二次封装数组

接口实现

add

在数组的末尾添加一个元素：void addLast(E e)

在数组的第一个位置添加一个元素：addFirst(E e)

在指定位置添加一个元素：add(int index, E e)

delete

从数组中删除index位置的元素, 返回删除的元素：E remove(int index)

从数组中删除第一个元素, 返回删除的元素：E removeFirst()

从数组中删除最后一个元素, 返回删除的元素： E removeLast()

从数组中删除单个元素e,删除成功则返回true,否则返回false：boolean removeElement(E e)

从数组中批量删除元素e,删除成功则返回true,否则返回false：boolean removeAllElement(E e)

删除所有重复元素

update

修改index索引位置的元素为e：void set(int index,E e)

get

获取数组中元素的个数：int getSize()

获取数组的容量：int getCapacity()

查找数组中是否有元素e：boolean contains(E e)

查找数组中元素e所在的索引, 如果不存在元素e, 则返回-1：int find(E e)

查找数组中所有元素e所在的索引, 如果不存在元素e, 则返回一个空的数组：int[] findAll(E e)

verification

验证数组是否为空：boolean isEmpty()

other

扩容/压缩数组：void resize(int newCapacity)

源码

gitee：https://gitee.com/xianxian86/post-packaging_array

/** * @Version 1.0 * @Author: 小贤 * @Date:2021/2/16 * @Content: 二次封装数组 */
public class Array<E> {
   

    private E[] data; //数组

    private int size; //元素个数

    /** * 构造数组,默认容量为10 */
    public Array(){
   
        this(10);
    }

    /** * 传入数组的capacity(容量),构造数组 * @param capacity */
    public Array(int capacity){
   
        data = (E[])new Object[capacity];
        size = 0; //指定元素的个数为0
    }

    /** * 获取数组中元素的个数 * @return */
    public int getSize(){
   
        return size;
    }

    /** * 获取数组的容量 * @return */
    public int getCapacity(){
   
        return data.length;
    }

    /** * 在数组的末尾添加一个元素 * @param e */
    public void addLast(E e){
   
        add(size,e);
    }

    /** * 在数组的第一个位置添加一个元素 * @param e */
    public void addFirst(E e){
   
        add(0,e);
    }

    /** * 在指定位置添加一个元素 * @param index * @param e */
    public void add(int index, E e){
   
        if(index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Array is full");
        if(size == data.length){
   
            resize(2 * data.length);
        }

        for(int i = size -1 ; i >= index; i--)
            data[i+1] = data[i]; // 移动元素的位置

        data[index] = e; // 赋值
        size ++; // 元素个数+1
    }

    /** * 返回数组是否为空 */
    public boolean isEmpty(){
   
        return size == 0;
    }

    /** * 获取index索引位置的元素 * @param index * @return */
    public E get(int index){
   
        if(index < 0 || index >= size){
   
            throw new IllegalArgumentException("Get failed. Index is full");
        }
        return data[index];
    }

    /** * 修改index索引位置的元素为e * @param index * @param e */
    public void set(int index,E e){
   
        data[index] = e;
    }

    /** * 查找数组中是否有元素e * @param e * @return */
    public boolean contains(E e){
   
        for(int i = 0 ; i < size ; i++){
   
            if(data[i].equals(e))
                return true;
        }
        return false;
    }

    /** * 查找数组中元素e所在的索引, 如果不存在元素e, 则返回-1 * @param e * @return */
    public int find(E e){
   
        for (int i = 0 ; i < size ; i++){
   
            if(data[i].equals(e)){
   
                return i;
            }
        }
        return -1;
    }

    /** * 查找数组中所有元素e所在的索引, 如果不存在元素e, 则返回一个空的数组 * @param e * @return */

    //查找数组中所有元素e所在的索引, 如果不存在元素e, 则返回一个空的数组
    public int[] findAll(E e){
   
        StringBuilder index = new StringBuilder();
        for (int i = 0 ; i < size ; i++){
   
            if (data[i].equals(e)) {
   
                index.append(i);
                if (i != size-1){
   
                    index.append(",");
                }
            }
        }
        if(index.length() == 0){
   
            return new int[0];
        }
        String[] splitIndex = index.toString().split(",");
        int[] resultIndex = new int[splitIndex.length];
        for (int i = 0; i < splitIndex.length; i++) {
   
            resultIndex[i] = Integer.parseInt(splitIndex[i]);
        }
        return resultIndex;
    }


    /** * 从数组中删除index位置的元素, 返回删除的元素 * @param index * @return */
    public E remove(int index){
   
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed. Index is illegal");
        E ret = data[index];
        for(int i = index+1 ; i<size ; i++)
            data[i-1] = data[i];
        size--;
        data[size] = null;
        if(size == data.length / 4 && data.length / 2 != 0)
            resize(data.length / 2);
        return ret;
    }

    /** * 从数组中删除第一个元素, 返回删除的元素 * @return */
    public E removeFirst(){
   
        return remove(0);
    }

    /** * 从数组中删除最后一个元素, 返回删除的元素 * @return */
    public E removeLast(){
   
        return remove(size - 1);
    }

    /** * 从数组中删除单个元素e,删除成功则返回true,否则返回false * @param e * @return */
    public boolean removeElement(E e){
   
        int index = find(e);
        if(index != -1){
   
            remove(index);
            return true;
        }
        return false;
    }

    /** * 从数组中批量删除元素e,删除成功则返回true,否则返回false * @param e * @return */
    public boolean removeAllElement(E e){
   
        int index = find(e);
        boolean flag = true;
        while(index != -1){
   
            flag = false;
            remove(index);
            index = find(e);
        }
        if (!flag) {
   
            return true;
        }
        return false;
    }

    @Override
    public String toString(){
   
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
        res.append('[');
        for(int i = 0 ; i < size ; i ++){
   
            res.append(data[i]);
            if(i != size - 1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }

    /** * 扩容/压缩数组 * @param newCapacity */
    private void resize(int newCapacity){
   
        E[] newData = (E[]) new Object[newCapacity];
        for(int i = 0 ; i < size ; i++){
   
            newData[i] = data[i];
        }
        data = newData;
    }
}

代码需要修改的地方还有很多，希望大家能够给我一些建议！