用顺序存储(数组)方式来实现列表

 

1.添加方法要扩容，数组是没有扩容机制的。

2.删除方法要重新排元素，将后面的元素向前推。

 

 

package demo1;
/**
 * 线性表(列表)的接口
 * @author DeepSleeping
 *
 */
public interface MyList {

    /*新增一个元素*/
    void add(Object element);
    /*删除相同元素*/
    void delete(Object element);
    /*根据索引删除元素*/
    void delete(int index);
    /*将指定索引位置的元素替换成新元素*/
    void update(int index,Object newElement);
    /*当前列表中是否含有target这个元素*/
    boolean contains(Object target);
    /*返回指定索引处的元素*/
    Object at(int index);
    /*查找element的索引,如果没有返回-1*/
    int indexOf(Object element);
    
}

package demo1;

/**
 * 用顺序存储(数组)方式来实现列表
 * 
 * @author DeepSleeping
 *
 */
public class MyArrayList implements MyList {

    private Object[] elements;// 真正存储元素的底层结构
    private int size = 0;// 元素的个数
    private int capacity = 10;// 容量

    public MyArrayList(int capacity) {
        this.capacity = capacity;
        elements = new Object[capacity];
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < size; i++) {
            sb.append(elements[i] + (i == size - 1 ? "" : ","));
        }
        sb.append("]");
        return sb.toString();
    }

    public MyArrayList() {
        elements = new Object[capacity];
    }

    /**
     * 新增一个元素
     * @param element
     */
    @Override
    public void add(Object element) {
        if (size == capacity) { // 扩容
            capacity *= 2; // 增加一倍的容量
            Object[] newArr = new Object[capacity];// 新建一个数组
            for (int i = 0; i < size; i++) {
                newArr[i] = elements[i];
            }
            elements = newArr; // 把旧的那个柜子扔掉
        }
        elements[size++] = element;
    }

    /**
     * 删除相同元素
     * @param element
     */
    @Override
    public void delete(Object element) {
        int index = indexOf(element);
        if (index >= 0) {
            delete(index);
        }
    }

    /**
     * 根据索引删除元素
     * @param index
     */
    @Override
    public void delete(int index) {
        // 前移[紧缩]
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i + 1];
        }
        elements[size - 1] = null;
        size -= 1;
    }

    /**
     * 将指定索引位置的元素替换成新元素
     * @param index
     * @param newElement
     */
    @Override
    public void update(int index, Object newElement) {
        elements[index] = newElement;
    }

    /**
     * 当前列表中是否含有target这个元素
     * @param target
     * @return
     */
    @Override
    public boolean contains(Object target) {

        return indexOf(target) >= 0;
    }

    /**
     * 返回指定索引处的元素
     * @param index
     * @return
     */
    @Override
    public Object at(int index) {

        return elements[index];
    }

    /**
     * 查找element的索引,如果没有返回-1 
     * @param element
     * @return
     */
    @Override
    public int indexOf(Object element) {
        for (int i = 0; i < size; i++) {
            if (elements[i].equals(element)) {
                return i;
            }
        }
        return -1;
    }

}

 

转载于:https://www.cnblogs.com/deepSleeping/p/10260384.html