操作数组的工具类Arrays

首先要导包：
import java.util.Arrays;

排序

//1.sort排序String[]数组：升序:从小到大
String[] names = { "Liz", "John", "Eric", "Alan" };
//只排序前两个
//[John, Liz, Eric, Alan]
Arrays.sort(names, 0, 2);
//全部排序
//[Alan, Eric, John, Liz]
Arrays.sort(names);
String [] name = {"li","ad","sf","qw"};
Arrays.sort(name);

当然，这里的排序也可以是自定义排序，有两种方式，一种是要比较的类实现Comparable接口：

import java.util.Arrays;

public class Employee implements Comparable<Employee> {
  String name;
  double salary;

  public Employee(String name, double salary) {
    this.name = name;
    this.salary = salary;
  }

  public int compareTo(Employee other) {
    return Double.compare(salary, other.salary);
  }

  public static void main(String[] args) {
    Employee[] staff = new Employee[4];
    staff[2] = new Employee("Carl Cracker", 75000);
    staff[3] = new Employee("Tony Tester", 38000);
    staff[0] = new Employee("Harry Hacker", 35000);
    staff[1] = new Employee("Harry Hacker2", 35000);
    Arrays.sort(staff);
    for (Employee e : staff) {
      System.out.println("name=" + e.name + " , salary=" + e.salary);
    }
  }
}

输出结果为：
name=Harry Hacker , salary=35000.0
name=Harry Hacker2 , salary=35000.0
name=Tony Tester , salary=38000.0
name=Carl Cracker , salary=75000.0

另一种是新建一个比较器类专门比较该类，该类实现了Comparator接口

如： 需要按照字符的长度递增来进行排序，这里用到了函数式编程写法：

import java.util.Arrays;
import java.util.Comparator;

public class Test {
  public static void main(String[] args) {
    String[] friends = {"Peter", "Paulllll", "Mary"};
    Arrays.sort(friends, Comparator.comparingInt(String::length));

    for (String f : friends) {
      System.out.print(f + " ");
    }
  }
}

输出结果为：
Mary Peter Paulllll

返回固定大小的List

//2.使用该方法可以返回一个固定大小的List，如：
List str= Arrays.asList(“welcome”,“to”,“fsdg”);
List intList = Arrays.asList(1, 2, 3, 4);

打印一维数组

//3.toString()方法：方便我们打印出数组的内容。
int[] ,String[],long[],boolean[]…
System.out.println(Arrays.toString(name));
System.out.println(Arrays.toString(a));

打印二维数组

//4.deepToString:方法：打印二维数组；
int[][] twoD={{1,2,3,4},{3,6,7,8}};
System.out.println(Arrays.deepToString(twoD));

比较两个一维数组内容是否相等

//5.equals：方法：使用Arrays.equals().来比较1维数组是否相等。
String[] names1 = { “Eric”, “John”, “Alan”, “Liz” };
String[] names2 = { “Eric”, “John”, “Alan”, “Liz” };
System.out.println(Arrays.equals(names1,names2));
注意正确重写equals方法。

比较两个二维数组内容是否相等

//6.Arrays.deepEquals能够去判断更加复杂的数组是否相等。
int[][] stuGrades1 = { { 80, 81, 82 }, { 84, 85, 86 }, { 87, 88, 89 } };
int[][] stuGrades2 = { { 80, 81, 82 }, { 84, 85, 86 }, { 87, 88, 89 } };
System.out.println(Arrays.deepEquals(stuGrades1, stuGrades2));

填充数组

//7.fill()方法，用某个数组填充数组。
int[] array1 = new int[8];
Arrays.fill(array1, 1);
//[1, 1, 1, 1, 1, 1, 1, 1]
System.out.println(Arrays.toString(array1));
Arrays.fill(array1, 3);
System.out.println(Arrays.toString(array1));

折半查找元素

//8. binarySearch方法 ：折半查找法 ，返回所给元素的索引
//- 用法：
//- //fromIndex,toIndex这两个参数可以省略（表示整个数组）
//不省略表示在这个区间查找，左闭右开， key 表示要查找的元素
//返回要查找元素的 索引位置
int index = Arrays.binarySearch(new int[] { 1, 2, 3, 4, 5, 6, 7 }, 6);
public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)

如果没有找到，则返回插入位置的相反数，太棒了！

public class Hello {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5};
        System.out.println(Arrays.binarySearch(arr, 4));
    }
}
// 输出 -3 （说明：插入在第三个位置，注意和索引间的转换）

拷贝数组

//9. copyOf及copyOfRange方法 :将一个数组拷贝到另一个数组中/或者其中//的一部分

//索引都是从零开始

String[] names2 = { "Eric", "John", "Alan", "Liz" };
//[Eric, John, Alan]
String[] copy = Arrays.copyOf(names2, 3); 
//[Alan, Liz]   ，左闭右开
String[] rangeCopy = Arrays.copyOfRange(names2, 2, names2.length);

Arrays中的Arraylist和ArrayList的区别

List integers = Arrays.asList(1, 2, 3, 4);
在日常操作中，我们通常都会使用add和remove方法对List的元素进行管理。如

integers.add(5);
integers.remove(1)
这时就出现了异常：java.lang.UnsupportedOperationException
原因：Arrays.asList()返回了一个定长的list, 这个方法充当array系列API和collection系列API之间的桥梁。所以说，返回值，只是数组简单包装而成的List而已，并不能改变其长度。

不过没有关系，我们可以用ArrayList的构造方法，来创建一个新的ArrayList，然后再进行增删操作。

Integer[] ints = {1, 2, 3, 4};
ArrayList integers = new ArrayList<>(Arrays.asList(ints));
integers.add(5);

假ArrayList: java.util.Arrays$ArrayList
真ArrayList: java.util.ArrayList

Arrays.asList(T… a)中返回的ArrayList是Arrays的内部类，继承了AbstractList。所以说调用add方法的时候，其实调用了父类AbstractList的方法，方法源码如下：（假ArrayList）

public void add(int index, E element) {
throw new UnsupportedOperationException(); //直接抛出了异常。
}

真ArrayList
我们通常用的ArrayList，继承了AbstractList，并重写了add, remove等方法,

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

public E remove(int index) {
      rangeCheck(index)
      modCount++;
      E oldValue = elementData(index)
      int numMoved = size - index - 1;
      if (numMoved > 0)
          System.arraycopy(elementData, index+1, elementData, index,
                           numMoved);
      elementData[--size] = null; // clear to let GC do its wor
      return oldValue;
    }