Java基础学习笔记-4

前言

本学习笔记将介绍Java中的数组概念以及各种与数组相关的操作和示例代码。
Java基础学习笔记-1
Java基础学习笔记-2
Java基础学习笔记-3

Demo01 - 声明和初始化数组

public class Demo01 {
    public static void main(String[] args) {
        // 声明一个数组，指明了里面只能存放整数
        int[] arr;
        // 赋值
        arr = new int[5];
        // 给数组里面的5个成员，都分别给个成绩
        // arr[0] arr[1] arr[2] arr[3] arr[4]
        arr[0] = 60;
        arr[1] = 61;
        arr[2] = 62;
        arr[3] = 63;
        arr[4] = 64;
        // 使用
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这个示例演示了如何声明、分配内存和初始化一个整数数组，并打印数组的元素。

Demo02 - 声明和初始化数组的简化形式

public class Demo02 {
    public static void main(String[] args) {
        // 声明 分配空间 赋值
        int[] arr = new int[]{81,82,83,84,85};
        int[] arr2 = {81,82,83,84,85}; // 如果声明、分配空间、赋值是在一行，可以省略new int[]
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

这个示例展示了声明、初始化数组的简化形式，同时演示了如何直接赋值给数组元素。

Demo03 - 数组长度和遍历数组

public class Demo03 {
    public static void main(String[] args) {
        System.out.println(args.length); // 0
        // Java的数组，天然有一个只读属性，它的名字叫length
        int[] arr = {81,82,83,84,85,86,87,88};
        System.out.println(arr.length);
        System.out.println("数组里面的信息：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

这个示例介绍了如何获取数组的长度属性和使用循环遍历数组。

Demo04 - 使用Scanner处理数组和查找元素

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] arr = {8, 4, 2, 1, 23, 344, 12};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i]; // 累计
            System.out.println(arr[i]); // 输出
        }
        System.out.println("和：" + sum);
        System.out.print("输入一个数：");
        int number = scanner.nextInt();
        boolean bFound = false;
        for (int i = 0; i < arr.length; i++) {
            if (number == arr[i]) {
                bFound = true;
                break;
            }
        }
        System.out.println(bFound ? "找到" : "没有找到"); // 唯一的三元操作符
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这个示例演示了如何使用Scanner处理用户输入以及如何查找数组中的元素。

Demo05 - 输入和计算金额数组

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double[] arrJingE = new double[5];
        for (int i = 0; i < arrJingE.length; i++) {
            System.out.print("请输入第"+(i+1)+"笔的金额：");
            arrJingE[i] = scanner.nextDouble();
        }
        System.out.println("序号\t金额");
        double sum = 0.0;
        for (int i = 0; i < arrJingE.length; i++) {
            System.out.println((i+1) + "\t" + arrJingE[i]);
            sum += arrJingE[i];
        }
        System.out.println("总金额\t" + sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这个示例允许用户输入五个金额，并将它们存储在一个数组中，然后计算总金额并打印出来。

Demo06 - 数组排序

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        int[] arr = {8, 4, 2, 1, 23, 344, 12};
//        for (int i = 0; i < arr.length; i++) {
//            System.out.println(arr[i]);
//        }
        Arrays.sort(arr); // 排序
        System.out.println(arr); // 打印数组名时，输出的是 [代表数组 I代表整数 @8位十六进制代表内存地址
        System.out.println(Arrays.toString(arr));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

这个示例展示了如何使用Arrays.sort()方法对数组进行排序，并使用Arrays.toString()方法打印排序后的数组。

Demo07 - 数组操作

import java.util.Arrays;

/*
boolean equals(array1,array2)	比较array1和array2两个数组是否相等
void fill(array,val)	        把数组array所有元素都赋值为val
copyOf(array,length)	        把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
int binarySearch(array, val)	查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）
 */
public class Demo07 {
    public static void main(String[] args) {
        int[] arr1 = new int[]{8, 4, 2, 1, 23, 344, 12};
        int[] arr2 = new int[]{8, 4, 2, 1, 23, 344, 12};
        System.out.println(Arrays.equals(arr1, arr2));
        Arrays.fill(arr1,  11);
        System.out.println(Arrays.toString(arr1));
        int[] arr3 = Arrays.copyOf(arr2, 8);
        System.out.println(Arrays.toString(arr3));
        Arrays.sort(arr2); // [1, 2, 4, 8, 12, 23, 344]
        System.out.println(Arrays.toString(arr2));
        int pos = Arrays.binarySearch(arr2, 0); // 没有找到，返回插入点的下标取负数再-1
        System.out.println("pos: " + pos);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这个示例提供了几种有用的数组操作，包括比较数组是否相等、填充数组、复制数组以及在排序数组中搜索元素等操作。

Demo08 - 字符数组的排序和逆序

import java.util.Arrays;

public class Demo08 {
    public static void main(String[] args) {
        char[] arr = {'a', 'c', 'u', 'b', 'e', 'p', 'f', 'z'};
        System.out.print("原字符序列：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        Arrays.sort(arr);
        System.out.println();
        System.out.print("升续排序后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        System.out.print("逆序输出后：");
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.print(arr[i] + " ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这个示例展示了如何对字符数组进行排序，并在排序后打印升序和降序的结果。

Demo09 - 嵌套循环打印九九乘法表

public class Demo09 {
    public static void main(String[] args) {
        // 二重循环，循环中嵌套循环
        for (int i=1; i<=9; i++) {
            for (int j=1; j<=i; j++) {
                System.out.print(j+"*"+i+"="+i*j+"\t"); // 行内效果
            }
            System.out.println(); // 换行
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

这个示例演示了如何使用嵌套循环打印九九乘法表。外层循环控制行数，内层循环控制每行中的元素。

Demo10 - 冒泡排序的实现

import java.util.Arrays;

public class Demo10 {
    public static void main(String[] args) {
        // 二重循环
        int[] arr = {10, 8, 4, 5, 2, -1, 56, 33};
        // 模拟Arrays.sort(arr)方法
        // 外层循环 n-1
        for (int i=0; i<arr.length-1; i++) {
            // 内层循环 n-1-i
            for (int j=0; j<arr.length-1-i; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这个示例展示了冒泡排序算法的实现。它使用了嵌套循环来比较和交换数组中的元素，以实现排序。

Demo11 - 遍历二维数组

public class Demo11 {
    public static void main(String[] args) {
        int[][] arr = {
                {10, 8, 4, 5, 2, -1, 56, 33, 1},
                {110, 18, 14, 15, 12, -11, 156, 133, 11},
                {1110, 118, 114, 115, 112, -111, 1156, 1133, 113}
        };
        // 二重循环
        // 外层循环 行数
        for (int i=0; i<arr.length; i++) { // arr.length是3
            // 内层循环 行内数据
            for (int j=0; j<arr[i].length; j++) { // arr[0]第一行数组 arr[1]第二行数组 arr[2]第三行数组
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println(); // 换行
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这个示例演示了如何使用嵌套循环遍历二维数组。外层循环控制行数，内层循环遍历每行中的元素。

Demo12 - 计算班级平均成绩

import java.util.Scanner;

public class Demo12 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 二重循环 外循环班级 内循环学生
        for (int i=1; i<=3; i++) { // 外循环班级
            System.out.println("请输入第" + i + "班级的成绩");
            int sum = 0; // 就近原则
            for (int j=1; j<=4; j++) { // 内循环学生
                System.out.print("第" + j + "个学生的成绩：");
                sum += scanner.nextInt();
            }
            System.out.println("第" + i + "班级的平均成绩：" + sum / 4.0);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这个示例演示了如何使用嵌套循环计算不同班级学生的平均成绩。外层循环迭代每个班级，而内层循环迭代每个学生。

Demo13 - 打印星号矩形

public class Demo13 {
    public static void main(String[] args) {
        // 二重循环 外循环行 内循环*
        int number = 3;
        for (int i=1; i<=number; i++) {
            for (int j=1; j<=number; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

这个示例展示了如何使用嵌套循环打印一个矩形图案，其中外层循环控制行数，内层循环打印星号。

Demo14 - 打印倒序星号矩形

public class Demo14 {
    public static void main(String[] args) {
        // 二重循环 外循环行 内循环*
        int number = 5;
        for (int i=1; i<=number; i++) {
            for (int j=1; j<=number-i+1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

这个示例演示了如何使用嵌套循环打印一个倒序的星号矩形，其中外层循环控制行数，内层循环打印星号。

Demo15 - 打印金字塔图案

public class Demo15 {
    public static void main(String[] args) {
        // 二重循环 外循环行 内循环*
        int number = 5;
        for (int i=1; i<=number; i++) {
            for (int j=1; j<=number-i; j++) {
                System.out.print(" ");
            }
            for (int j=1; j<=2*i-1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这个示例演示了如何使用嵌套循环打印一个金字塔形状的图案，其中外层循环控制行数，内层循环打印星号和空格。

总结

这些示例代码涵盖了Java数组的基本概念和常见操作。学习数组是Java编程的基础，它们用于存储和处理大量数据。通过这些示例，您可以了解如何声明、初始化、访问、遍历和操作数组，这将有助于您在Java中处理各种数据集合。希望这些示例对您的学习和开发过程有所帮助！