数组及Arrays工具类

• 1. 数组的定义
• 2. 数据的特点
• 3. 数组初始化
• • 3.1 动态初始化
  • 3.2 静态初始化
• 4. 数组的遍历
• • 4.1 for循环遍历
  • 4.2 增强for循环遍历
  • 4.3 Arrays.toString()
• 5.Arrays工具类的使用
• • 5.1 Arrays.toString()
  • 5.2 Arrays.equals()
  • 5.3 Arrays.sort() 排序方法

数组是相同类型数据的有序集合

1. 长度确定
2. 同一个数组内数据类型一致
3. 数组类型可以是任意类型，包括基本数据类型和引用数据类型
4. 数组有索引，索引从0开始到数组的长度-1结束
5. 数组变量属于引用数据类型，数组也是对象，数组中的每个元素相当于该对象的成员变量，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[数组长度];
数组存储的数据类型 数组名字[] = new 数组存储的数据类型[数组长度];
//定义一个长度为5的int类型数组
int[] arr = new int[5];

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
//定义存储1，2，3，4，5整数的数组容器
int[] arr = new int[]{1,2,3,4,5};
//静态初始化省略格式
int[] arr = {1,2,3,4,5}

       	int[] arr = {3,6,9,5,4,2,1};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
 // 执行结果：3695421

        int[] arr = {3,6,9,5,4,2,1};
        for (int i : arr) {
            System.out.print(i);
        }
 // 执行结果：3695421

        int[] arr = {3,6,9,5,4,2,1};
        System.out.println(Arrays.toString(arr));
 // 执行结果：[3, 6, 9, 5, 4, 2, 1]

import java.util.Arrays;

public class Code06 {
    public static void main(String[] args) {
        // 给定一个数组
        int[] arr = {3,6,9,5,4,2,1};
        // Arrays.sort：升序排序
        // Arrays.toString:查看数组所有元素
        // Arrays.binarySearch:二分法查找：找出指定数组中的指定元素对应的索引
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 9]
        System.out.println(Arrays.binarySearch(arr,4));// 返回下标3
        // 数组复制
        int[] newArr1 = Arrays.copyOf(arr,4);
        System.out.println(Arrays.toString(newArr1));//[1, 2, 3, 4]
        // 区间复制
        int[] newArr2 = Arrays.copyOfRange(arr,1,4);
        System.out.println(Arrays.toString(newArr2));//[2, 3, 4]
        // equals比较两个数组
        System.out.println(Arrays.equals(newArr1,newArr2));
        // 数组快速填充
        Arrays.fill(arr,6);
        System.out.println(Arrays.toString(arr));//[6, 6, 6, 6, 6, 6, 6]
    }
}

1. 源码真是长见识，废话不多说，直接上代码

    public static String toStr(int[] arr){
        if (arr == null){
            return null;
        }
        int len = arr.length-1;
        if (len == -1){
            return "[]";
        }
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; ; i++) {
            stringBuilder.append(arr[i]);
            // 莫名其妙的知识点增加了一个，原来for循环的布尔表达式还可以写在循环体里
            if (i == len){
                return stringBuilder.append("]").toString();
            }
            stringBuilder.append(",");
        }
    }

1. 源码里for循环以及内部if语句省略了｛｝

    public static boolean myEquals(int[] arr1,int[] arr2){
        // 同一个地址必然是同一个数组
        if (arr1 == arr2){
            return true;
        }
        // 不是同一个地址，若其中一个指向null，必然不是同一个数组
        if (arr1 == null || arr2 == null){
            return false;
        }
        int len = arr1.length;
        // 长度不一致为false
        if (arr2.length != len){
            return false;
        }
        //长度一致比较元素
        for (int i = 0; i < len; i++) {
            if (arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }

1. 源码里直接调用了DualPivotQuicksor.sort()，该方法里有一个常量QUICKSORT_THRESHOLD=286，如果要排序的数组的长度小于该常数，则优先使用快速排序而不是归并排序。排序还没学习到，暂时放弃。