Arrays和Collections常用操作

Arrays 和 Collections

Arrays

在Java中，操作数组的方法主要集中在Arrays类中，这是一个包含静态方法的工具类，专门用于处理数组。以下是Arrays类中一些常用方法的总结和示例：

1. sort(array): 对数组进行排序。

   int[] array = {4, 2, 5, 1, 3};
   Arrays.sort(array);
   // array 现在是 [1, 2, 3, 4, 5]
   

2. toString(array): 返回数组的字符串表示形式。

   int[] array = {1, 2, 3, 4, 5};
   System.out.println(Arrays.toString(array));
   // 输出：[1, 2, 3, 4, 5]
   

3. fill(array, val): 将指定的值分配给数组的每个元素。

   int[] array = new int[5];
   Arrays.fill(array, 9);
   // array 现在是 [9, 9, 9, 9, 9]
   

4. binarySearch(array, key): 在数组中使用二分查找算法查找指定的元素。

   int[] array = {1, 2, 3, 4, 5};
   int index = Arrays.binarySearch(array, 4);
   // index 是 3
   

5. copyOf(array, newLength): 复制数组，截断或用默认值填充（如果必要的话），以使副本具有指定的长度。

   int[] original = {1, 2, 3, 4, 5};
   int[] copy = Arrays.copyOf(original, 3);
   // copy 是 [1, 2, 3]
   

6. copyOfRange(array, from, to): 复制数组的指定范围。

   int[] original = {1, 2, 3, 4, 5};
   int[] rangeCopy = Arrays.copyOfRange(original, 1, 4);
   // rangeCopy 是 [2, 3, 4]
   

7. equals(array1, array2): 比较两个数组是否相等。

   int[] array1 = {1, 2, 3};
   int[] array2 = {1, 2, 3};
   boolean equal = Arrays.equals(array1, array2);
   // equal 是 true
   

8. deepEquals(array1, array2): 对于多维数组，可以用来比较两个数组的深层内容是否相等。

   int[][] array1 = {{1, 2, 3}, {4, 5, 6}};
   int[][] array2 = {{1, 2, 3}, {4, 5, 6}};
   boolean deepEqual = Arrays.deepEquals(array1, array2);
   // deepEqual 是 true
   

这些方法提供了一种快捷、高效的方式来操作Java数组，从基本的排序和搜索到复杂的比较和转换操作。使用Arrays类的方法可以极大地简化数组的处理过程。

Collections

Java中的Collections类是一个包含静态方法的工具类，这些方法用于操作或返回集合。下面是一些Collections类中常用的方法，以及相应的Java代码示例：

1. sort(List list): 对列表进行排序。

   List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9);
   Collections.sort(list);
   System.out.println(list); // 输出排序后的列表
   

2. reverse(List<?> list): 反转列表。

   List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9);
   Collections.reverse(list);
   System.out.println(list); // 输出反转后的列表
   

3. shuffle(List<?> list): 对列表进行随机排序。

   List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9);
   Collections.shuffle(list);
   System.out.println(list); // 输出打乱后的列表
   

4. min(Collection<? extends T> coll), max(Collection<? extends T> coll): 返回集合中的最小或最大元素。

   List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9);
   int min = Collections.min(list);
   int max = Collections.max(list);
   System.out.println("Min: " + min + ", Max: " + max); // 输出最小和最大值
   

5. frequency(Collection<?> c, Object o): 返回指定集合中指定元素的出现次数。

   List<String> list = Arrays.asList("apple", "banana", "apple", "orange");
   int freq = Collections.frequency(list, "apple");
   System.out.println(freq); // 输出“apple”出现的次数
   

6. swap(List<?> list, int i, int j): 交换列表中指定位置的元素。

   List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9);
   Collections.swap(list, 0, 5); // 交换位置0和位置5的元素
   System.out.println(list); // 输出交换后的列表
   

7. fill(List<? super T> list, T obj): 用指定元素替换列表中的所有元素。

   List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "orange"));
   Collections.fill(list, "strawberry");
   System.out.println(list); // 输出填充后的列表
   

这些方法提供了一种快捷、高效的方式来操作Java集合。使用Collections类的方法可以极大地简化集合的操作过程。