5.2 数组工具类-Java语言基础9-常用API和常见算法

当前位置:　首页>> 技术小册>> Java语言基础9-常用API和常见算法

-  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++];
        }
    }
}
```

该分类下的相关小册推荐：

Java语言基础5-面向对象初级

深入拆解 Java 虚拟机

SpringBoot合辑-高级篇

Mybatis合辑5-注解、扩展、SQL构建

Java语言基础2-运算符

JAVA 函数式编程入门与实践

Java语言基础8-Java多线程

Java语言基础7-Java中的异常

Java语言基础12-网络编程

Java语言基础10-Java中的集合

Java必知必会-Maven高级

SpringBoot合辑-初级篇