三、数组

数组的概述

一维数组

一维数组的知识点

数组的初始化

数组的索引、长度

遍历数组

数组的默认值（声明了没赋值，打印数组是什么默认值）

内存简图：

内存解析：

多维数组

二维数组知识点

二维数组的声明和初始化

二维数组的索引、长度

二维数组遍历 两层for循环

二维数组的初始值

二维数组内存解析：

数组中常见算法

数据结构

• 杨辉三角

public static void main(String[] args) {

        int[][] yangHui = new int[10][];
        for (int i=0;i<yangHui.length;i++){
            yangHui[i] = new int[i+1];
        }
        yangHui[0][0]=1;
        for (int i=1;i<yangHui.length;i++){
            yangHui[i][0]=1;
            yangHui[i][i]=1;
            for (int j=1;j<i;j++){
                yangHui[i][j]=yangHui[i-1][j-1]+yangHui[i-1][j];
            }
        }
        System.out.println("-打印杨辉三角-");
        for (int i=0;i<yangHui.length;i++){
            for (int j=0;j<yangHui[i].length;j++){
                System.out.print(yangHui[i][j]+"\t");
            }
            System.out.println();
        }
    }

• 求数组的总和、最大、最小、平均值

public static void main(String[] args) {


        //随机数组
        //定义数组、sum、min、max、avg
        int[] arr = new int[10];
        int sum=0;
        int min,max;
        float avg;

        // 给数组附上随机值
        for (int i=0;i<arr.length;i++) {
            //给元素先赋值 1-100
            arr[i] = (int) ((Math.random() * 90) + 10);
            //求总和
            sum +=arr[i];

        }
        //求平均数
        avg = sum/10f;
        // 求最大、最小值
        min = arr[0];
        max = arr[0];
        for (int i=0;i<arr.length;i++){
            if (arr[i]>=max){
                max = arr[i];
            }
            if (arr[i]<=min){
                min = arr[i];
            }
        }
        //输出结果
        System.out.println("数组："+Arrays.toString(arr));
        System.out.println("总和："+sum);
        System.out.println("平均数："+avg);
        System.out.println("最大值："+max);
        System.out.println("最小值："+min);
    }

• 数组的复制

public static void main(String[] args) {


        int[] arr1 = new int[]{2,3,5,7,11,13,17,19};
        System.out.println(Arrays.toString(arr1));
        // 不能称为数组的复制，是把arr1的地址值赋给arr2
        int[] arr2 = arr1;
        for (int i=0;i<arr2.length;i++){
            if (i%2==0){
                arr2[i]=i;
            }
        }
        System.out.println(Arrays.toString(arr2));
        System.out.println(Arrays.toString(arr1));

int[] arr2 = arr1;不是复制数组，是把是把arr1的地址值赋给arr2

复制数组先要创建一个新的数组

复制数组：

public static void main(String[] args) {


        int[] arr1 = new int[]{2,3,5,7,11,13,17,19};
        System.out.println(Arrays.toString(arr1));

        //数组的复制
        int[] arr3 = new int[arr1.length];
        for (int i=0;i<arr1.length;i++){
            arr3[i]=arr1[i];
        }
        for (int i=0;i<arr3.length;i++){
            if (i%2==0){
                arr3[i]=i;
            }
        }
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr3));
}

• 数组的反转

public static void main(String[] args) {

        // 数组的反转
        String[] nickname = new String[]{"JJ","DD","MM","GG","SS","AA"};
        // 定义一个中间数，进行数据交换
        String temp;
        for (int i=0;i<nickname.length/2;i++){
            temp = nickname[i];
            nickname[i]=nickname[nickname.length-1-i];
            nickname[nickname.length-1-i]=temp;
        }
        System.out.println(Arrays.toString(nickname));//输出：[AA, SS, GG, MM, DD, JJ]

    }

• 数组的查找（线性查找、二分法查找）

线性查找：一个一个往下找

public static void main(String[] args) {

        //查找（或叫搜索）
        // 线性查找 ：一个一个往下找
        String[] nickname = new String[]{"JJ","DD","MM","GG","SS","AA"};

        // 是否找到相同元素的标识
        boolean isFlag = true;
        String desc ="DD";
        for (int i=0;i<nickname.length;i++){
            if (desc.equals(nickname[i])){
                System.out.println("找到了相同的元素，下标为"+i);
                isFlag = false;
                break;
            }
        }
        if (isFlag==true){
            System.out.println("没有相同的元素");
        }

二分法查找(前提：所要查找的数组必须是有序的)

public static void main(String[] args) {
        // 二分法查找
        // 前提：所要查找的数组必须是有序的
        int[] numbers= new int[]{-23,-13,-4,2,9,34,99,100}; //从小到大排列
        int target=99;
        // 初始时的首位索引值
        int head = 0;
        // 初始时的末尾索引值
        int end = numbers.length-1;
        boolean isFlag1 = true;
        while (head<=end){
            int mid = (head+end)/2;
            if (numbers[mid] == target){
                System.out.println("找到了相同元素，下标为："+mid);
                isFlag1 = false;
                break;
            }else if (numbers[mid]>target){
                end = mid -1;
            }else {//numbers[mid]<target
                head = mid+1;
            }
        }
        if (isFlag1){
            System.out.println("没有相同的元素");
        }
}

• 数组元素中的排序算法

冒泡排序（要会写代码）

public static void main(String[] args) {
        //冒泡排序
        int[] numbers= new int[]{-23,0,-4,2,-9,134,99,100};
        //相邻两个数比较，大的数往后移
        for (int i =0;i<numbers.length-1;i++){
            for (int j=0;j<numbers.length-1-i;j++){
                if (numbers[j]>numbers[j+1]){
                    int temp = numbers[j];
                    numbers[j] = numbers[j+1];
                    numbers[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(numbers));
  }

快速排序（了解思维）

排序算法性能对比

Arrays工具类的使用

public static void main(String[] args) {
        // 比较两个数组是否相等
        int[] arr1 = new int[]{-23, 0, -4, 2,-9};
        int[] arr2 = new int[]{-23, 0, -4, 2,-9};
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);

        // 输出数组的信息
        System.out.println(Arrays.toString(arr1));

        // 将指定值填充到数组中 :每个元素都替换成value
        Arrays.fill(arr1,15);
        System.out.println(Arrays.toString(arr1));

        // 排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        // 二分查找，前提是有序
        int[] arr3 = new int[]{-23,-13,-4,2,9,34,99,100};
        int index = Arrays.binarySearch(arr3,32);//负数表示没有这个数
        System.out.println(index);

    }

数组使用中的常见异常

空指针：地址值为null,没有指向堆