Arrays类的常用方法

文章目录

1. 简介

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

2. 常用方法

2.1 asList()方法

static List asList(T… a)：返回一个受指定数组支持的固定大小的列表。

		List<Integer> list = Arrays.asList(1, 2, 3, 4);
		//list.add(3);//添加元素
        System.out.println(list.toString());
        //打印数组[1, 2, 3, 4]

但是大家如果使用list来添加元素就会发现报错，抛出UnsupportedOperationException异常。

为什么会这样呢，我们通过源码分析，原来Arrays在内部声明了一个内部类ArrayList。没有add()方法。导致添加元素报错。

 public static <T> List<T> asList(T... a) {
       // 1.创建一个ArrayList 此ArrayList是一个静态内部类,并非是一个集合
        return new ArrayList<>(a);
    }
 private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
{
        private static final long serialVersionUID = -2764017481108945198L;
        // 2.定义一个常量数组命名为 a(常量是不可改变的,所以如果赋值为这个常量就不可以进行crud操作)
        private final E[] a;
		 
        ArrayList(E[] array) {
        // 3.如果传递进来的数组是null 直接抛出异常,
        //否则把传递进来的数组赋值给定义的常量数组a
            a = Objects.requireNonNull(array);
        }
        public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

        //数组的长度
        public int size() {
            return a.length;
        }

        //克隆数组，返回原来的副本
        public Object[] toArray() {
            return a.clone();
        }

     // 方法重载,最终也是返回一个数组.里面这个a是克隆后的
        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
            //复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。     
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。                    
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

       //获取指定index的元素
        public E get(int index) {
            return a[index];
        }

        //修改指定index的元素
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        //返回指定元素的索引
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

       //是否包含元素
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }
      //按照自定义方式遍历元素
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }
        按照自定义方式遍历替换元素
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }
		//按照传入的Comparator排序
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

总结：
由源码中看到因为声明了一个内部final E[] a;常量是不可改变的,所以如果赋值为这个常量就不可以进行crud操作)。但是如果非要往集合添加元素怎么办呢，可以使用Collect接口的addAll()重写生成一个集合。

		List<Integer> list = Arrays.asList(1, 2, 3, 4);
        List<Integer> newlList =new ArrayList<>();//声明一个新的集合
        newlList.addAll(list);
        newlList.add(3);//添加元素
        System.out.println(newlList.toString());
        //打印数组[1, 2, 3, 4, 3]

2.2 binarySearch()方法

static int binarySearch(int[] a, int key)：使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。

Arrays中对binarySearch()实现了很多重载方法，有需要的自己看下，就不一一举例了。不过需要注意的是数组一定是排好序的，否则会出错。找到匹配的第一个元素，就返回其索引。
代码示例：

   //初始化一个排好序的数组
        int[] arr={1,3,5,5,7,9};
        //使用二分法查找
        int i = Arrays.binarySearch(arr, 5);
        System.out.println(i);// 输出: 2  第一个找到的索引

大家可能有点疑问，为何不使用循环遍历，非要用二分法查找呢，而且还需要排好序的数组，不排好序的数组还不能用，那不是吃力不讨好嘛。其实一般情况下循环变量就可以了，但是如果涉及到几百万条上一条数据那时间复杂度就是O(n)，但是使用了二分法O(logN)。所以数据越多，越能看出效率。

 public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }
     private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

从源码可以看到，我们对一个数组每次取中间位置去匹配要找的值，如果大了就从右边找，小了就从左边找（这个取决是升序还是降序），找到了就返回索引，找不到就返回-1。直到循环条件结束。

2.3 copyOfRange()方法

static int[] copyOfRange(int[] original, int from, int to)： 将指定数组的指定范围复制到一个新数组。

其实数组的复制底层都是调用System.arraycopy()方法，所以我们接下来主要看下其源码，直到其方法使用。

 //初始化一个排好序的数组
        int[] arr={1,3,5,5,7,9};
        /**
         * original - 将要从其复制一个范围的数组
         * from - 要复制的范围的初始索引（包括）
         * to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
         */
        int[] copy = Arrays.copyOfRange(arr, 2, 4);
        printArr(copy);//输出结果 5 5

看下其源码

public static int[] copyOfRange(int[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        int[] copy = new int[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }
    /***
    src - 源数组。
	srcPos - 源数组中的起始位置。
	dest - 目标数组。
	destPos - 目标数据中的起始位置。
	length - 要复制的数组元素的数量。
    */
public static native void arraycopy(Object src, 
									int srcPos,
                       				Object dest, 
                       				int destPos,
                                    int length);

2.4 sort()方法

static void sort(int[] a):对指定的 int 型数组按数字升序进行排序。

代码示例：

		//初始化一个数组
        int[] arr={1,9,3,5,4,9};
        //使用sort()方法排序
        Arrays.sort(arr);
        printArr(arr);//输出结果 1	3	4	5	9	9