java实现数据结构01(数组详解代码之自定义数组)

自定义数组类

/**
 * @description: 数组类,E为泛型，可以使用任意对象
 * @author: liangrui
 * @create: 2019-12-05 20:25
 **/
public class Array<E> {

    //数据
    private E[] data;
    //实际数据个数
    private int size;

    /**
     * 有参构造函数
     * @param capacity 数据容量
     */
    public Array(int capacity){
        data=(E[]) new Object[capacity];
        size=0;
    }

    /**
     * 无参构造函数，this(10)代表调用有参构造函数，赋予容量10
     */
    public Array(){
        this(10);
    }

    /**
     * 重新设置数组容量，使数组具有可伸缩性
     * @param newCapacity 设置的容量大小
     */
    private void resetCapacity(int newCapacity){
        E[] newData=(E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i]=data[i];
        }
        data=newData;
    }

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

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

    /**
     * @return 判断数组是否为空，为空返回true，不为空返回false
     */
    public boolean isEmpty(){
        return size==0;
    }

    /**
     * 指定数组位置添加数据
     * @param index 数组下标
     * @param e 添加的数据
     */
    public void add(int index,E e){

        //如果插入的位置下标小于0或者大于数组元素的数量，即不合法。抛出异常。
        if (index<0||index>size){
            throw new IllegalArgumentException("Add failed. Require index>=0 and index<=size.");
        }

        //如果数组元素等于数组容量，即数组已满,可以扩容2倍
        if(size==data.length){
            resetCapacity(2*data.length);
        }

        //从最后一个元素遍历到存储的下标，逐个把前一个的元素赋值到后一个，从而保证元素不丢失，且把要添加的index位置空出来
        for (int i = size-1; i >=index ; i--) {
            data[i+1]=data[i];
        }

        //把e赋值到index所在的数组位置
        data[index]=e;
        //元素数量+1。
        size++;
    }

    /**
     * 从最后面添加数据
     * @param e 添加的数据
     */
    public void addLast(E e){
        add(size,e);
    }

    /**
     * 在数组最前面添加数据
     * @param e 添加的数据
     */
    public void addFirst(E e){
        add(0,e);
    }

    /**
     * 查询数组信息
     * @return 返回数组信息
     */
    @Override
    public String toString(){
        //创建StringBuilder对象，实现字符串拼接
        StringBuilder sb=new StringBuilder();
        //第一行为数组的元素个数和数组的容量
        sb.append(String.format("Array Size:%d. Array Capacity:%d.\n",size,data.length));
        //第二行为数组的数据
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            //如果不是最后一个元素，拼接","
            if (i!=size-1){
                sb.append(",");
            }
        }
        sb.append("]");
        //返回字符串
        return sb.toString();
    }

    /**
     * 获取指定下标的数据
     * @param index 下标
     * @return 返回对应数组中的数据
     */
    public E get(int index){
        //非法索引
        if (index<0||index>=size){
            System.out.println(index);
            throw new IllegalArgumentException("Get failed. Index is Illegal.");
        }
        return data[index];
    }

    /**
     * 修改指定下标的数据
     * @param index 下标
     * @param e 修改后的数据
     */
    public void set(int index,E e){
        //非法索引
        if (index<0||index>=size){
            throw new IllegalArgumentException("Set failed. Index is Illegal.");
        }
        data[index]=e;
    }

    /**
     * 查询数组中是否包含某元素
     * @param e 查询的元素
     * @return 存在返回true,不存在返回false
     */
    public boolean contains(E e){
        for (int i = 0; i < size; i++) {
            //包含
            if (data[i].equals(e)){
                return true;
            }
        }
        //遍历结束，不包含
        return false;
    }

    /**
     * 查询某元素的索引
     * @param e 查询的元素
     * @return 返回元素索引，元素不存在返回-1
     */
    public int findIndex(E e){
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)){
                return i;
            }
        }
        return -1;
    }

    /**
     * 查询所有相同元素的索引
     * @param e 元素
     */
    public void findAllIndex(E e){
        StringBuilder sb=new StringBuilder();
        sb.append("AllIndex:");
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)){
                sb.append(i+" ");
            }
        }
        System.out.println(sb.toString());
    }

    /**
     * 删除指定索引的元素
     * @param index 索引
     */
    public E removeByIndex(int index){
        //非法索引
        if (index<0||index>=size){
            throw new IllegalArgumentException("Remove failed. Require index>=0 and index<size.");
        }
        E removeElement=data[index];
        //依次将(i+1)的元素赋值到i
        for (int i = index; i < size-1; i++) {
            data[i]=data[i+1];
        }
        //元素个数-1
        size--;
        //设置为null,程序优化
        data[size]=null;

        //当元素个数小于容量的1/4，则减少容量为原来的1/2，且数组容量要大于1
        if (size<data.length/4&&data.length/2!=0){
            resetCapacity(data.length/2);
        }
        return removeElement;
    }

    /**
     * 删除第一个元素
     */
    public E removeFirst(){
        return removeByIndex(0);
    }

    /**
     * 删除最后一个元素
     */
    public E removeLast(){
        return removeByIndex(size-1);
    }

    /**
     * 删除指定元素
     * @param e 指定的元素
     */
    public E removeElement(E e){
        int index=findIndex(e);
        if (index==-1){
            throw new IllegalArgumentException("Remove failed.The element is nonexistent.");
        }else {
            return removeByIndex(index);
        }
    }

    /**
     * 删除所有相同的元素e
     * @param e 要删除的元素
     */
    public void removeAllElement(E e){
        int index=findIndex(e);
        if (index==-1){
            System.out.println("Remove failed.The element is nonexistent.");
        }else {
            for (int i = 0; i < size; i++) {
                if (data[i].equals(e)){
                    removeByIndex(i);
                }
            }
        }
    }
}

main测试：

public class Main {

    public static void main(String[] args) {
        Array<Integer> array=new Array(10);
        for (int i = 0; i <10 ; i++) {
            array.addLast(i);
        }
        //Array Size:10. Array Capacity:20.
        //[0,1,2,3,4,5,6,7,8,9]
        System.out.println(array);

        array.add(1,100);
        //Array Size:11. Array Capacity:20.
        //[0,100,1,2,3,4,5,6,7,8,9]
        System.out.println(array);

        array.addFirst(-1);
        //Array Size:12. Array Capacity:20.
        //[-1,0,100,1,2,3,4,5,6,7,8,9]
        System.out.println(array);

        //0
        System.out.println(array.get(1));

        array.set(11,9999);
        //Array Size:12. Array Capacity:20.
        //[-1,0,100,1,2,3,4,5,6,7,8,9999]
        System.out.println(array);

        //Remove success. Removed element:4,Removed index:6
        array.removeElement(4);
        /*
        Array Size:11. Array Capacity:20.
        [-1,0,100,1,2,3,5,6,7,8,9999]
         */
        System.out.println(array);
    }
}

测试结果：

Array Size:10. Array Capacity:10.
[0,1,2,3,4,5,6,7,8,9]
Array Size:11. Array Capacity:20.
[0,100,1,2,3,4,5,6,7,8,9]
Array Size:12. Array Capacity:20.
[-1,0,100,1,2,3,4,5,6,7,8,9]
0
Array Size:12. Array Capacity:20.
[-1,0,100,1,2,3,4,5,6,7,8,9999]
Array Size:11. Array Capacity:20.
[-1,0,100,1,2,3,5,6,7,8,9999]