【Java|基础篇】全面解析数组,数组知识点汇总_java 数组

1.数组的概念

什么是数组？ 数组就是相同数据类型元素的集合。在内存中是一段连续的空间。在会使用到很多相同数据类型的变量时，使用数组可以更加方便，减少程序的代码量。

2.一维数组

3.一维数组的定义

数组的定义有3中方式,具体定义方式如下:

int[] arr1 = {1,2,3};
int[] arr2 = new int[]{1,2,3};
int[] arr3 = new int[3];
1
2
3

注意:arr1、arr2和arr3是引用变量.用来存放地址的哈希值，可以理解为地址。
int[]表示的是数据的类型，是一维数组。[]中间不需要加数字。
虽然也能像C语言那样 写成 int arr[] ={1,2,3} ,但是不推荐！

4.访问数组的元素

对于访问数组的元素,我们可以使用 数组名+[合法的下标] 对数组的元素进行访问.
注:合法的下标就是下标不能超过数组的长度,也不能是负数。
数组支持随机访问，即通过下标访问快速访问数组中任意位置的元素。
Java数组的下表是从0开始,对于一个有N个元素的数组来说，下标的合法位置就介于[0, N）不包含N,不能越界，否则会报出下标越界异常。
对于二维数组来说，同样可以使用下标来进行访问，不过要同时指正行和列。

5.遍历数组

遍历数组常见的方式有3种,for循环进行遍历,for each进行遍历以及toString进行遍历.对于数组的长度,Java给我们提供了一个简单的方法,直接通过数组名.length() 我们就可以直接得到数组的长度了.

for循环遍历数组

语法格式:
for (int i = 0; i < 数组名.length; i++) {
System.out.print(数组名[i]);
}

for循环遍历数组,就是通过循环,将下标从0开始一直到数组的最后一个元素打印出来.

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
1
2
3
4
5
6

for each遍历数组

for each在遍历数组的时候，我们要创建一个与数组的数据类型相同的临时变量,数组会把的每一个元素都复制给临时变量,然后进行输出.

语法格式:
for(数据类型 变量:数组名){
System.out.print(变量);
}

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int x:arr) {
            System.out.print(x+" ");
        }
    }
1
2
3
4
5
6

toString遍历数组

toString是将数组的元素以字符串的方式打印出来。
要使用toString 必须要导入一个包 import java.util.Arrays;
使用方式：String 变量 = Arrays.toString(数组名) 然后打印字符串变量就可以了

语法格式:
String 变量= Arrays.toString(数组名);
System.out.println(变量);

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        String str = Arrays.toString(arr);
        System.out.println(str);
    }
1
2
3
4
5

6.数组的初始化

数组的初始化分为两种：一种是静态初始化，另外一种是动态初始化。

静态初始化

静态初始化就是在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定。

int[] arr1 = {1,2,3};
int[] arr2 = new int[]{1,2,3};
1
2

arr1和arr2就是静态初始化的数组。
注意:虽然在定义数组的时候没有指定大小，但是编译器会根据{}中元素的个数来确定数组的长度。
arr1和arr2是一样的，都是静态初始化的数组，我们就可以使用arr1的那种形式来简化代码.

动态初始化

动态初始化就是在定义数组时，指定数组的长度。

int[] arr3 = new int[3];
1

arr3就是动态初始化的数组。动态初始化完不能不能扩充数组，arr3就只能放3个元素。

数组元素的默认值

在Java中,我们定义局部变量是没有初始值的,因此我们在使用局部变量时必须要赋值,但是数组不一样, 对于数组来说,即使不赋值,也会有默认值.
不同数据类型的数组的默认值如下:

7.二维数组

二维数组就是特殊的一维数组

int[][] arr1 = {{1,2,3},{4,5,6}};
int[][] arr2 = new int[][]{{1,2,3},{4,5,6}};
int[][] arr3 = new int[2][3];
1
2
3

在arr1和arr2的定义中，虽然我们没有给它定义行和列，但是通过{}也能让编译器知道行和列。
注意：二维数组在java中是可以省略列的

8.二维数组的遍历

for循环进行遍历

二维数组是特殊的一维数组，那我们就可以把二维数组的行看成一维数组的长度，把列看成一维数组行的长度
因此要遍历一个二维数组就可以使用下面这种方法：

for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j]+" ");
            }
        }
1
2
3
4
5

for each进行遍历

对于二维数组，我们要先用for each把二维数组的每一行放到一维数组中，然后在使用for each打印一维数组中的每一个元素。
使用方式如下：

for (int[] arr:arr1) {
            for (int x:arr) {
                System.out.print(x+" ");
            }
            System.out.println();
        }
1
2
3
4
5
6

deepToString

对于deepToString方法，在使用前要先导入import java.util.Arrays 这个包
使用方式如下：

int[][] arr1 = {{1,2,3},{4,5,6}};
System.out.println(Arrays.deepToString(arr1));
1
2

9.数组的拷贝

对于数组的拷贝，除了使用for循环拷贝数组，Java还为我们提供了一些非常便利的方法。

for循环拷贝数组

for循环拷贝数组，就是利用循环将要拷贝的数组的元素逐个赋值给新的数组。
具体代码实现如下：

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] copy = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            copy[i] = arr[i];
        }
    }
1
2
3
4
5
6
7

Arrays.copyOf方法

Arrays.copyOf方法可以拷贝的数组类型有很多，具体类型如下：

在使用Arrays.copyOf方法，我们先看看拷贝整型数组的Arrays.copyOf方法的原码：

public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
1
2
3
4
5
6

我们可以看到Array.copyOf方法的返回值是是一个数组，而形参是有两个参数，一个是数组，另外一个是一个整型的变量。
形参中的int[] original就是我们要拷贝数组的数组名
形参中的int newLength就是我们要拷贝数组的长度
因为是有返回值的，所以我们在使用Arrays.copyOf方法的时候，要有数组来接收返回值。
使用方式如下：

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] copy =Arrays.copyOf(arr,arr.length);
    }

1
2
3
4
5

注意:拷贝的长度是可以超过要拷贝数组的长度的，如果超过了拷贝数组的长度的话，那么多出来的元素值就为0； 比如：我要拷贝arr数组，但是arr数组的大小为5，如果我在拷贝的时候，将arr.length*2了，那么copy这个数组大小就是变成10，并且6~10个元素值为0.这也算是扩容。

Arrays.copyofRange方法

Arrays.copyofRange方法能拷贝的数组类型也有很多，如下：

如果我们要拷贝数组的一部分，就可以使用Arrays.copyRange这个方法。同上一样，也是用拷贝整型数组进行讲解，我们先看一下它底层的原码：

public static int[] copyOfRange(int[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        int[] copy = new int[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

1
2
3
4
5
6
7
8
9
10

通过Arrays.copyRange的原码可以看到返回值是一个数组，而形参是一个数组，两个整型的变量。
形参中的数组就是要拷贝的数组的数组名
形参中的两个整型变量from和to就是要拷贝数组元素的范围，范围是[form，to)是左闭右开的
使用方式如下：

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] copy = Arrays.copyOfRange(arr,1,3);
    }

1
2
3
4
5

注意：数组下标是从0开始的，1~3号的元素是指2，3，4.但是右边是开区间，所以不包括4，因此copy这个数组知识拷贝了2和3这两个元素。

System.arraycopy方法

其实细心的话，就会发现在前面两个方法的原码中都有System.arraycopy方法。
前面两个方法的底层也是靠System.arraycopy方法来实现的。System.arraycopy方法是看不了原码的，只能看到形参。如下：

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

1
2
3
4

各个形参的意思如下：

System.arraycopy是看不到实现的原码的，原因在于native,它的底层是C/C++来实现的。
因为是C/C++实现的，因此native方法的优点就是执行速度非常快
使用方法代码如下：

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] copy = new int[arr.length];
        System.arraycopy(arr,0,copy,0,arr.length);
    }
1
2
3
4
5

clone方法

最后一个是数组名.clone这个方法，这个方法了解即可。

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] copy = arr.clone();
    }
1
2
3
4

这种方法主要是产生了对象的一个副本，地址还是不一样的。

10.总结

数组在Java中还是比较常用的，主要是总结了数组的定义、遍历、通过下标对数组的元素进行访问等一些问题的总结（如有错误，欢迎指正！）

感谢你的观看!
Java专栏持续更新中~ 希望与君共勉,携手并进!