Array，Arrays

Array

属于object类，用来存放一组数据的数据结构，数组是最基本的一种数据结构但不是基本数据类型，数组是相同数据类型组成的集合，数组中的元素按线性顺序排序

      //省略格式静态初始化
      int[] a = {6,2,6,8};
//静态初始化标准格式
      int[] a = new int[]{1,2,3,4,5};
//可拆分为两个步骤
      int[] a;
      a = new int[]{1,2,3,4,5};

//错误，省略格式不能拆成两个步骤
// int[] a;
// a = {6,2,6,8};
      int[] arr = new int[3];
      System.out.println(arr);  //地址值

数组作为方法参数

数组作为方法参数传递，传递的参数是数组内存的地址。

public static void main (String[]args){
    int[] result = calculate(10, 20, 30);
    System.out.println("main方法接收到的返回值数组是：");
    System.out.println(result); // 地址值
    System.out.println("总和：" + result[0]);
    System.out.println("平均数：" + result[1]);
}


public static int[] calculate ( int a, int b, int c){
    int sum = a + b + c; // 总和
    int avg = sum / 3; // 平均数
    // 两个结果都希望进行返回

    // 需要一个数组，也就是一个塑料兜，数组可以保存多个结果
    /*
    int[] array = new int[2];
    array[0] = sum; // 总和
    array[1] = avg; // 平均数
    */
    int[] array = {sum, avg};
    System.out.println("calculate方法内部数组是：");
    System.out.println(array); // 地址值
    return array;
}

数组作为方法的参数，传递进去的其实是数组的地址值。

数组作为方法的返回值，返回的其实也是数组的地址值。

二维数组

存放数组的数组

int[][] a = new int[3] [2];

外围数组长度为3，内部3个数组长度为2，一共有4个数组，内部数组默认值0，外围数组保存的是内部数组的地址。

int[][] a = new int[3] [];

只建一个外围数组长度3，3个位置都是null，之后可以建新数组放入内部。

**Arrays **

转换为String

Arrays.toString（数组）把数组数据连接成字符串。

Arrays.deepToString(数组) 把多维数组转成字符串

int[] intArray = {10, 20, 30};
// 将int[]数组按照默认格式变成字符串
String intStr = Arrays.toString(intArray);
System.out.println(intStr); // [10, 20, 30]


int[][][] dp = {{{1,2},{3,4}},{{5,6},{7,8}},{{9,10},{11,12}}};
System.out.println(Arrays.deepToString(dp)); //[[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]

排序

Arrays.sort(） 数组排序基本类型：优化的快速排序；引用类型：优化的合并排序。

Arrays.sort(T[] a, Comparator<? super T> c)

int[] nums = new int[]{1,-2,-3,4,-7,6,-5};
Arrays.sort(nums);  //自然排序
System.out.println(Arrays.toString(nums));  //[-7, -5, -3, -2, 1, 4, 6]

//重写Compare方法需要引用类型，故需要转换为Integer流
int[] arr1 = Arrays.stream(nums).boxed().sorted((o1, o2) -> o2 - o1).mapToInt(Integer::intValue).toArray();
System.out.println(Arrays.toString(arr1)); //[6, 4, 1, -2, -3, -5, -7]

//引用类型Array可通过重写Compare方法或使用Collections.reverseOrder()
Integer[] arr2 = new Integer[]{1,-2,-3,4,-7,6,-5};
Arrays.sort(arr2, Collections.reverseOrder());
System.out.println(Arrays.toString(arr2));  //[6, 4, 1, -2, -3, -5, -7]

备注：

1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。

二维数组的排序

二维数组的元素是引用类型，故可以直接重写compare方法

按照内部数组第一个元素排序

int[][] a1 = new int[][]{{1, 3}, {1, 2}, {4, 5}, {3, 7}};
Arrays.sort(a1, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
        return o1[0] - o2[0];
    }
});
System.out.println(Arrays.deepToString(a1)); //[[1, 3], [1, 2], [3, 7], [4, 5]]

Arrays.binarySearch（数组，目标值） ：二分法查找，在有序数组中查找目标值下标，找不到返回 -1

int[] nums = new int[]{1,-2,-3,4,-7,6,-5};
System.out.println(Arrays.binarySearch(nums,-2)); //1

复制

public static int[] copyOf(int[] original, int newLength)：复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 0。当且仅当指定长度大于原数组的长度时，这些索引存在。

// 原始数组
     int[] originalArray = {1, 2, 3, 4, 5};
     // 使用 Arrays.copyOf() 复制数组
     int[] copiedArray = Arrays.copyOf(originalArray, originalArray.length);

通过 Arrays.copyOf() 方法复制的数组是一个全新的数组，与原始数组完全独立，修改原始数组的值并不会影响到复制后的数组。

arraycopy方法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：

将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

• src - 源数组。
• srcPos - 源数组中的起始位置(起始索引)。
• dest - 目标数组。
• destPos - 目标数据中的起始位置。
• length - 要复制的数组元素的数量。

// 源数组
int[] sourceArray = {1, 2, 3, 4, 5};
// 目标数组，长度至少为源数组的长度
int[] destinationArray = new int[sourceArray.length];
// 使用 arraycopy 方法将源数组的元素复制到目标数组
System.arraycopy(sourceArray, 0, destinationArray, 0, sourceArray.length);
System.out.println(Arrays.toString(destinationArray)); //[1, 2, 3, 4, 5]

注意：

• System.arraycopy() 并不返回新的数组，而是在已存在的目标数组上进行原地复制。
• Arrays.copyOf() 返回一个新的数组，原数组不受影响。

如果在方法内运行需要注意Arrays.copyOf()并不会改变原来的数组

转换为List

Arrays.asList( )：注意该方法的返回值是java.util.Arrays类中一个私有静态内部类java.util.Arrays.ArrayList，它并非java.util.ArrayList类。

java.util.Arrays.ArrayList类具有set()，get()，contains()等方法，但是不支持添加add()或删除remove()方法，调用这些方法会报错。

//因为list中是包装类。所以数组创建时也需要使用包装类
Integer[] num = new Integer[]{1,2,3,4,5,6,7,8,9};
List<Integer> ans1 = Arrays.asList(num);
//此时得到的list 不能 使用 add() 与 remove()方法；
// 解决办法：
//创建一个新的list 对象，将残缺的list加入进去
List<Integer> list = new ArrayList<>(ans1);
list.add(1);