Java-----学习笔记5

数组

概念

存储多个相同类型数据，有固定的长度。

定义数组

        1、静态初始化（固定长度，定值）

int[] arr1 = {1, 2, 3, 4, 5};

        2、动态初始化

int[] arr2 = new int[5]; //元素默认初始化为0

        3、 先声明后初始化

int[] arr3; // 声明数组变量，但未初始化  
// ...（在需要的时候）  
arr3 = new int[3]; // 分配长度为3的数组空间，元素默认初始化为0  
// 或者直接初始化元素  
arr3 = new int[]{10, 20, 30};

数组特性

1、固定长度

        通过数组名.length(一种属性)获取数组的长度。

2、索引从零开始

int[] arr = {10, 20, 30, 40, 50};  
// 有效的索引：0, 1, 2, 3, 4  
// arr[0] = 10  
// arr[1] = 20  
// ...  
// arr[4] = 50
//索引范围[0,length-1]

3、访问数组

int[] numbers = {1, 2, 3, 4, 5};  
int secondNumber = numbers[1]; // 访问索引为1的元素，即2

4、数组的遍历

       普通循环：

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

        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }

         增强性for循环（forEach循环）：

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

        for (int number : numbers) {
            System.out.println(number);
        }
    }

数组排序

一、冒泡排序

public static void sort(int[] a) {  
    // 外层循环控制排序的总轮数，由于每完成一轮，最大的元素就会"冒泡"到它应该在的位置，  
    // 所以每次内层循环结束后，都可以减少一次比较（即a.length - i - 1）  
    for (int i = 0; i < a.length - 1; i++) {  
        // 假设当前轮次内数组已经有序，设置f为true  
        boolean f = true; // 这是一个标记，用于检测当前轮次是否发生了元素交换  
        // 内层循环负责进行相邻元素的比较和可能的交换  
        for (int j = 0; j < a.length - i - 1; j++) {  
            // 如果发现相邻元素顺序错误（即前一个比后一个大），则交换它们  
            if (a[j] > a[j + 1]) {  
                // 发生了交换，所以当前轮次数组不是有序的  
                f = false;  
                // 交换元素  
                int tmp = a[j];  
                a[j] = a[j + 1];  
                a[j + 1] = tmp;  
            }  
        }  
        // 如果在当前轮次中没有发生任何交换，说明数组已经有序，可以结束排序  
        if (f) break;  
    }  
}

二、选择排序

public static void sort(int[] a) {  
    for (int i = 0; i < a.length - 1; i++) { // 遍历数组，除了最后一个元素  
        int min = a[i]; // 假设当前元素是最小的  
        int pos = i; // 记录最小元素的位置  
        for (int j = i + 1; j < a.length; j++) { // 从i+1开始寻找真正的最小值  
            if (min > a[j]) { // 如果发现更小的值  
                min = a[j]; // 更新最小值  
                pos = j; // 更新最小值的位置  
            }  
        }  
        // 将找到的最小值放到它应该在的位置上（即位置i上）  
        if (pos != i) { // 这一步实际上可以省略，因为即使pos等于i，交换也不会改变数组  
            // 但为了代码的清晰性，我还是保留了它  
            int temp = a[i];  
            a[i] = a[pos]; // 注意这里是a[pos]，因为我们想要把找到的最小值放到a[i]上  
            a[pos] = temp; // 将原来a[i]上的值放到它现在的位置上（即a[pos]）  
        }  
    }  
}

三、插入排序

public static void sort(int[] a) {  
    // 从数组的第二个元素开始遍历，因为假设第一个元素已经排好序  
    for (int i = 1; i < a.length; i++) {  
        // 保存当前要插入的元素  
        int tmp = a[i];  
        // pos用于记录tmp元素应该插入的位置  
        int pos = i;  
  
        // 在已排序序列a[0..i-1]中从后向前扫描  
        for (int j = i; j > 0; j--) {  
            // 如果当前元素比它前面的元素小，则将前面的元素向后移动一位  
            if (tmp < a[j - 1]) {  
                a[j] = a[j - 1];  
                // 更新tmp元素应该插入的位置  
                pos = j - 1;  
            }  
            // 如果tmp不小于它前面的元素，则找到了插入位置，退出内层循环  
            // 注意：这里没有显式的else语句，因为当不满足if条件时，循环会自动继续或终止  
        }  
  
        // 将tmp元素插入到它正确的位置上  
        a[pos] = tmp;  
    }  
}

多维数组

java的多维数组本质： 一维数组。

看做一张表，行-列 坐标

二维数组： 一维数组中的元素是一个一维数组