Java中的Arrays类是Java标准库中的一个工具类，它提供了一系列静态方法来操作数组，这些方法可以实现对数组的搜索、排序、比较和填充等操作。
目录
一、Arrays.toString()
二、Arrays.sort()
三、Arrays.equals()
四、Arrays.asList()
五、Arrays.copyOf()
六、Arrays.fill()
七、Arrays.binarySearch()
八、Arrays.stream()
九、Arrays练习
1. 给定一个整型数组，使用Arrays类的方法将其所有元素填充为指定的值。
2. 给定两个整型数组，使用Arrays类的方法比较它们是否相等。
3. 给定一个整型数组，使用Arrays类的方法将其复制到一个新的数组中。
4. 给定一个整型二维数组，使用Arrays类的方法对其进行排序，按照每行第一个元素升序排序。
5. 给定一个已排序的整型数组，查找特定元素的位置。如果元素存在，则返回其索引；如果不存在，则返回一个负数。
6. 给定一个整型数组，将数组的前三个元素填充为3。
7. 给定一个整型数组，使用Arrays.copyOf方法创建一个新的数组，新数组是原数组的一个副本，但是长度是原数组长度的两倍。
8. 给定一个整型数组，将该数组的所有元素乘以2，赋值给一个新数组。
9. 合并两个int[]类型的数组，得到一个int[]类型的数组，再转换成List类型
10. 给定一个整型数组，去除数组中的重复元素，并返回一个没有重复元素的新数组，并求出最大值和最小值。
一、Arrays.toString()
- 对于多维数组，直接调用 Arrays.toString() 只会打印子数组的引用，而不是内容。因此，需要遍历多维数组，并对每个子数组分别调用 Arrays.toString()。
import java.util.Arrays;// 定义一个成绩类，包含学生ID、语文成绩、数学成绩以及总分
class Score {public int id; // 学生IDpublic int Chinese; // 语文成绩public int Math; // 数学成绩public int sum; // 总分// 构造方法，初始化学生ID、语文成绩、数学成绩，并计算总分Score(int id, int Chinese, int Math) {this.id = id;this.Chinese = Chinese;this.Math = Math;this.sum = Chinese + Math; // 计算总分}// 重写toString方法，方便输出成绩信息@Overridepublic String toString() {return "Score{" +"id=" + id +", Chinese=" + Chinese +", Math=" + Math +", sum=" + sum +"}";}
}public class Main {public static void main(String[] args) {// 定义一个基本类型数组并初始化int[] intArray = {1, 2, 3, 4, 5};// 使用Arrays.toString()打印数组内容System.out.println(Arrays.toString(intArray)); // 输出: [1, 2, 3, 4, 5]// 定义一个二维数组并初始化int[][] multiArray = {{1, 2}, {3, 4}};// 打印二维数组的引用，不是内容System.out.println(Arrays.toString(multiArray)); // 输出: [[I@49e4cb85, [I@2133c8f8]// 遍历二维数组并打印每个一维数组的内容for (int[] arr : multiArray) {System.out.println(Arrays.toString(arr));// 输出每个一维数组的内容// [1, 2]// [3, 4]}// 定义一个成绩对象数组并初始化Score[] scoreArray = {new Score(1, 90, 80),new Score(2, 95, 86)};// 使用Arrays.toString()打印成绩对象数组的内容System.out.println(Arrays.toString(scoreArray)); // 输出: [Score{id=1, Chinese=90, Math=80, sum=170}, Score{id=2, Chinese=95, Math=86, sum=181}]}
}
二、Arrays.sort()
- sort(Object[] a): 对整个数组进行排序。
- sort(T[] a, int fromIndex, int toIndex): 对数组的指定范围进行排序。
import java.util.Arrays;
import java.util.Collections;// 定义一个成绩类，包含学生ID、语文成绩、数学成绩以及总分
class Score {public int id; // 学生IDpublic int Chinese; // 语文成绩public int Math; // 数学成绩public int sum; // 总分// 构造方法，初始化学生ID、语文成绩、数学成绩，并计算总分Score(int id, int Chinese, int Math) {this.id = id;this.Chinese = Chinese;this.Math = Math;this.sum = Chinese + Math; // 计算总分}// 重写toString方法，方便输出成绩信息@Overridepublic String toString() {return "Score{" +"id=" + id +", Chinese=" + Chinese +", Math=" + Math +", sum=" + sum +"}";}
}public class Main {public static void main(String[] args) {// 对基本类型的数组进行排序int[] intArr = {1, 3, 5, 7, 6, 4, 2};Arrays.sort(intArr); // 使用Arrays.sort进行升序排序System.out.println(Arrays.toString(intArr)); // 输出排序后的数组，结果为[1, 2, 3, 4, 5, 6, 7]// 对包装类型的数组进行降序排序Integer[] integerArr = {1, 3, 5, 7, 6, 4, 2};Arrays.sort(integerArr, Collections.reverseOrder()); // 使用Collections.reverseOrder进行降序排序System.out.println(Arrays.toString(integerArr)); // 输出排序后的数组，结果为[7, 6, 5, 4, 3, 2, 1]// 对成绩对象数组进行排序Score[] scoreArr = {new Score(1, 90, 80),new Score(2, 95, 86),new Score(3, 95, 100),new Score(4, 80, 90)};// 按照总分降序排序，如果总分一样，按照语文成绩降序排序Arrays.sort(scoreArr,(s1, s2) -> s2.sum - s1.sum == 0 ? s2.Chinese - s1.Chinese : s2.sum - s1.sum);// 遍历并输出排序后的成绩数组for (var i : scoreArr) {System.out.println(i);}// 输出结果：// Score{id=3, Chinese=95, Math=100, sum=195}// Score{id=2, Chinese=95, Math=86, sum=181}// Score{id=1, Chinese=90, Math=80, sum=170}// Score{id=4, Chinese=80, Math=90, sum=170}}
}
三、Arrays.equals()
import java.util.Arrays;public class Main {public static void main(String[] args) {// 创建两个整型数组int[] array1 = {1, 2, 3, 4, 5};int[] array2 = {1, 2, 3, 4, 5};int[] array3 = {5, 4, 3, 2, 1};// 使用 Arrays.equals 比较两个数组boolean equals = Arrays.equals(array1, array2);System.out.println("array1 和 array2 是否相等: " + equals); // trueequals = Arrays.equals(array1, array3);System.out.println("array1 和 array3 是否相等: " + equals); // false}
}
四、Arrays.asList()
import java.util.Arrays;
import java.util.List;public class Main {public static void main(String[] args) {// 使用 Arrays.asList 将数组转换为 ListInteger[] array = {1, 2, 3, 4, 5};List<Integer> list1 = Arrays.asList(array); //可改元素，不能增加和删除// 输出转换后的 ListSystem.out.println(list1); // 输出 [1, 2, 3, 4, 5]// 尝试修改 List 中的一个元素list1.set(0, 10); // 这是允许的，因为它修改了原始数组中的元素System.out.println(list1); // 输出 [10, 2, 3, 4, 5]// 尝试添加或删除元素将抛出异常// list1.add(6); // 抛出 UnsupportedOperationException// list1.remove(1); // 抛出 UnsupportedOperationException// 比较Arrays.asList 和 List.ofList<Integer> list2 = List.of(array);// 输出创建的 ListSystem.out.println(list2); // 输出 [1, 2, 3, 4, 5]// 尝试修改 List 中的一个元素将抛出异常// list2.set(0, 10); // 抛出 UnsupportedOperationException// 尝试添加或删除元素也将抛出异常// list2.add(6); // 抛出 UnsupportedOperationException// list2.remove(1); // 抛出 UnsupportedOperationException}
}
五、Arrays.copyOf()
- int[] copyOf(int[] original, int newLength)：从original数组中截取长度为newLength的新数组
- int[] copyOfRange(int[] original, int from, int to)：从original数组中截取[from,to)新数组
import java.util.Arrays;public class Main {public static void main(String[] args) {// 示例1：复制基本数据类型数组int[] originalArray = {1, 2, 3, 4, 5};int[] newArray = Arrays.copyOf(originalArray, 10); // 新数组长度为10System.out.println("新数组（基本数据类型）: " + Arrays.toString(newArray)); //[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]// 示例2：复制对象数组String[] originalStringArray = {"Apple", "Banana", "Cherry"};String[] newStringArray = Arrays.copyOf(originalStringArray, 5); // 新数组长度为5System.out.println("新数组（对象数组）: " + Arrays.toString(newStringArray)); //[Apple, Banana, Cherry, null, null]// 示例3：新数组长度小于原始数组int[] originalArray2 = {1, 2, 3, 4, 5};int[] newArray2 = Arrays.copyOf(originalArray2, 3); // 新数组长度为3System.out.println("新数组（部分复制）: " + Arrays.toString(newArray2)); //[1, 2, 3]// 示例4：使用Arrays.copyOfRange复制数组的一部分int[] newArray3 = Arrays.copyOfRange(originalArray2, 1, 4);System.out.println("新数组（copyOfRange）: " + Arrays.toString(newArray3)); //[2, 3, 4]}
}
六、Arrays.fill()
- void fill(Object[] a, Object val)：填充数组
- void fill(Object[] a, int fromIndex, int toIndex, Object val)：填充数组[fromIndex,toIndex)
import java.util.Arrays;public class Main {public static void main(String[] args) {// 创建一个整型数组int[] array = new int[10];// 使用 fill 方法将整个数组填充为 5Arrays.fill(array, 5);System.out.println("填充整个数组: " + Arrays.toString(array)); // [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]// 使用 fill 方法将数组的索引 3 到索引 7 的元素填充为 8Arrays.fill(array, 3, 8, 8);System.out.println("填充部分数组: " + Arrays.toString(array)); // [5, 5, 5, 8, 8, 8, 8, 8, 5, 5]}
}
七、Arrays.binarySearch()
（1）int binarySearch(Object[] a, Object key)：
- 在数组a中查找key。
- 如果找到key，则返回其在数组中的索引。
- 如果未找到key，则返回-(insertion point) - 1，其中insertion point是key应该插入的位置。
（2）int binarySearch(int[] a, int fromIndex, int toIndex, int key)：
- 在数组a的子数组[fromIndex, toIndex)中查找key。
- 如果找到key，则返回其在子数组中的索引。
- 如果未找到key，则返回-(insertion point) - 1，其中insertion point是key应该插入的位置。
import java.util.Arrays;public class Main {public static void main(String[] args) {// 创建并初始化一个已排序的整型数组int[] array = {1, 3, 5, 7, 9, 11, 13, 15};// 查找元素7int index1 = Arrays.binarySearch(array, 7);System.out.println(index1); // 3// 在子数组[2, 6)中[5, 7, 9, 11]查找元素5int index2 = Arrays.binarySearch(array, 2, 6, 5);System.out.println(index2); // 2// 查找一个不存在的元素，比如4int index3 = Arrays.binarySearch(array, 4);System.out.println(index3); // 应输出一个负数，表示插入点}
}
八、Arrays.stream()
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.OptionalDouble;
import java.util.OptionalInt;public class Main {public static void main(String[] args) {int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};// 案例1: 计算数组元素的总和int sum = Arrays.stream(numbers).sum();System.out.println("Sum: " + sum); // 预期输出: Sum: 55// 案例2: 计算数组元素的平均值OptionalDouble average = Arrays.stream(numbers).average();System.out.println("Average: " + average.getAsDouble()); // 预期输出: Average: 5.5// 案例3: 找出数组中的最大值OptionalInt max = Arrays.stream(numbers).max();System.out.println("Max: " + max.getAsInt()); // 预期输出: Max: 10// 案例4: 找出数组中的最小值OptionalInt min = Arrays.stream(numbers).min();System.out.println("Min: " + min.getAsInt()); // 预期输出: Min: 1// 案例5: 计算数组中偶数的个数long evenCount = Arrays.stream(numbers).filter(n -> n % 2 == 0).count();System.out.println("Even count: " + evenCount); // 预期输出: Even count: 5// 案例6: 将数组中的每个元素乘以2int[] multiplied = Arrays.stream(numbers).map(n -> n * 2).toArray();System.out.println("Multiplied: " + Arrays.toString(multiplied)); // 预期输出: Multiplied: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]// 案例7: 将数组中的偶数平方int[] squaredEvens = Arrays.stream(numbers).filter(n -> n % 2 == 0).map(n -> n * n).toArray();System.out.println("Squared evens: " + Arrays.toString(squaredEvens)); // 预期输出: Squared evens: [4, 16, 36, 64, 100]// 案例8: 检查数组中是否所有元素都大于0boolean allPositive = Arrays.stream(numbers).allMatch(n -> n > 0);System.out.println("All positive: " + allPositive); // 预期输出: All positive: true// 案例9: 检查数组中是否至少有一个元素大于5boolean anyGreaterThanFive = Arrays.stream(numbers).anyMatch(n -> n > 5);System.out.println("Any greater than 5: " + anyGreaterThanFive); // 预期输出: Any greater than 5: true// 案例10: 获取数组元素的统计信息IntSummaryStatistics stats = Arrays.stream(numbers).summaryStatistics();System.out.println("Statistics: " + stats); // 预期输出: Statistics: IntSummaryStatistics{count=10, sum=55, min=1, average=5.500000, max=10}}
}
九、Arrays练习
1. 给定一个整型数组，使用Arrays类的方法将其所有元素填充为指定的值。
import java.util.Arrays;public class Main {public static void main(String[] args) {int[] arr = new int[]{1, 4, 5, 7, 9, 3};Arrays.fill(arr, 1);System.out.println(Arrays.toString(arr));}
}
2. 给定两个整型数组，使用Arrays类的方法比较它们是否相等。
import java.util.Arrays;public class Main {public static void main(String[] args) {int[] arr1 = new int[]{1, 4, 5, 7, 9, 3};int[] arr2 = {1, 4, 5, 7, 9, 3};boolean equals = Arrays.equals(arr1, arr2);System.out.println(equals); //true}
}
3. 给定一个整型数组，使用Arrays类的方法将其复制到一个新的数组中。
import java.util.Arrays;public class Main {public static void main(String[] args) {int[] arr1 = new int[]{1, 4, 5, 7, 9, 3};int[] arr2 = Arrays.copyOf(arr1, arr1.length);System.out.println(Arrays.toString(arr2)); //[1, 4, 5, 7, 9, 3]}
}
4. 给定一个整型二维数组，使用Arrays类的方法对其进行排序，按照每行第一个元素升序排序。
import java.util.Arrays;
import java.util.Comparator;public class Main {public static void main(String[] args) {int[][] arr = {{3, 5}, {1, 2}, {4, 6}};Arrays.sort(arr, Comparator.comparingInt(a -> a[0]));for (int[] a : arr) {System.out.println(Arrays.toString(a));}//[1, 2]//[3, 5]//[4, 6]}
}
5. 给定一个已排序的整型数组，查找特定元素的位置。如果元素存在，则返回其索引；如果不存在，则返回一个负数。
import java.util.Arrays;public class Main {public static void main(String[] args) {int[] arr = {1, 3, 5, 6, 7, 8, 9};int i1 = Arrays.binarySearch(arr, 3);int i2 = Arrays.binarySearch(arr, 4);System.out.println(i1); // 1System.out.println(i2); // -3}
}
6. 给定一个整型数组，将数组的前三个元素填充为3。
import java.util.Arrays;public class Main {public static void main(String[] args) {int[] arr = {1, 3, 5, 6, 7, 8, 9};Arrays.fill(arr,0,3,3);System.out.println(Arrays.toString(arr)); //[3, 3, 3, 6, 7, 8, 9]}
}
7. 给定一个整型数组，使用Arrays.copyOf方法创建一个新的数组，新数组是原数组的一个副本，但是长度是原数组长度的两倍。
import java.util.Arrays;public class Main {public static void main(String[] args) {int[] arr1 = {1, 3, 5, 6, 7, 8, 9};int[] arr2 = Arrays.copyOf(arr1, arr1.length * 2);System.out.println(Arrays.toString(arr2)); //[1, 3, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0]}
}
8. 给定一个整型数组，将该数组的所有元素乘以2，赋值给一个新数组。
import java.util.Arrays;public class Main {public static void main(String[] args) {int[] arr1 = {1, 3, 5, 6, 7, 8, 9};int[] arr2 = Arrays.stream(arr1).map(i -> i * 2).toArray();System.out.println(Arrays.toString(arr2)); //[2, 6, 10, 12, 14, 16, 18]}
}
9. 合并两个int[]类型的数组，得到一个int[]类型的数组，再转换成List<Integer>类型
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class Main {public static void main(String[] args) {int[] arr1 = {1, 3, 5, 7, 9};int[] arr2 = {2, 4, 6, 8, 10, 12};int[] arr3 = Arrays.copyOf(arr1, arr1.length + arr2.length);System.out.println(Arrays.toString(arr3)); //[1, 3, 5, 7, 9, 0, 0, 0, 0, 0, 0]//从arr2的0号元素开始，复制到arr3，从arr3的arr1.length号元素开始，复制arr2.length个元素System.arraycopy(arr2, 0, arr3, arr1.length, arr2.length);System.out.println(Arrays.toString(arr3)); //[1, 3, 5, 7, 9, 2, 4, 6, 8, 10, 12]Arrays.sort(arr3);System.out.println(Arrays.toString(arr3)); //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12]List<Integer> list = Arrays.stream(arr3).boxed().collect(Collectors.toList());System.out.println(list); //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12]}
}
10. 给定一个整型数组，去除数组中的重复元素，并返回一个没有重复元素的新数组，并求出最大值和最小值。
import java.util.Arrays;public class Main {public static void main(String[] args) {int[] arr1 = {1, 3, 3, 3, 3, 5, 5, 6, 8, 9};int[] arr2 = Arrays.stream(arr1).distinct().toArray();System.out.println(Arrays.toString(arr2)); //[1, 3, 5, 6, 8, 9]int max = Arrays.stream(arr2).max().getAsInt();int min = Arrays.stream(arr2).min().getAsInt();System.out.println(max); // 9System.out.println(min); // 1}
}
