蓝桥杯JAVA组基础知识点回顾（数组，集合，Map，输入，格式化输出），小白也能一次上手，数组篇

（一）：数组该如何定义与使用（初始化）

一：一维数组

两种方式：1.静态数组 2.动态数组

 public static void main(String[] args) {
        // 定义一个静态数组
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        char[] arr1 = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
        String[] arr2 = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"};
        // 定义一个动态数组
        int[] arr4 = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr4[i] = arr[i];
        }
        for (int i = 0; i < arr4.length; i++) {
            System.out.println(arr4[i]);
        }
        
    }

1.静态数组：一般存储特定数据或者字符串，用来映射答案，比如月份，星期

注意点：字符数组用单引号，字符串数组用双引号

2.动态数组：我们可以自定义一个数组，先给他数组存储元素数，后面再给他赋值或者接收键盘录入数据 

 二：二维数组

public static void main(String[] args) {
        // 定义一个静态二维数组
        int[][] arr = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11},        //{9, 10, 11,12},
                {13, 14, 15, 16}
        };
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                //arr[i].length是每一行的元素个数
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        //定义一个动态二维数组
        Scanner sc = new Scanner(System.in);
        int[][] arr2 = new int[4][4];
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                arr2[i][j] = sc.nextInt();
            }
        }
    }

1.二维数组相当于几个一维数组一层一层放在一起，每一层一维数组的数目可以不相同，如下：

定义的时候可以只定义行数，不用定义每行多少，后面自己根据情况写

int[][] arr3 = new int[4][];
        arr3[0] = new int[1];
        arr3[1] = new int[2];
        arr3[2] = new int[3];
        arr3[3] = new int[4];
        for (int i = 0; i < arr3.length; i++) {
            for (int j = 0; j < arr3[i].length; j++) {
                arr3[i][j] = sc.nextInt();
            }
        }
        for (int i = 0; i < arr3.length; i++) {
            for (int j = 0; j < arr3[i].length; j++) {
                System.out.print(arr3[i][j] + " ");
            }
            System.out.println();
        }
    }

输入：

1
1 2
1 2 3
1 2 3 4

输出：
1 
1 2 
1 2 3 
1 2 3 4

多维数组类比上面定义 ！！！

三：数组定义后默认值以及赋值

在 Java 中，数组动态初始化时不同数据类型的默认值如下：

 下面我介绍几种场景方法：

（一）：默认值

大多数默认值就是0，false什么的，满足一般要求

（二）：循环赋值

这个不多说，就是循环一个一个赋值，比较繁琐，但是也是常用的方式

（三）：使用 Arrays.fill() 方法

import java.util.Arrays;

public class ArraysFillExample {
    public static void main(String[] args) {
        int[] intArray = new int[5];
        // 将数组所有元素设置为 -1
        Arrays.fill(intArray, -1);

        System.out.println(Arrays.toString(intArray));
    }
}

一行代码解决这种单一赋值，简洁

fill可以填充基本数据类型和引用数据类型，不单单是int

但是fill()方法 不能一句代码赋值多维数组，例如二维数组我们可以变通使用，如下：

import java.util.Arrays;

public class TwoDArrayFillInitialization {
    public static void main(String[] args) {
        int[][] twoDArray = new int[3][3];
        int value = -1;
        for (int i = 0; i < 3; i++) {
            Arrays.fill(twoDArray[i], value);
        }
       
    }
}    

四：数组常见的静态方法

1. Arrays.toString()

此方法能够把数组转换成字符串，方便输出与调试。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

[1, 2, 3, 4, 5]

2. Arrays.sort()

可以对数组进行排序。对于基本数据类型，采用的是双轴快速排序；对于对象数组，使用的是 TimSort 算法。

双轴快速排序：是对传统快速排序算法的优化。传统快速排序选取一个基准元素（pivot）来划分数据，而双轴快速排序则选取两个基准元素，将数组划分成三个部分，以此减少比较和交换的次数，进而提升排序效率。

TimSort算法：对于对象数组，Arrays.sort() 使用 TimSort 算法。TimSort 是一种稳定的混合排序算法，由 Tim Peters 在 2002 年为 Python 编程语言所设计。它结合了归并排序（Merge Sort）和插入排序（Insertion Sort）的优点，在处理不同类型的数据时都能有出色的性能表现。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 3, 4, 1, 2};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

[1, 2, 3, 4, 5]

3. Arrays.binarySearch()

在已排序（有序）的数组里运用二分查找法来查找特定元素。要是找到该元素，就返回其索引；若未找到，则返回一个负数。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int index = Arrays.binarySearch(arr, 3);
        System.out.println("元素 3 的索引是: " + index);
    }
}

运行结果：

元素 3 的索引是: 2

4. Arrays.copyOf() 和 Arrays.copyOfRange()

Arrays.copyOf() 方法能复制数组到一个新数组，新数组的长度可以和原数组不同。Arrays.copyOfRange() 则是复制数组的指定范围。左闭右开区间 [ start,end )

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int[] newArr = Arrays.copyOf(arr, 3);
        int[] rangeArr = Arrays.copyOfRange(arr, 1, 3);
        System.out.println(Arrays.toString(newArr));
        System.out.println(Arrays.toString(rangeArr));
    }
}

运行结果：

[1, 2, 3]
[2, 3]

5. Arrays.equals()

用于比较两个数组是否相等，即数组的长度和对应位置的元素都相同。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        boolean isEqual = Arrays.equals(arr1, arr2);
        System.out.println("两个数组是否相等: " + isEqual);
    }
}

运行结果：

两个数组是否相等: true