前言

  本文详细介绍Java中基本类型数组的使用。在前面我们已经学习了基本数据类型的简单数据类型，下面介绍引用数据类型——数组。如果没有学习过基本数据类型，可以参考Java之基本数据类型

1 数组的基本概念和特点

数组的定义

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。

数组的特点

1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素的类型必须是相同类型，不允许出现混合类型。
3. 数组类型可以是任何数据类型，包括基本类型和引用类型。
4. 数组有索引的：索引从0开始，到 数组.length-1 结束。
5. 数组变量属于引用类型，数组也是对象。

代码实例：

/**
 * 数组
 */
public class demo1 {
    public static void main(String[] args){
        //以int类型数据为案例：数组用来存储int类型数据
        //1.声明(定义数组)
        //定义一个int类型的数组，名字叫arr
        int[] arr;
//        int arr[];  //如果数组只声明，没有后续操作，那么这个数组相当于没定义
        
        //int[] arr3 = null;  //空 辨别：数组赋值为null和什么都没有赋值  不一样的效果
        //指向null表示没有内存空间指向
        //什么都没有赋值表示指向了一个默认的位置

        //2.创建
        arr = new int[4];//给数组开辟了一个长度为4的空间
        //编译期声明和创建会被合为一句话: int[] arr = new int[4];
        /*数组的初始化：
            int[] arr = {12,23,45};
            int[] arr = new int[]{12,23,45};
            注意：
            1.new int[3]{12,23,45};-->错误
            2.int[] arr ;
            arr = {12,23,45};  --->错误
        */

        //3.赋值
        arr[0] = 12;
        arr[3] = 47;
        arr[2] = 98;
        arr[1] = 56;
        arr[2] = 66;
        /*
            arr[4] = 93;
            出现异常：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4  --->数组索引越界异常
        */

        //4.使用
        System.out.println(arr[2]);
        System.out.println(arr[0]+100);
        //通过数组一个属性来获取  length 长度
        System.out.println("数组的长度是："+arr.length);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

上述代码的内存分析

对象是存储在堆结构里面的，方法内的具体是放在方法区里面的。而数组是一种对象，所以数组保存在堆中，当new int[4]时，在堆中开辟4个连续的空间，每个空间占int4个字节，并且将首地址传递赋值给arr变量，之后就可以通过arr来操作数组了。

2 数组的遍历

代码实例：数组的赋值和遍历查看

/**
 * 数组的遍历
 */
public class demo2 {
    public static void main(String[] args){
        //功能：键盘录入十个学生的成绩，求和，求平均数：
        //定义一个int类型的数组，长度为10 ：
        int[] scores = new int[10];
        //定义一个求和的变量：
        int sum = 0;
        Scanner sc = new Scanner(System.in);
        for(int i=1;i<=10;i++){//i:控制循环次数
            System.out.print("请录入第"+i+"个学生的成绩：");
            int score = sc.nextInt();
            scores[i-1] = score;
            sum += score;
        }
        System.out.println("十个学生的成绩之和为："+sum);
        System.out.println("十个学生的成绩平均数为："+sum/10);


        //求第6个学生的成绩： 
        //System.out.println(scores[5]);

        //将数组中的每个元素进行查看--》数组的遍历：
        //方式1：普通for循环---》正向遍历：
        for(int i=0;i<=9;i++){
            System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
        }

        //方式2：增强for循环:
        //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
        int count = 0;
        for(int num:scores){
            count++;
            //每次都将num在控制台输出
            System.out.println("第"+count+"个学生的成绩为："+num);
        }
                
                /*
                增强for循环：
                优点：代码简单
                缺点：单纯的增强for循环不能涉及跟索引相关的操作
                */

        //方式3：利用普通for循环： 逆向遍历：
        for(int i=9;i>=0;i--){
            System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

3 Arrays工具类的使用

为了方便外面对数组进行操作，系统提供了一个类Arrays，我们可以将它当作时工具类来使用

代码实例：

import java.util.Arrays;
/**
 * Arrays对数组的操作
 */
public class demo3 {
    public static void main(String[] args){
        //给定一个数组：
        int[] arr = {1,3,7,2,4,8};
        //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
        System.out.println(Arrays.toString(arr)); // [1, 3, 7, 2, 4, 8]

        //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
        //这个方法的使用前提：一定要查看的是一个有序的数组：
        //sort：排序 -->升序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 7, 8]
        System.out.println(Arrays.binarySearch(arr,4)); // 3

        int[] arr2 = {1,3,7,2,4,8};
        //copyOf:完成数组的复制：
        int[] newArr = Arrays.copyOf(arr2,4);
        System.out.println(Arrays.toString(newArr)); // [1, 3, 7, 2]

        //copyOfRange:区间复制：
        int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
        System.out.println(Arrays.toString(newArr2)); // [3, 7, 2]

        //equals:比较两个数组的值是否一样：
        int[] arr3 = {1,3,7,2,4,8};
        int[] arr4 = {1,3,7,2,4,8};
        System.out.println(Arrays.equals(arr3,arr4)); // true
        //如果是数，==比较左右两侧的值是否相等
        //如果是对象，比如数组，那么==比较的是左右的地址值，返回结果一定是false
        System.out.println(arr3==arr4); // false

        //fill：数组的填充：
        int[] arr5 = {1,3,7,2,4,8};
        Arrays.fill(arr5,10);
        System.out.println(Arrays.toString(arr5)); // [10, 10, 10, 10, 10, 10]
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

  System类里面也有可以操作数组的方法：static void arraycopy(Object src,int srcPos,Object destPos, int length)

import java.util.Arrays;
/**
 * System类对数组的操作
 */
public class demo4 {
    public static void main(String[] args){
        //给一个源数组：
        int[] srcArr = {11,22,33,44,55,66,77,88};
        //给一个目标数组：
        int[] destArr = new int[10];

        //复制：
        System.arraycopy(srcArr,1,destArr,3,3);
        //遍历查看目标数组：
        System.out.println(Arrays.toString(destArr)); // [0, 0, 0, 22, 33, 44, 0, 0, 0, 0]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4 二维数组

初始化

int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组
1
2
3

本质上都是一维数组

代码实例

/**
 * 二维数组
 */
public class demo5 {
    public static void main(String[] args){
        //定义一个二维数组：
        int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3   
        int[] a1 = {1,2,3};
        arr[0] = a1;
        arr[1] = new int[]{4,5,6,7};
        arr[2] = new int[]{9,10};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

对上述二维数组的内存分析：