📋 个人简介

• 💖 作者简介：大家好，我是阿牛，全栈领域新星创作者。😜
• 🎉 支持我：点赞👍+收藏⭐️+留言📝
• 📣 系列专栏：重走 java 路🍁
• 💬格言：要成为光，因为有怕黑的人！🔥
  

---

前言

犹豫了好久，终于下定决心重学java了，之前的基础学的太浅了，我觉得很有必要重走java之路，将我不熟悉或者不知道的知识记录下来！那么就先从数组开始吧！

一维数组

初始化

//        静态初始化
        int[] num = new int[]{1,2,3,4};
//        静态初始化省略格式
        int[] nums = {1,5,6,7};
//        动态初始化
        String[] names = new String[5];

1
2
3
4
5
6
7

错误写法：

//        错误写法
        int[] arr1 = new int[];
        int[] arr2 = new int[3]{1,2,3};
1
2
3

数组元素的默认初始化
数组元素是整数 ： 0
数组元素是浮点型 ： 0.0
数组元素是char型 : 0或“\u000”,不是’0’
数组元素是boolean型 : false
数组元素是引用数据类型 ：null

二维数组

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。存数组的底层运行机制看，其实没有多维数组。

二维数组分为外层数组元素，内层数组元素,初始化方式这里不再记录：

        int[][] arr = new int[3][2];
//        外层元素 arr[0],arr[1]等；
//        内层元素 arr[0][0],arr[1][2]等
1
2
3

数组元素的默认初始化

针对于初始化方式一：比如： int [ ][ ] arr = new int [4][3];

• 外层元素的初始化值为：地址值。
• 内层元素的初始化值为：与一维数组初始化情况相同。

针对于初始化方式二：比如： int [ ][ ] arr = new int [4][ ];

• 外层元素的初始化值为：null
• 内层元素的初始化值为：不能调用，否则报错(空指针异常)。

注意：[ [ 代表是二维数组，[ 代表是一维数组！I 代表是int型。

二维数组内存图

Arrays工具类的使用

最常用的就是下面5种方法：

1.equals

我们可以看看equals的源码，我们自己也能写出来：

public static boolean equals(int[] a, int[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        return ArraysSupport.mismatch(a, a2, length) < 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12

2.toString

看看toString源码：

public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.fill
注：将数组里的所有值变为填充值

继续看源码：

public static void fill(int[] a, int val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }
1
2
3
4

4.sort

源码：

知道底层是个快速排序就ok!

5.binarySeach

注：二分查找的数组必须要有序，返回值是一个负数，这说明查找值不在数组中。

源码：

 public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }
1
2
3

private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

数组报错总结

1.数组角标越界异常：ArrayIndexOutOfBoundsException

2.空指针异常：NullPointerException

//        情况1
        int[] arr2 = new int[]{1,2,6};
        arr2 = null;
        System.out.println(arr2[0]); //空指针

//        情况2
        int[][] arr3 = new int[4][];
//        System.out.println(arr3[0]); //null
        System.out.println(arr3[0][0]); //空指针
1
2
3
4
5
6
7
8
9

结语

如果你觉得博主写的还不错的话，可以关注一下当前专栏，博主会更完这个系列的哦！也欢迎订阅博主的其他好的专栏。

🏰系列专栏
👉软磨 css
👉硬泡 javascript
👉flask框架快速入门