数组的定义与使用

数组的基本概念

为什么要使用数组

假设我们要储存五名同学的数学成绩，并对其进行输出，

public class Test {


    //为什么要使用数组
    public static void main(String[] args) {
        int student1 = 89;
        int student2 = 82;
        int student3 = 68;
        int student4 = 90;
        int student5 = 73;
        System.out.println(student1);
        System.out.println(student2);
        System.out.println(student3);
        System.out.println(student4);
        System.out.println(student5);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这种情况下，我们发现我们需要重复的创建变量，这大大降低了我们写代码的效率。我们发现这些数据的类型是相同的，这时我们就可以使用变量。

什么是数组

数组：相同类型元素大的一个集合。 在内存中是一段连续的空间。
【数组的特点】

• 数组中存放的元素类型相同；
• 数组的空间的是连在一起的；
• 每个空间都有自己单独的编号，其初始位置是0，即数组的下标。

那么我们如何创建数组呢？

数组的创建及初始化

数组的创建

T[] 数组名 = new T[N];

T：表示数组存放元素的类型
T[]:数组的数据类型；
N:表示数组的长度。

【数组创建的示例】

//数组创建的示例
    public static void main(String[] args) {
        int[] array2 = new int[5];
        double[] array3 = new double[3];
    }
1
2
3
4
5

数组的初始化

数组的初始化主要分为两种类型：动态初始化和静态初始化。

1. 动态初始化：在创建数组的时候，直接指定数组中元素的个数

int[] array = new int[10];

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

int[] array = new int{1,2,3,4,5,6};
int[] array = {1,2,3,4,5,6};

【注意事项】

• 静态初始化虽然没指定数组的长度，编译器在编译时会根据{}中的元素个数来确定数组的长度；
• 静态初始化时，{}中数据类型必须与[]前数据类型一致；
• 静态初始化可以简写，省略后面的new T[]. (但是在编译器编译代码时还是会还原，自动加上省略的部分)；
• 数组也可以按照C语言一样创建数组，但是我们不会去使用这种方法，但是语法是支持的。

int[] array = new int[5];
int array[] = new int[5]; //语法支持，但不推荐；
int array[5] = new int[5];//语法不支持

• 静态和动态初始化可以分为两步，但是不可以省略格式；

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10,20,30};
//array2 = {1,2,3} 这种格式是错误的。

• 如果没有对数组进行初始化，数组中元素有其默认值，1. 如果数组中储存元素类型为基类类型，默认为基类类型对应的默认值：比如：byte\short\int\long 类型默认值为 0，float 默认值为 0.0f double 默认值为 0.0，char 类型默认值为 /u0000, ***boolean 默认值为 false ***. 2.如果数组中储存元素类型为引用类型，其默认值为 null

数组的使用

数组中元素的访问

//数组元素的访问
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
1
2
3
4
5
6
7

【注意事项】

1. 数组是一段连续的内存空间，因此支持随机访问，即通过下标可快速访问任意元素。
2. 下标从0开始，介于[0,N)

遍历数组

遍历：是指将数组中的所有元素都访问一遍。
【三种遍历数组的方法】

//数组元素的访问
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        for (int x: array) {
            System.out.println(x);
        }
        System.out.println(Arrays.toString(array));
    }
1
2
3
4
5
6
7
8
9
10
11

第一种遍历的方式，我们能够轻松理解；
第二种我们可以使用 for-each 遍历数组；
第三种我们可以使用 java 提供的包内的方法来遍历数组。

数组是引用类型

基本数据类型与引用类型变量的区别

基本变量：基本数据类型所创立的变量，空间存放的是所对应的值；
引用变量：引用数据类型说创建的变量，其空间中储存的是对象所在空间的地址。

//基本数据类型和引用数据类型所存放的位置
    public static void main(String[] args) {
        int a = 29;
        int b = 99;
        double[] array = new double[]{3.14, 1.56, 4.99};
    }
1
2
3
4
5
6

在上述代码中a\b\array，都是函数内部的变量，因此其开辟的空间都在main方法对应的栈帧中分配。

• a\b都是内置类型的变量，其空间中储存的都是该变量的值。
• array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。
  
  引用变量不直接储存数据的值，而是在堆区开辟新的空间，在堆区存放数据，而在栈中存放对应堆区的地址。

认识null

***null 在Java中表示“空引用”，也就是一个不指向对象的引用。

//null
    public static void main(String[] args) {
        int[] array = null;
        System.out.println(array[0]);
    }
1
2
3
4
5

null 的作用类似于C语言的空指针，都是表示一个无效的内存地址，如果我们对它进行操作会导致空指针异常问题（NullPointerException）。

Java中没有约定 null 与 0 号地址有任何关系。

数组的应用场景

保存数据

//数组的应用场景 保存数据
    public static void main(String[] args) {
        int[] students = {99, 100, 66};
        for (int x: students) {
            System.out.print(x + " ");
        }
    }
1
2
3
4
5
6
7

作为函数的参数

参数传基本数据类型

  //参数传基本数据类型
    public static int func(int num) {
        num = 0;
        return num;
    }

    public static void main(String[] args) {
        int num = 20;
        func(num);
        System.out.println(num);
    }
1
2
3
4
5
6
7
8
9
10
11

在这种情况下，形参只是实参的临时拷贝，我们修改形参的值，并不会影响实参。

参数传数组类型

    //参数传数组类型
   public static int[] func (int[] array) {
       for (int i = 0; i < array.length; i++) {
           array[i] = i;
       }
       return array;
   }

   public static void main(String[] args) {
       int[] array = {10, 20, 30};
       func(array);
       for (int x: array) {
           System.out.print(x + " ");
       }
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

我们发现，如果对引用类型进行数值上的修改，数组的内容会真的改变。
总结：所谓的引用本质上只是存了一个地址。Java中将数组设定成引用类型，这样的话后续进行数组参数传参，***其实只是将数组的地址传到函数的形参当中，但是使用的仍让是堆上相同的空间。

作为函数的返回值

示例：获取斐波那契数列的前N项

 //作为方法的返回值 获取斐波那契数列的前N项
    public static int[] fibonacci (int num) {
        int[] array = new int[num];
        array[0] = 1;
        array[1] = 1;
        for (int i = 2; i < num; i++) {
            array[i] = array[i-1] + array[i-2];
        }
        return array;
    }

    public static void main(String[] args) {
        int n = 9;
        System.out.println(Arrays.toString(fibonacci(n)));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

数组练习

数组转字符串

 //数组转字符串
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        String str = Arrays.toString(array);
        System.out.println(str);

    }
1
2
3
4
5
6
7

Java中提供了 Java.util.Arrays 包，其中包含了一些操作数组的常用方法。

数组拷贝

//数组拷贝
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50, 60};
        //copyOf 方法进行拷贝，并会建立一个新的数组
        int[] newArr1 = Arrays.copyOf(array, array.length);
        System.out.println(Arrays.toString(newArr1));
        //拷贝某个范围
        int[] newArr2 = Arrays.copyOfRange(array, 2, 5);
        System.out.println(Arrays.toString(newArr2));
    }
1
2
3
4
5
6
7
8
9
10

二维数组

二维数组本质上就是一维数组，只不过每个元素又是一个一维数组。
【基本语法】

数据类型[][] 数组名称 = new 数据类型[行数][列数]{初始化数据类型}；

【代码示例】

 //二维数组
    public static void main(String[] args) {
        int[][] array1 = {{1,2}, {3,4}};
        int[][] array2 = new int[][]{{1,2}, {3,4}};
        int[][] array3 = new int[2][2];
        int[][] array4 = new int[2][];
    }
1
2
3
4
5
6
7

二维数组创建的方式有四种，第一种和第二种直接初始化，第三种和第四种指定元素的个数，但不能初始化，这里与C语言有点不一样，Java中不要指定列数，指定相应的行数即可。
二维数组我们在此处只做简单的了解。