• java.util.Arrays 数组工具类，提供了很多静态方法来对数组进行操作，而且如下的每一个方法都有重载，以下只列出 int[] 类型的，其他类型依次类推：

二分查找法：要求数组有序，在数组中查找 key 是否存在，如果存在返回第一次找到的下标，不存在返回负数

public static int binarySearch(int[] a, int key) {}

根据 original 原数组复制一个长度为 newLength 的新数组，并返回新数组：

public static int[] copyOf(int[] original, int newLength) {}

复制 original 原数组的 [from,to) 构成新数组，并返回新数组：

public static int[] copyOfRange(int[] original, int from, int to){}

比较两个数组的长度、元素是否完全相同：

public static boolean equals(int[] a, int[] a2) {}

用 val 填充整个 a 数组：

public static void fill(int[] a, int val) {}

将 a 数组 [fromIndex,toIndex) 部分填充为 val ：

public static void fill(int[] a, int fromIndex, int toIndex, int val){}

将 a 数组按照从小到大进行排序：

public static void sort(int[] a) {}

将 a 数组的 [fromIndex, toIndex) 部分按照升序排列：

public static void sort(int[] a, int fromIndex, int toIndex){}

把 a 数组的元素，拼接为一个字符串，形式为：[元素1，元素2，元素3。。。]

public static String toString(int[] a) {}

示例：

package com.github.array.demo13;
import java.util.Arrays;
import java.util.Random;
/**
 * @author maxiaoke.com
 * @version 1.0
 * 
 */
public class Test {
    public static void main(String[] args) {
        int[] arr = new int[5];
        // 打印数组，输出地址值
        System.out.println(arr); // [I@1540e19d
        // 数组内容转换为字符串
        System.out.println("arr数组的初始状态：" + Arrays.toString(arr)); // [0, 0, 0, 0, 0]
        // 向数组中填充数据
        Arrays.fill(arr, 3);
        System.out.println("arr数组的现在状态：" + Arrays.toString(arr)); // [3, 3, 3, 3, 3]
        // 向数组中赋值100以内的随机数
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(100);
        }
        System.out.println("arr数组的现在状态：" + Arrays.toString(arr)); // [3, 19, 72, 81, 66]
        // 根据original原数组复制一个长度为newLength的新数组，并返回新数组
        int[] arr2 = Arrays.copyOf(arr, 10);
        System.out.println("新数组：" + Arrays.toString(arr2)); // [93, 62, 31, 90, 88, 0, 0, 0, 0, 0]
        // 两个数组比较
        System.out.println(Arrays.equals(arr, arr2)); // false
        // 数组排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // [17, 23, 32, 57, 98]
    }
}

示例：使用数组工具类实现动态数组

package com.github.array;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Iterator;
/**
 * 动态数组
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class MyArrayList<E> implements Iterable<E> {
    /**
     * 底层存储的数据的容器
     */
    private Object[] all = new Object[5];
    /**
     * 记录实际存储元素的个数
     */
    private int total;
    /**
     * 插入元素
     *
     * @param e
     * @return
     */
    public boolean add(E e) {
        // 判断是否要扩容
        if (total >= all.length) {
            all = Arrays.copyOf(all, all.length + (all.length >> 1));
        }
        all[total++] = e;
        return true;
    }
    /**
     * 插入指定位置的元素
     *
     * @param index
     * @param e
     * @return
     */
    public boolean add(int index, E e) {
        // 校验 index ,合理的范围是 [0,total]
        if (index < 0 || index > total) {
            throw new IndexOutOfBoundsException(index + "越界" + "，合理的范围是 [0," + total + "]");
        }
        // 判断是否要扩容
        if (total >= all.length) {
            all = Arrays.copyOf(all, all.length + (all.length >> 1));
        }
        System.arraycopy(all, index, all, index + 1, total - index);
        all[index] = e;
        total++;
        return true;
    }
    /**
     * 删除某个位置上的元素：元素前移，最后一个元素位置[total-1]设置为 null
     *
     * @param index
     * @return
     */
    public boolean remove(int index) {
        // 校验 index ,合理的范围是 [0,total-1]
        if (index < 0 || index >= total) {
            throw new IndexOutOfBoundsException(index + "越界" + "，合理的范围是 [0," + (total - 1) + "]");
        }
        System.arraycopy(all, index + 1, all, index, total - index - 1);
        all[total - 1] = null;
        total--;
        return true;
    }
    @Test
    public void test() {
        MyArrayList<String> list = new MyArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");
        for (String s : list) {
            System.out.println("s = " + s);
        }
        list.remove(1);
        for (String s : list) {
            System.out.println("s = " + s);
        }
    }
    @Override
    public Iterator<E> iterator() {
        return new Intr<>();
    }
    private class Intr<E> implements Iterator<E> {
        private int cursor; // 默认指向第一个元素
        @Override
        public boolean hasNext() {
            return cursor < total;
        }
        @Override
        public E next() {
            return (E) all[cursor++];
        }
    }
}