Java Array 数组

Java Array 数组

一，数组的介绍

1. 数组的理解(Array)

概念: 是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
简称: 多个和数据的组合。
Java中的容器: 数组、集合框架: 在内存中对多个数据的存储

2. 数组相关的概念

数据名
数据的元素(即内部存储的多个元素)
数据的下标、角标、下角标、索引、index(即找到指定数组元素所使用的编号)
数组的长度(即数组容器中存储的元素的个数)

3. 数组的特点:

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间。占据的空间的大小，取决于数组的长度和数组中元素的类型。
数据中的元素在内存中是依次紧密排列的，有序的。
数组，一旦初始化完成，其长度就是确定的，数据的长度一旦确定，就不能修改。
我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
数组名中引用的是这块连续空间的首地址。

4. 变量按照数据类型的分类

基本数据类型: byte \ short \ int \ long \ float \ double \ char \ boolean
引用数据类型: 类、数组、枚举、注解、记录

5. 数组的分类

按照数组的类型: 基本数据类型元素的数组; 引用数据类型元素的数组
按照数组的维数来分: 一维数组; 二维数组; …

6. 一维数组的使用(6个基本点)

数组的声明和初始化
调用数组的指定元素
数组的属性: length,表示数组的长度
数组的遍历
数据元素的默认初始化值
一维数组的内存解析(难点)

7. 数组元素的默认初始化值的情况

注意: 以数组的动态初始化方式为例说明。
整型数组元素的默认初始化值: 0
浮点型数组元素的默认初始化值: 0.0
字符型数组元素的默认初始化值: 0 (或理解为’\u0000’)
boolean型数组元素的默认初始化值: false
引用数据类型数据元素的默认初始化值: null

二，一维数组

1. 一维数组功能测试

包含，一维数组的静态初始化和动态初始化，数组元素调用和数组元素赋值,测试了不同类型数组的数组的元素的初始值，还有如何获取数组的长度，以及遍历数组，数组的内存解析。

package Java_Array_one;

/**
 * ClassName: One_array_test
 * Packge: Java_Array_one
 * Description: 一维数组的测试
 *
 * @Author: aex
 * @Create 2024/5/8 14:24
 * @Version 1.0
 */
public class One_array_test_1 {
    public static void main(String[] args) {
        //1.声明数组和数组初始化
        // 静态初始化: 数组变量的赋值与数组元素的赋值操作同时进行。
        double[] prices = new double[]{20.32,43.21,43.22}; // 初始化数组

        // 动态初始化: 数组变量的赋值与数组元素的赋值操作分开进行
        String[] foods = new String[4]; // 初始化数组

        // 其他正确的方式
        int arr[] = new int[4];
        int[] arr1 = {1,2,3};  //类型推断

        // 错误的方式
        //int[] arr2 = new int[3]{1,2,3};  // 不能动态和静态结合
        //int[3] arr3 = new int[];  // 不能把动态的的长度放到前面去

        //2. 数组元素的调用
        //通过下标的方式，获取数组的元素
        System.out.println(prices[0]); // 取出数组的第一个元素

        foods[0] = "拌海蜇";
        foods[1] = "龙须菜";
        foods[2] = "炝冬笋";
        foods[3] = "玉兰片";

        System.out.println(foods[0]);

        //3. 数组的长度: 用来描述数组容器中容量的大小
        // 用length属性来获取数组的长度
        System.out.println(foods.length);
        System.out.println(prices.length);

        //4. 如何遍历数组
        for (int i=0;i<foods.length;i++){
            System.out.print(foods[i]);
        }

        for (int i = 0; i < prices.length; i++) {
            System.out.println(prices[i]);
        }
        System.out.println("-----");
        //5. 数组元素的默认初始化值
        int[] arr3 = new int[3];
        System.out.println(arr3[0]); // 整型数组元素的默认初始化值为 0
        double[] arr4 = new double[3];
        System.out.println(arr4[2]); // 浮点型数组元素的默认初始化值为 0
        boolean[] arr5 = new boolean[3];
        System.out.println(arr5[0]); // 布尔型数组元素的默认初始化值为 false
        char[] arr6 = new char[3];
        System.out.println(arr6[1]); // 字符型数组元素的默认初始化值为 0
        String[] arr7= new String[3];
        System.out.println(arr7[0]); // 引用型数组元素的默认初始化值为 null

        //6. 数组的内存解析
        int[] a1 = new  int[]{1,2,3};
        int[] a2 = a1;
        a2[1] = 10;
        System.out.println(a1[1]);
        System.out.println(a1);  // a1 和 a2 指向的内存地址是同一个
        System.out.println(a2);  // a1 和 a2 指向的内存地址是同一个

        String a3  = "3b07d329";
        int number  = Integer.parseInt(a3,16); // 将16进制转换为十进制，查看内存地址
        System.out.println(number);
    }
}
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

2. 一维数组案例

(1). 破解房东电话

实现思路: 这里是有两个数组，一个是存着电话的具体数字，一个数字可能被多次使用，比如122345 这里 2 就使用了两次，然后第二个数字就是存着这些号码的索引，比如第一个是1 也就是上面数组的第二个位置，也就是1，第一位号码就是1，然后我们还要定义一个数组 tel 用来接收电话号码，进入循环，初始化条件 i = 0,因为 索引是从0开始的，i < 索引数组的长度，也就是 11 因为电话号码就是 11 位，我们先把 索引都拿到 也就是 index[i] ，然后把每一位的索引对应的号码都拿到 arr[index[i]] 把每一位号码放到 tel 也就是存号码的数组里，tel[i] = arr[index[i]] 最后for循环遍历这个 tel 数组就可以了。
注意：这个题考察的点是 两个数组间索引和值的对应 tel[i] = arr[index[i]];

/**
         * 案例："破解" 房东电话
         *
         * 升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调，卫生间，厨房齐全，屋内均是IT行业人员
         * 所以要求求租者最好是同行或者刚毕业的年轻人，爱干净，安静
         * */
        int[] arr = new int[]{9,1,0,3,6,9,8}; // 用来存具体的号码
        int[] index = new int[]{1,0,3,4,2,4,5,5,3,6,4}; //用来存号码的位数对应的具体号码的索引跟上面的数组对应
        int[] tel = new int[11]; // 定义一个变量 int 数组 用来接收电话号码
        for (int i = 0;i < index.length;i++){
//            int value = index[i];
            tel[i] = arr[index[i]];   // 将电话号码存入这个数组中
        }

        for (int j = 0;j < tel.length;j++){ //遍历这个数组，输出电话号码
            System.out.print(tel[j]);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

结果输出

(2). 输出英文星期几

思路：用一个数组存放一周七天的单词，相当于是输入一个数字然后拿到对应的 week 数组里的索引的元素，像是这样，System.out.print(week[0]) 这样拿到的就是 第一个元素也就是 Monday，我们的索引是从 0 开始的，用一个变量 day 来接收输入的数字，if(day >=1 && day <= 7){System.out.print(week[day - 1])} 之所以要这样写是因为，数字肯定是要 大于等于1并且小于等于7，然后 索引是从0开始，如果我们 输入数字1要星期一，那应该是 1-1 索引 0 刚好对应星期一。

/**
 * 案例：输出英文星期几
 * 用一个数组，保存星期一到星期天的7个英文单词，从键盘输入1-7，显示对应的单词
 * {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"}
 * */
String[] week = new String[]{"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
Scanner scan = new Scanner(System.in);
System.out.print("请输入数值(1-7):");
for (;;){
    int day = scan.nextInt();
    if(day >= 1 || day <= 7){
        System.out.println(week[day - 1]);
    }else{
        System.out.println("你输入的数据有误!");
        break;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

结果输出

(3). 学生考试等级划分

思路：首先第一步是 输入学生的人数，由这个人数来决定数组的长度，第二步就是循环，这里面要输入每一个学生的成绩，定义一个变量 cj 来接收每一个学生的成绩，然后赋值给 用来存放成绩的数组，然后获取 这些学生成绩里面的最大值，Arrays.stream(arr_score).max(); 直接用这个 api，最后一步就是遍历这个成绩数组，并且将最大值与每一位学生的成绩做对比来划分等级。

 /**
         * 案例：学生考试等级划分
         * 从键盘读入学生成绩，找出最高分，并输出学生成绩等级
         *  成绩 >= 最高分 - 10  等级为: 'A'
         *  成绩 >= 最高分 - 20  等级为: 'B'
         *  成绩 >= 最高分 - 30  等级为: 'C'
         *  其余  等级为: 'D'
         *
         *  先读入学生人数，根据人数创建int数组，存放学生成绩
         * */

        //1. 从键盘输入学生的人数，根据人数，创建数组（动态初始化）
        Scanner scan1 = new Scanner(System.in);
        System.out.print("请输入学生人数:");
        int count = scan1.nextInt();
        int[] arr_score = new int[count]; // 根据人数创建动态数组

        //2. 根据提示，依次输入学生成绩，并将成绩保存在数组元素中
        for (int i = 0;i < arr_score.length;i++){
            System.out.print("请输入第"+(i + 1) + "位学生成绩:");
            int cj = scan1.nextInt();
            arr_score[i] = cj;
        }

        //3. 获取学生成绩的最大值
        OptionalInt max_score = Arrays.stream(arr_score).max();
        System.out.println(max_score.getAsInt());

        //4. 遍历数组元素，根据学生成绩与最高分的差值，得到每个学生的等级，并输出成绩和等级
        for (int i = 0;i< arr_score.length;i++){
            if(arr_score[i] >= max_score.getAsInt() - 10){
                System.out.println("学生成绩为:" + arr_score[i] + "等级为: 'A'");
            }else if (arr_score[i] >= max_score.getAsInt() - 20){
                System.out.println("学生成绩为:" + arr_score[i] + "等级为: 'B'");
            } else if (arr_score[i] >= max_score.getAsInt() - 30) {
                System.out.println("学生成绩为:" + arr_score[i] + "等级为: 'C'");
            }else{
                System.out.println("学生成绩为:" + arr_score[i] + "等级为: 'D'");
            }
        }
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

结果输出