7.数组

一、数组的概述

1.定义

　　多个相同数据类型的数据按照一定的顺序排列的集合，使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.特点

　　①数组是有序排列的；

　　②数组本身是引用数据类型，数组中的元素既可以是基本数据类型，也可以是引用数据类型；

　　③创建数组会在内存中开辟一整块连续的空间，而数组通过数组名引用的是这块连续空间的首地址；

　　④数组一旦初始化完成，其长度就确定了；数组的长度一旦确定，就不能修改；

　　⑤通过索引来访问数组中的元素，速度很快

3.分类

按照维数：一维数组、二维数组、多维数组

按照数组中元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

二、一维数组

1.一维数组的声明和初始化

public class test {
    public static void main(String[] args) {
        //数组的声明
        int[] arr1;
        String arr2[];
        //数组的静态初始化
        arr1 = new int[]{1, 2, 3};
        //数组的动态初始化
        arr2 = new String[4];
        //声明+初始化
        int[] arr3 = new int[3];
        //类型推断
        String[] arr4 = {"str1", "str2", "str3"};
    }
}

2.访问一维数组中的元素

public class test {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        //访问数组中的元素：索引访问
        System.out.println(arr[2]);//3
    }
}

3.一维数组的长度

public class test {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        //数组的长度：调用数组对象的length属性
        System.out.println(arr.length);//5
    }
}

4.一维数组的遍历

public class test {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        //数组的遍历：循环
        for (int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

5.一维数组的默认初始化值

public class test {
    public static void main(String[] args) {
        //一维数组的默认初始化值
        //整形
        byte[] arr1 = new byte[3];
        short[] arr2 = new short[3];
        int[] arr3 = new int[3];
        long[] arr4 = new long[3];
        System.out.println(arr1[1]);//0
        System.out.println(arr2[1]);//0
        System.out.println(arr3[1]);//0
        System.out.println(arr4[1]);//0

        //浮点型
        float[] arr5 = new float[3];
        double[] arr6 = new double[3];
        System.out.println(arr5[2]);//0.0
        System.out.println(arr6[2]);//0.0

        //字符型
        char[] arr7 = new char[3];
        if (arr7[0] == '\u0000'){
            System.out.println("hello！");//hello!
        }

        //boolean型
        boolean[] arr8 = new boolean[3];
        System.out.println(arr8[1]);//false

        //引用数据类型
        String[] arr9 = new String[3];
        System.out.println(arr9[0]);//null
    }
}

6.一维数组的内存解析

 

 三、二维数组

1.二维数组的声明和初始化

public class test {
    public static void main(String[] args) {
        //静态初始化
        String[][] arr1 = new String[][]{{"张三", "李四"}, {"小明", "小花", "小王"}};
        //动态初始化1
        int[][] arr2 = new int[3][2];
        //动态初始化2
        int[][] arr3 = new int[3][];
        //类型推断
        int[][] arr4 = {{1, 2}, {1, 2, 5}};
    }
}

2.访问二维数组中的元素

public class test {
    public static void main(String[] args) {
        //访问二维数组的元素
        String[][] arr1 = new String[][]{{"张三", "李四"}, {"小明", "小花", "小王"}};
        int[][] arr2 = new int[3][2];
        int[][] arr3 = new int[3][];
        System.out.println(arr1[0][1]);//李四
        System.out.println(arr2[2][1]);//0
        System.out.println(arr3[1]);//null
//        System.out.println(arr3[0][1]);//报异常：NullPointerException
    }
}

3.二维数组的长度

public class test {
    public static void main(String[] args) {
        //二维数组的长度
        String[][] arr1 = new String[][]{{"张三", "李四"}, {"小明", "小花", "小王"}};
        System.out.println(arr1.length);//2
        System.out.println(arr1[1].length);//3
    }
}

4.遍历二维数组

public class test {
    public static void main(String[] args) {
        //二维数组的遍历
        String[][] arr1 = new String[][]{{"张三", "李四"}, {"小明", "小花", "小王"}};
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.println(arr1[i][j]);
            }
        }
    }
}

5.二维数组的默认初始化值

public class test {
    public static void main(String[] args) {
        //二维数组的默认初始化值
        //方式一：
        int[][] arr1 = new int[3][2];
        /*
        外层元素：地址值
        内层元素：跟一维数组的初始化情况相同
         */
        System.out.println(arr1[0]);//[I@4e50df2e
        System.out.println(arr1[0][1]);//0

        //方式二：
        int[][] arr2 = new int[3][];
        /*
        外层元素：null
        内层元素：不存在，无从谈起；强行调用，报错
         */
        System.out.println(arr2[1]);//null
//        System.out.println(arr2[1][0]);//NullPointerException
    }
}

6.二维数组的内存解析

 

 四、数组中的常见算法

1.数组元素的赋值

打印10行的“杨辉三角”：

public class test {
    public static void main(String[] args) {
        //1.声明并初始化二维数组
        int[][] yangHui = new int[10][];
        //2.给数组的元素赋值
        for(int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i + 1];
            //2.1 给首末元素赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            //2.2 给每行的非首末元素赋值
            for(int j = 1;j < yangHui[i].length - 1;j++){
                yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
            }
        }
        //3.遍历二维数组
        for(int i = 0;i < yangHui.length;i++){
            for(int j = 0;j < yangHui[i].length;j++){
                System.out.print(yangHui[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

2.数值型的数组求最大值、最小值、总和、平均值

public class test {
    public static void main(String[] args) {
        //定义一个整形数组，数组中有10个元素，且每一个元素都是随机的两位数
        int[] arr = new int[10];
        int num;
        for (int i = 0; i < arr.length; i++) {
            num = (int)(Math.random() * (99 - 10 + 1) + 10);
            arr[i] = num;
        }
        //遍历数组中的元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //求最大值
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("最大值为：" + max);//最大值为：93

        //求最小值
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("最小值为：" + min);//最小值为：10

        //求总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总和为：" + sum);//总和为：597

        //求平均值
        int avg = sum / arr.length;
        System.out.println("平均值为：" + avg);//平均值为：49
    }
}

3.数组的赋值和复制

数组的赋值：

　　将数组1的地址值赋给数组2，使得数组1和数组2同时指向了堆空间中的同一个对象实体。

数组的复制：

　　完全copy一份，相当于堆空间中创建一个新的对象实体。

public class test {
    public static void main(String[] args) {
        //数组的复制
        int[] arr1 = new int[]{1, 2, 5, 6};
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
            System.out.println(arr2[i]);
        }
    }
}

 

 4.数组的反转

public class test {
    public static void main(String[] args) {
        //数组的反转
        int[] arr = new int[]{2, 5, 8, 3};
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

5.二分法查找

public class test {
    public static void main(String[] args) {
        //二分法查找
        int[] arr = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int dest = 79;
        int start = 0;
        int end = arr.length - 1;
        boolean isFlag = true;
        while (start <= end){
            int middle = (start + end) / 2;
            if (dest == arr[middle]){
                System.out.println("找到了数组中的元素, 其索引为：" + middle);
                isFlag = false;
                break;
            }else if (dest < arr[middle]){
                end = middle - 1;
            }else {
                start = middle + 1;
            }
        }
        if (isFlag){
            System.out.println("很遗憾，没有找到指定元素");
        }
    }
}

6.十大排序算符

 

 手写冒泡排序：

public class test {
    public static void main(String[] args) {
        //手写冒泡排序
        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");//-98    -21    0    32    32    33    43    64    76    99
        }
    }
}

五、Arrays工具类的使用

1.理解：

①属于java.util包下的工具类；

②里面定义了许多操作数组的方法；

 

 2.使用

public class test {
    public static void main(String[] args) {
        //Arrays工具类的使用
        int[] arr1 = new int[]{1, 2, 3, 4};
        int[] arr2 = new int[]{1, 2, 3, 4};

        //equals:判断两个数组是否相等
        boolean equals = Arrays.equals(arr1, arr2);
        System.out.println(equals);//true

        //toString:输出数组信息
        System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]

        //fill:将指定值填充到数组中
        Arrays.fill(arr2, 10);
        System.out.println(Arrays.toString(arr2));//[10, 10, 10, 10]

        //sort:对数组进行排序
        int[] arr = new int[]{2, 5, 8, 1, 28, 23};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//[1, 2, 5, 8, 23, 28]

        //binarySearch:查找数组中的元素，并返回索引
        int dest = 28;
        int index = Arrays.binarySearch(arr, dest);
        if (index >= 0) {
            System.out.println(index);//5
        }else {
            System.out.println("未找到");
        }
    }
}

六、数组中的常见异常

1.数组角标越界：ArrayIndexOutOfBoundsException

public class test {
    public static void main(String[] args) {
        int[] arr = new int[3];
//        System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
    }
}

2.空指针异常：NullPointerException

public class test {
    public static void main(String[] args) {
        int[] arr = new int[3];
//        //情况一：
//        arr = null;
//        System.out.println(arr[0]);//NullPointerException

        //情况二：
        int[][] arr1 = new int[3][];
        System.out.println(arr1[1][0]);//NullPointerException
    }
}

 

 

 

作者：Java之美

日期：2020-03-28

来源：https://www.cnblogs.com/897463196-a/p/12587695.html