Arrays用法总结

数组转字符串

int[] array = new int[]{ 
  1, 2, 3}; out.println(Arrays.toString(array)); //[1, 2, 3]

如果是一维数组，toString方法可以很好的适用。但遇到多维数组时，需要使用deepToString把数组完全转成字符串。

int[][] deepArray = new int[][]{ 
  { 
  1, 3},{ 
  2, 4}}; out.println(Arrays.toString(deepArray)); //[[I@1540e19d, [I@b6] out.println(Arrays.deepToString(deepArray)); //[[1, 3], [2, 4]]

填充数组

array = new int[5]; Arrays.fill(array, 2); out.println(Arrays.toString(array)); //[2, 2, 2, 2, 2] array = new int[5]; Arrays.fill(array, 1, 4, 2); //部分填充 out.println(Arrays.toString(array));//[0, 2, 2, 2, 0]

数组元素排序

array = new int[]{3, 10, 4, 0, 2}; Arrays.sort(array); out.println(Arrays.toString(array)); //[0, 2, 3, 4, 10] array = new int[]{3, 10, 4, 0, 2}; Arrays.parallelSort(array); //和sort相比是这个是并行的 out.println(Arrays.toString(array)); //[0, 2, 3, 4, 10] array = new int[]{3, 10, 4, 0, 2}; Arrays.sort(array, 0, 4); //部分排序 out.println(Arrays.toString(array)); //[0, 3, 4, 10, 2]

数组的比较

array = new int[]{ 
  1, 2, 3}; int[] array2 = new int[]{ 
  1, 2, 3}; out.println(Arrays.equals(array, array2)); //true

和toString方法一样，equals方法遇到多维数组时也会出现问题。

int[][] deepArray1 = new int[][]{ 
  { 
  1, 3},{ 
  2, 4}}; int[][] deepArray2 = new int[][]{ 
  { 
  1, 3},{ 
  2, 4}}; out.println(Arrays.equals(deepArray1, deepArray2)); //false out.println(Arrays.deepEquals(deepArray1, deepArray2)); //true

deepEquals用于判定两个指定数组彼此是否深层相等，此方法适用于任意深度的嵌套数组。

equals用于判定两个数组是否相等，如果两个数组以相同顺序包含相同元素，则返回true。

如果两个数组使用equals返回true，则使用deepEquals必定也返回true，也就是说在比较的两个数组均为一维数组的前提下，equals和deepEquals的比较结果没有差别。

数组复制

array = new int[]{ 
  3, 10, 4, 0, 2}; int[] arrayCopy = Arrays.copyOf(array, 3); out.println(Arrays.toString(arrayCopy)); //[3, 10, 4] arrayCopy = Arrays.copyOf(array, 7); out.println(Arrays.toString(arrayCopy)); //[3, 10, 4, 0, 2, 0, 0], 多出的长度补0 arrayCopy = Arrays.copyOfRange(array, 1, 4); out.println(Arrays.toString(arrayCopy)); //[10, 4, 0]

二分查找返回下标

array = new int[]{0, 3, 4, 10, 20}; out.println(Arrays.binarySearch(array, 10)); //3, array必须是排序的，否则得到的是错误的结果 out.println(Arrays.binarySearch(array, 6)); //-4, 找不到的值，从-1开始，6如果存在下标是3， 所以返回-4 out.println(Arrays.binarySearch(array, 2, 5, 10)); //3, 返回的还是全局的下标值。

数组转List

int array = new int[]{ 
  3, 10, 4, 0, 2}; out.println(Arrays.asList(array).contains(3)); //false Integer arr[] = new Integer[]{ 
  3, 10, 4, 0, 2}; out.println(Arrays.asList(arr).contains(3)); //true

这里是比较有意思的地方，实际上拆开来看是这样的

int array = new int[]{ 
  3, 10, 4, 0, 2}; List<int[]> ints = Arrays.asList(array);

Integer arr[] = new Integer[]{3, 10, 4, 0, 2}; List<Integer> integers = Arrays.asList(arr);

现在就知道区别了，原始数据类型int的数组调用asList之后得到的List只有一个元素，这个元素就是元素类型的数组。而封装类Integer数组调用asList是把数组中每个元素加到了List中。

对数组元素采用指定的方法计算

array = new int[]{ 
  3, 10, 4, 0, 2}; Arrays.parallelPrefix(array, (x,y)->(x+y)); //[3, 13, 17, 17, 19] out.println(Arrays.toString(array)); array = new int[]{3, 10, 4, 0, 2}; Arrays.parallelSetAll(array, (x)->(x*x)); //[0, 1, 4, 9, 16] out.println(Arrays.toString(array)); Arrays.setAll(array, (x)->(x%3)); out.println(Arrays.toString(array)); //[0, 1, 2, 0, 1], 与parallelSetAll相比只是不并行

对其他对象数组进行排序

public class Test{ 
    public static void main(String[] args){ Employee[] employees = new Employee[3]; employees[0] = new Employee(20); employees[1] = new Employee(10); employees[2] = new Employee(30); Arrays.sort(employees); for(Employee e : employees){ System.out.println(e); //Employee{id=10} Employee{id=20} Employee{id=30} } } static class Employee implements Comparable<Employee>{ 
    private int id; public Employee(int id){ 
  this.id = id;} @Override public int compareTo(Employee o) { return this.id - o.id; } @Override public String toString() { return "Employee{" + "id=" + id + '}'; } } }

自定义排序规则

String[] names = { 
  "tom", "alice", "fred"}; Arrays.sort(names); out.println(Arrays.toString(names));

public class LengthComparator implements Comparator<String> { 
    @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } public static void main(String[] args){ String[] names = { 
  "tom", "alice", "fred"}; Arrays.sort(names, new LengthComparator()); out.println(Arrays.toString(names)); } }

String[] names = { 
  "tom", "alice", "fred"}; Comparator 
  
    comp = ( 
   first, 
   second) -> 
   first. 
   length() - 
   second. 
   length(); Arrays.sort(names, comp); 
  

或者更加简单点

String[] names = { 
  "tom", "alice", "fred"}; Arrays.sort(names, (first, second) -> first.length() - second.length());

Arrays.sort方法的第二个参数变量接受一个实现了Comparator接口的类的实例，调用该对象的compare方法会执行lambda表达式中的代码，所以这也就是为什么接口只有一个抽象方法的时候可以用lambda表达式代替。