数组声明、遍历，Arrays类常用方法

一、数组声明

（一）Java创建数组有三种方式：

第一种方式

int arr [ ] = new int [5] ;

属于动态创建，声明并创建内存空间，等待赋值。

第二种方式

int a[ ] = new int [ ] { 1,2,3,4,5 };

也是动态创建，声明并创建内存空间，并赋值。

第三种方式

int [ ] x = {6,7,8,9,10};

属于静态创建，声明并直接赋值，创建内存空间。

public static void main(String[] args) {

    //第一种  
    int arr [ ]  = new int [5] ;   
    arr [0] = 1;
    arr [1] = 2;

    //第二种
    int  a[ ] = new int [ ] { 1,2,3,4,5 }; 

    //第三种
    int [ ] x = {6,7,8,9,10};   
}

（二）二维数组的三种定义方式：

二维数组可以理解为：数组中的数组，数组里面储存的还是数组

        //第一种方式：
       int a[][]={{1,2,3},{4,5,6}};


        //第二种方式；
       int[][] ints = new int[4][2];
       ints[i][j] =__; //分别赋值

        //第三种方式：第二维的长度可以动态申请
       int[][] arr3 = new int[5][];//五行的长度
       for(int i=0; i<arr3.length; ++i){
           arr3[i]=new int[i+1];   //列的长度每次都变化。每次都要重新申请空间(长度)
           for(int j=0; j<arr3[i].length; ++j)
               arr3[i][j]= i+j;

        }

二、二维数组的遍历

二维数组的遍历
二维数组中存储四个一维数组，每个一维数组长度不同

遍历：for循环，遍历二维数组
遍历过程中，for循环遍历一维数组

二维数组的使用举例：
定义一个二维数组 int[ ][ ] arr = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}, {10}};
求数组元素的和

public class ThroughArrays {
    public static void main(String[] args) {
    int[][] arr = new int[3][4];
    System.out.println(arr);        //打印 [[I@50cbc42f
    System.out.println(arr[2]);     //打印 [I@75412c2f
    System.out.println(arr[2][3]);  //打印 0

    int[][] arr2 = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}, {10}};
    System.out.println(arr2[2][1]); //打印7
    System.out.println(arr2[3][0]); //打印10

    int sum = add(arr2);//调用求和函数
    System.out.println("sum=" + sum);//输出和 sum = 55

    }

   public static int add(int[][] arr) {
        int sum = 0;
        //遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            //遍历一维数组
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        return sum;
    }
}

三、Arrays类的常用方法

3.1 Arrays.fill() 填充替换

Arrays.fill(Object[] array, Object obj)
用指定元素填充整个数组（会替换掉数组中原来的元素）

Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 9, 9]

Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)
用指定元素填充数组，从起始位置到结束位置，取头不取尾（会替换掉数组中原来的元素）

Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 0, 2, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 3, 4]

把第一位到第三位的值替换为9

3.2 Arrays.sort() 数组元素排序

Arrays.sort(Object[ ] array)
对数组元素进行排序（串行排序）

int[] a=new int[]{3,2,5,4,1};
Arrays.sort(a);
for (int i = 0; i <a.length ; i++) {
    System.out.print(a[i]+" ");
}

给所有数正序排列
输出结果：1 2 3 4 5

Arrays.sort(Object[ ] array, int fromIndex, int toIndex)
对数组元素的指定范围进行排序（串行排序）

int []arr = {3,2,1,5,4};
Arrays.sort(arr,1,3);
output(arr);

给第1位（0开始）到第3位（不包括）排序
输出结果：3 1 2 5 4

Arrays.parallelSort(T[ ] array)

1.Arrays.parallelSort() 数组元素(并行)排序
2.对数组元素进行排序（并行排序），当数据规模较大时，会有更好的性能

String[] data = {"1", "4", "3", "2"};
Arrays.parallelSort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

3.3 Arrays.copyOf() 数组元素拷贝

Arrays.copyOf(T[] original, int newLength)
拷贝数组，其内部调用了 System.arraycopy() 方法，从下标0开始，如果超过原数组长度，会用null进行填充

Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOf(data1, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data2 = Arrays.copyOf(data1, 5);
System.out.println(Arrays.toString(data2)); // [1, 2, 3, 4, null]

Arrays.copyOfRange(T[] original, int from, int to)
拷贝数组，指定起始位置和结束位置，如果超过原数组长度，会用null进行填充

Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOfRange(data1, 0, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data2 = Arrays.copyOfRange(data1, 0, 5);
System.out.println(Arrays.toString(data2)); // [1, 2, 3, 4, null]

3.4 Arrays.equals() 比较数组是否相等(哈希)

Arrays.equals(Object[] array1, Object[] array2)
判断两个数组是否相等，实际上比较的是两个数组的哈希值，即 Arrays.hashCode(data1) == Arrays.hashCode(data2)

Integer[] data1 = {1, 2, 3};
Integer[] data2 = {1, 2, 3};
System.out.println(Arrays.equals(data1, data2)); // true

输出结果：true
Arrays.deepEquals(Object[] array1, Object[] array2)
判断两个多维数组是否相等，实际上比较的是两个数组的哈希值，即 Arrays.hashCode(data1) == Arrays.hashCode(data2)

Integer[][] data1 = {{1,2,3}, {1,2,3}};
Integer[][] data2 = {{1,2,3}, {1,2,3}};
System.out.println(Arrays.deepEquals(data1, data2)); // true

输出结果：true

3.5 Arrays.toString() 转换格式

Arrays.toString(Object[] array)
返回数组元素的字符串形式

Integer[] data = {1, 2, 3};
System.out.println(Arrays.toString(data)); // [1, 2, 3]

Arrays.deepToString(Object[] array)
返回多维数组元素的字符串形式

Integer[][] data = {{1, 2, 3}, {1, 2, 3}};
System.out.println(Arrays.deepToString(data)); // [[1, 2, 3], [1, 2, 3]]

3.6 Arrays.asList() 将数组转化为list

Arrays.asList(T… data)
注意：该方法返回的是Arrays内部静态类ArrayList，而不是我们平常使用的ArrayList,，该静态类ArrayList没有覆盖父类的add, remove等方法，所以如果直接调用，会报UnsupportedOperationException异常
也可以使数组[但是数组类型不能是（byte,short,int,long,float,double,boolean），可以是Integer等。

List<String> ebsCodes = Arrays.asList("USERNAME","REAP","NLS");

String[] s = {"aa","bb","cc"};
List<String> strlist = Arrays.asList(s);

如果将基本数据类型的数组作为参数传入，
该方法会把整个数组当作返回的List中的第一个元素

int[] data = {1, 2, 3};
List<int[]> list = Arrays.asList(data);
System.out.println(list.size()); // 1
System.out.println(Arrays.toString(list.get(0))); // [1, 2, 3]

参考引用：