数组

int[] arr = {5, 2, 8, 1, 6};
Arrays.sort(arr);
结果为{1, 2, 5, 6, 8}
也可以使用Collections类的sort()方法对数组进行排序，但需要先将数组转换为List。

Java中 Arrays类 提供了许多常用方法，其中一些包括：
不需要实例化Arrays类的对象就可以直接调用这些方法，例如Arrays.sort()

1. sort()：对数组进行排序。
2. binarySearch()：使用二分查找算法在排序数组中查找指定元素。
3. fill()：使用指定值填充数组。

int[] arr = {1, 2, 3, 4, 5};
Arrays.fill(arr, 0); // 现在arr数组中的所有元素都被替换为0

int[] arr = {1, 2, 3, 4, 5};
Arrays.fill(arr, 1, 4, 0); // 现在arr数组中索引为1到3的元素（不包括索引4）都被替换为0

4. equals()：比较两个数组是否相等。
5. copyOf()：复制指定的数组，可以指定新数组的长度。
6. copyOfRange(T[] original, int from, int to):方法是用来复制指定范围内的数组元素并返回一个新的数组
7. asList()：将数组转换为List。
8. toString()：将数组转换为字符串。
9. hashCode()：返回数组的哈希码值。
10. deepEquals()：递归比较两个多维数组是否相等。
11. parallelSort()：使用并行排序算法对数组进行排序。
12. public static < T > void sort(T[] a, Comparator<? super T> c)
13. public static IntStream stream(int[] array):将传入的int数组转换为一个IntStream流(专门用于处理int类型的流)

计算和

这段代码使用了Java 8中的Stream API来计算数组中所有元素的和。
首先，Arrays.stream(nums)将传入的int数组nums转换为一个IntStream流。IntStream是一个专门用于处理int类型的流。
然后，.sum()是IntStream流的一个终端操作，它将对流中的所有元素进行求和，返回求和结果。
所以，int total = Arrays.stream(nums).sum();的作用是计算数组nums中所有元素的和，并将结果存储在变量total中。

计算数组中所有元素的和

int[] nums;
int total = Arrays.stream(nums).sum();

二维数组

在Java中，二维数组的长宽可以分别用数组的列数和行数来表示。
例如：
一个二维数组arr的长可以用 arr.length 来表示，
而宽可以用 arr[0].length 来表示（假设arr的每一行都包含相同数量的元素）。

遍历原数组中的元素，其坐标在原数组中的位置(在mxn的二维数组中)：
(x表示第0个、第1个、第2个… x∈[0,mn))
行 = x/n
列 = x%n

如何得到周围相邻格子的状态？
static int[] dx = {0, 1, 0, -1};//上下
static int[] dy = {1, 0, -1, 0};//左右
定义两个静态数组 dx 和 dy，分别存储在二维网格中上下左右四个方向的偏移量。
具体来说，dx 和 dy 中的元素分别表示了在二维网格中向右、向下、向左、向上四个方向的偏移量。
例如(左上角为原点)，dx[0] = 0，dy[0] = 1 表示向右移动一步，
dx[1] = 1，dy[0] = 0 表示向下移动一步，以此类推。

 int[] dx = {0, 1, 0, -1};
 int[] dy = {1, 0, -1, 0};

for(int k = 0; k < 4; k++){
  int x = i + dx[k];//偏移后的行
  int y = j + dy[k];//偏移后的高
}
                    

排序

Arrays.sort()方法是Java中用于对数组进行排序的静态方法。
它可以对包含基本数据类型或对象的 数组 进行排序，其中排序的规则可以是 自然顺序 或 自定义顺序 。

1. 数组：对数组进行排序。
2. 数组的起始索引和结束索引：对指定范围内的数组进行排序。
3. 比较器：自定义 Comparator 对象：使用 Comparator 对象定义的排序规则对数组进行排序。

Arrays.sort(arr, new Comparator<String>() {
           @Override
           public int compare(String s1, String s2) {
               if (s1.length() != s2.length()) {
                   return s2.length() - s1.length(); // 按照字符串长度由大到小排序
               } else {
                   return s1.compareTo(s2); // 长度相同时，按照字典序由小到大排序
               }
           }
       });

Arrays.sort(words, (a, b) ->  {
           if (a.length() != b.length()) {
               return b.length() - a.length();
           } else {
               return a.compareTo(b);
           }
       });

语法

public static void sort(Object[] a)
public static void sort(Object[] a, Comparator comparator)

• 第一个参数a是要排序的数组。
• 第二个参数comparator是一个比较器，用于指定排序的规则。如果不提供比较器，则会使用默认的自然顺序进行排序。

工作原理

• 对于基本数据类型数组，Arrays.sort()方法使用快速排序算法或归并排序算法来对数组进行排序。
• 对于对象数组，Arrays.sort()方法会调用对象的compareTo()方法（如果对象实现了Comparable接口），或者使用提供的比较器Comparator来进行排序。

示例

// 对整数数组进行排序
int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
Arrays.sort(arr);

// 对字符串数组按照长度进行排序
String[] names = {"Alice", "Bob", "Charlie", "David"};
Arrays.sort(names, (a, b) -> a.length() - b.length());

在上面的示例中，第一个例子对整数数组进行排序，而第二个例子对字符串数组按照长度进行排序，使用了Lambda表达式来定义比较器。

一维数组

// 对数组进行排序
Arrays.sort(arr);
// 将数组从高到低排序
Arrays.sort(arr, Collections.reverseOrder());


Arrays.sort(arr); // 对数组进行正向排序
Collections.reverse(Arrays.asList(arr)); // 反转数组元素顺序

二维数组

//二维数组
int[][] arr = new int[n][2];
//按照第二位升序排列(从小到大)
Arrays.sort(arr, (a, b) -> a[1] - b[1]);
//按照第二位降序排列(从大到小)
Arrays.sort(arr, (a, b) -> b[1] - a[1]);


//按照第一位升序排列(从小到大)
Array.sort(arr,(a,b) -> a[0] - b[0]);
//按照第一位降序排列(从大到小)
Array.sort(arr,(a,b) -> b[0] - a[0]);

Donate