静态方法，Arrays类，二维数组

一、静态方法

静态方法属于类的，可以直接使用类名.方法名()调用。

静态方法的声明

访问修饰符 static 类型 方法名(参数列表)

{

         //方法体

}

方法的作用：一个程序分解成几个方法，有利于快速调试程序，也有利于提高程序代码的利用率。因为方法是可以多次被调用的，调用次数和调用场合没有限制。

方法分类：①返回值为（空）void的方法②带具体返回类型的方法③不带参数的方法④带参数的方法

方法的返回值：如果方法中有返回值，方法中必须使用关键字return返回该值，返回值类型为该方法所定义的返回值类型。

①不带返回值的方法

public class BubbleSort{
    public static void main(String []argas)
    {
        int[] array={80,53,12,90,35,22,65,45,82,33};
        bubble(array);
        print(array);
    }
    
    //冒泡方法
    public static void bubble(int[] array)
    {
        //N个数比较的轮数为N-1次
        for(int i=0;i<array.length-1;i++)
        {
            //每一轮比较的次数为N-1-i次
            for(int j=0;j<array.length-i-1;j++)
            {
                //比较相邻的2个数，小靠前
                if(array[j]>array[j+1])
                {
                    //两个数做交换，通过设置临时变量
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }

    }
    
    //打印输出方法
    public static void print(int[] array)
    {
        //把排好序的数组输出
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+",");
        }
    }
}

②带返回值的方法

public class BubbleSort{
    public static void main(String []argas)
    {
        int[] array={80,53,12,90,35,22,65,45,82,33};
        print(bubble(array));
    }
    
    //冒泡方法
    public static int [] bubble(int[] array)
    {
        //N个数比较的轮数为N-1次
        for(int i=0;i<array.length-1;i++)
        {
            //每一轮比较的次数为N-1-i次
            for(int j=0;j<array.length-i-1;j++)
            {
                //比较相邻的2个数，小靠前
                if(array[j]>array[j+1])
                {
                    //两个数做交换，通过设置临时变量
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }
    
    //打印输出方法
    public static void print(int[] array)
    {
        //把排好序的数组输出
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+",");
        }
    }
}

③方法复用及不带参数的方法

public class BubbleSort{
    public static void main(String []argas)
    {
        int[] array={80,53,12,90,35,22,65,45,82,33};
        show1();
        print(array);
        show2();
        print(bubble(array));
        
        int[] array1={80,25,12,30,35,22,55,45,82,33};        
        show1();
        print(array1);
        show2();
        print(bubble(array1));
    }
    
    public static void show1()
    {
        System.out.print("排序前:");
    }
    
    public static void show2()
    {
        System.out.print("排序后:");
    }
    
    //冒泡方法
    public static int [] bubble(int[] array)
    {
        //N个数比较的轮数为N-1次
        for(int i=0;i<array.length-1;i++)
        {
            //每一轮比较的次数为N-1-i次
            for(int j=0;j<array.length-i-1;j++)
            {
                //比较相邻的2个数，小靠前
                if(array[j]>array[j+1])
                {
                    //两个数做交换，通过设置临时变量
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }
    
    //打印输出方法
    public static void print(int[] array)
    {
        //把排好序的数组输出
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+",");
        }
        System.out.println();
    }
}

二、Arrays类

Java的jdk中提供了一个Arrays工具类，此类专门为程序员操作数组提供了很多专有方法，通过方法的调用可以对数组进行赋值，排序，比较，查找元素等功能。

在jdk的api中搜索arrays可以看到该类的用法

就举几个例子

import java.util.Arrays;
public class ArraysUtilDemo{
    public static void main(String []argas)
    {
        int[] arraySrc1={6,8,9,16,35,90}; 
        //拷贝数组
        int[] arrayDes1=Arrays.copyOf(arraySrc1,10);
        for(int i=0;i<arrayDes1.length;i++)
        {
            System.out.print(arrayDes1[i]+" ");
        }
        
        System.out.println("
**************************");
        //拷贝指定数组中的指定范围内的数据
        int[] arrayDes2=Arrays.copyOfRange(arraySrc1,2,4);
        for(int i=0;i<arrayDes2.length;i++)
        {
            System.out.print(arrayDes2[i]+" ");
        }
        
        System.out.println("
**************************");
        int[] arraySrc2={8,6,10,16,35,90}; 
        boolean flag=Arrays.equals(arraySrc1,arraySrc2);
        System.out.print(flag);
        
        System.out.println("
**************************");
        //数组填充
        int[] arrayDes3=new int[10];
        Arrays.fill(arrayDes3,10);
        for(int i=0;i<arrayDes3.length;i++)
        {
            System.out.print(arrayDes3[i]+" ");
        }
        
        System.out.println("
**************************");
        //对数组进行排序
        Arrays.sort(arraySrc1);
        for(int i=0;i<arraySrc1.length;i++)
        {
            System.out.print(arraySrc1[i]+" ");
        }
        
        System.out.println("
**************************");
        //二分法查找
        int x=Arrays.binarySearch(arraySrc1,9);
        System.out.print(x);
        
        System.out.println("
**************************");
        //使用System类的方法来拷贝数组
        int[] arrayDes4=new int[10];
        System.arraycopy(arraySrc1,0,arrayDes4,2,5);
        for(int i=0;i<arrayDes4.length;i++)
        {
            System.out.print(arrayDes4[i]+" ");
        }
    }
}

三、二维数组

①   可以看成以数组为元素的数组

②   Java中二维数组的声明和初始化应按照从高维到低维的顺序排列

示例

int[][] arr1=new int[10][];//第二维长度未定

int[][] arr2=new int[10][20];//第二维长度确定

☆虽然这两个数组的创建有区别，但系统为它们分配的堆内存空间大小是一样的。

对于任何类型的二维数组而言，第一维的大小决定了二维数组对象的大小，因为二维数组的成员是数组引用，数组引用本身大小是固定的。

初始化二维数组

①   静态初始化：int[][] arr={{1,2},{3,4,5},{6,7,8,9}};

②   动态初始化：

String[][] arrStr;                                       //声明

arrStr=new String[3][];                          //创建，分配内存

arrStr[0]=new String[2];                       //为高维初始化

arrStr[1]=new String[3];

arrStr[2]=new String[4];

arrStr[0][0]=new String(“abc00”);     //为低维初始化

arrStr[0][1]=new String(“abc01”);

arrStr[1][0]=new String(“abc10”);

arrStr[1][1]=new String(“abc11”);

arrStr[1][2]=new String(“abc12”);

arrStr[2][0]=new String(“abc20”);

arrStr[2][1]=new String(“abc21”);

arrStr[2][2]=new String(“abc22”);

arrStr[2][3]=new String(“abc23”);

public class ArrayDemo2{
    public static void main(String []args){
        int[][] arr=new int[3][];
        //每个高维的数组指向一个低维的int数组
        arr[0]=new int[2];
        arr[1]=new int[3];
        arr[2]=new int[4];
        
        //给低维数组进行赋值
        arr[0][0]=1;
        arr[0][1]=2;
        arr[1][0]=3;
        arr[1][1]=4;
        arr[1][2]=5;
        arr[2][0]=6;
        arr[2][1]=7;
        arr[2][2]=8;
        arr[2][3]=9;
        
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr[i].length;j++)
            {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }
}