Arrays类常用方法总结

Arrays类

常用方法

数组转列表asList

List  asList(T... a)

 数组进行内部排序sort

void sort(Object[] array)

void sort(T[] array, Comparator comparator)

void sort(Object[] array, int fromIndex, int toIndex)

void sort(T[] array, int fromIndex, int toIndex, Comparator c)

 void parallelSort(T[] array)

使用二分法查找指定元素binarySearch

int binarySearch(Object[ ] a,Object key)

int  binarySearch(Object[] array, int fromIndex, int toIndex, Object obj)

数组拷贝copyOf

T[] copyOf(T[] original ,int newLength)

T[] copyOfRange(T[] original ,int form,int to)

数组比较equals

boolean equals(Object[] a1,Object[] a2)

填充fill

 void  fill(Object[] array, Object obj)

void fill(Object[] array, int fromIndex, int toIndex, Object obj)

转字符串toString

String  toString(Object[] array)

 String deepToString(Object[] array)

返回哈希值

int  hashCode(Object[] array)

int  deepHashCode(Object[] array)

返回数组的流

Stream  stream(T[] array)

---

Arrays类

public class Arrays extends Object

Arrays 是JDK提供的操作数组的工具类，Arrays类提供了动态创建和访问 Java 数组的方法。

此类主要用于操作数组（比如排序和搜索）的各种方法。Arrays类还包含一个允许将数组作为列表来查看的静态工厂。

Arrays类官方文档

常用方法

1. 数组转列表：asList()
2. 排序：Arrays.sort()
3. 查找：Arrays.binarySearch()
4. 复制：Arrays.copyOf(),Arrays.copyOfRange()
5. 比较：Arrays.equals()
6. 填充：Arrays.fill()
7. 转字符串:Arrays.toString()

数组转列表asList

List<T>  asList(T... a)

返回由指定数组支持的一个固定大小的列表。该方法作为数组和饥饿和之间的桥梁，结合Collection.toArray()。

该方法返回的是 Arrays 内部静态类 ArrayList，而不是我们平常使用的 ArrayList,，该静态类 ArrayList 没有覆盖父类的 add(), remove() 等方法，所以如果直接调用，会报 UnsupportedOperationException 异常。

 //asList:将数组转化成List集合，参数是T泛型，可以存放任意的Java数据类型
        List<Integer> integers = Arrays.asList(1,2,3);
        for (Integer e : integers){
            System.out.println(e);
        }
        List<Character> longs = Arrays.asList('1','2','3');
        for (Character c : longs){
            System.out.println(c);
        }
        
        Integer[] data = {1,2,3,4};
        List<Integer> list = Arrays.asList(data);
        list.forEach(System.out::println);

        int[] data2 = {1,2,3,4};
        //基本数据类型的数组作为参数传入
        List<int[]> list1 = Arrays.asList(data2);
        System.out.println(list1.size());
        System.out.println(Arrays.toString(list1.get(0)));

 数组进行内部排序sort

void sort(Object[] array)

对数组元素从大到小进行排序

    //参数可以是byte[],char[],int[],double[],float[],long[],short[]
        int[] numbers = new int[]{1,3,5,2,4};
        Arrays.sort(numbers);
        for (int n : numbers){
            System.out.println(n);
        }

void sort(T[] array, Comparator<? super T> comparator)

使用自定义比较器，对数组元素进行排序

自定义对象数组，需要给出比较器才能进行排序操作。

class Person{
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ArraysTest {
    public  static void main(String[] args) {
        //使用自定义比较器
        Person[]  persons = new Person[3];
        persons[0] =new Person("张三",10);
        persons[1] = new Person("李四",20);
        persons[2] = new  Person("王五",15);
        Arrays.sort(persons, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                 //按照年龄从小到大进行排序
                return o1.age-o2.age;
            }
        });
        for (Person person:persons){
            System.out.println(person);
        }
    }
}

void sort(Object[] array, int fromIndex, int toIndex)

对指定范围内的数组元素进行排序

前开后闭：[fromIndex，toIndex）

//对指定范围内的元素进行排序
    Character[] characters = {'1','8','5','2','6'};
 //对下标[0,3)的元素进行排序
    Arrays.sort(characters,0,3);
    System.out.println(Arrays.toString(characters));

void sort(T[] array, int fromIndex, int toIndex, Comparator<? super T> c)

使用自定义比较器，对指定范围内的数组元素进行排序

在上面使用自定义比较器的基础上，在参数上加上指定的范围，对指定下标的元素进行排序。

 void parallelSort(T[] array)

对数组进行排序（并行排序），当数据规模比较大时，会有更好的性能。

使用二分法查找指定元素binarySearch

int binarySearch(Object[ ] a,Object key)

使用二分法查找数组内指定元素的索引值

在调用该方法之前，必须先调用Arrays.sort()方法进行排序，如果数组没有排序，结果是不确定的。

  Integer[]  integers1 = {1,3,5,7};
  Arrays.sort(integers1);
  System.out.println(Arrays.binarySearch(integers1,1));//0
  // 此时程序会把数组看作 {1, 3, 5, 7， 9}，此时9的索引值为4，则搜索8时返回 -(4 + 1) = -5
  System.out.println(Arrays.binarySearch(integers1,10));//-5
  // 此时程序会把数组看作 {1, 2, 3, 5, 7}，此时2的索引值为1，则搜索2时返回 -(1 + 1) = -2
  System.out.println(Arrays.binarySearch(integers1,2));//-2

当搜索元素是数组元素时，返回该元素的索引值

当搜索元素不是数组元素时，返回  -（索引值+1）

 根据binarySearch源码：

int  binarySearch(Object[] array, int fromIndex, int toIndex, Object obj)

使用二分法查找指定范围内的指定元素的索引值

Integer[] arr = {1,5,3,7,9};
Arrays.sort(arr);
System.out.println(Arrays.binarySearch(arr,0,3,9));//-4
//1,3,5,7,9
//[0,3)
System.out.println(Arrays.binarySearch(arr,0,3,5));//2

数组拷贝copyOf

T[] copyOf(T[] original ,int newLength)

拷贝数组，拷贝的长度为newLength。

 

内部调用了System.arraycopy()方法，从下标0开始，如果超过原数组长度，就用null进行填充。

T[] copyOfRange(T[] original ,int form,int to)

将指定的数组指定的范围复制到一个新的数组中。

 //数组拷贝
  Integer[] arr1 = {1,2,3,4,5};
  Integer[] arr2 = Arrays.copyOf(arr1,6);
  Integer[] arr3 = Arrays.copyOf(arr1,3);
  System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4, 5, null]
  System.out.println(Arrays.toString(arr3));//[1, 2, 3]

//将指定的数组指定的范围复制到一个新的数组中。
//[0,3)
 Integer[] arr4 = Arrays.copyOfRange(arr1,0,3);
 System.out.println(Arrays.toString(arr4));//[1,2,3]

数组比较equals

boolean equals(Object[] a1,Object[] a2)

判断两个数组是否相等

如果数组元素为基本数据类型，直接比较

如果数组元素为引用数据类型，调用元素的equals逐一进行比较

 如果比较的是两个自定义对象数组，对于自定义的对象要复写自身的equals方法

 //判断数组是否相等
        Integer[] array1 = {1,2,3};
        Integer[] array2 = {1,2,3};
        System.out.println(Arrays.equals(array1,array2));

填充fill

 void  fill(Object[] array, Object obj)

用指定元素填充整个数组（会替换掉数组中原来的元素），相当于初始化操作

String[] words = new String[]{"hello","world"};
Arrays.fill(words,"hi");
for (String s:words){
     System.out.println(s);
 }

void fill(Object[] array, int fromIndex, int toIndex, Object obj)

将数组的指定位置元素用指定元素替换,替换数组的部分的元素（相当于部分初始化操作）

//[1,2)
String[] string = new String[]{"I","am","a","student"};
Arrays.fill(string,1,2,"not");
for (String s :string){
     System.out.println(s);
}

转字符串toString

String  toString(Object[] array)

返回数组元素的字符串形式，将数组进行输出操作

int[]  array = new int[]{1,3,4,6,2,5};
Arrays.sort(array);
System.out.println(Arrays.toString(array));

 String deepToString(Object[] array)

返回多维数组元素的字符串形式

Integer[][] arr= {{1, 2, 3，4}, {1, 2, 3，5}};
System.out.println(Arrays.deepToString(arr)); 

返回哈希值

int  hashCode(Object[] array)

返回数组的哈希值

int[] array3 = new int[]{1,2,3,4};
System.out.println(Arrays.hashCode(array));

int  deepHashCode(Object[] array)

返回多维数组的哈希值

Integer[][] data = {{1, 2, 3}, {1, 2, 3}};
System.out.println(Arrays.deepHashCode(data)); // 987105

返回数组的流

Stream<T>  stream(T[] array)

返回指定数组对应的流（源序列）Stream

Integer[] integers2 = {1,2,3,4};
List<Integer> list2 = Arrays.stream(integers2).collect(Collectors.toList());
System.out.println(list2);