顺序表--Java版

interface Sequence

package 顺序表;

public interface Sequence {
    void add(Object data);
    boolean remove(int index);
    Object set(int index,Object newData);
    Object get(int index);
    boolean contains(Object data);//判断线性表中是否含有指定元素
    int size();
    Object[] toArray();//将线性表转为数组
    void clear();//直接清空线性表内容
}

class SequenceArrayImpl

package 顺序表;

import java.util.Arrays;

/**
 * 基于数组实现的线性表，可以扩容
 */

public class SequenceArrayImpl implements Sequence{
    private static final int DEFAULT_CAPACITY = 2;//默认容量
    private int size;//存放的元素个数
    private Object[] elementData;//真正存放元素的对象数组
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//线性表是有限序列，所以规定它的最大容量


    public SequenceArrayImpl() {//初始化存储元素数组，默认初始化为10
        this.elementData = new Object[DEFAULT_CAPACITY];
    }

    /**
     * 首先判断添加元素是否会导致数组越界，若越界则先进行扩容后存储元素
     * @param data ：要添加的元素
     */
    @Override
    public void add(Object data) {
        ensureCapacity(size+1);
        elementData[size++] = data;
    }

    /**
     * 删除某索引的元素
     * @param index
     * @return 成功删除返回true，否则返回false
     */
    @Override
    public boolean remove(int index) {
        rangCheck(index);
        int moveSteps = size - index - 1;//移动的步数
        if(moveSteps > 0){
            System.arraycopy(elementData,index+1,elementData,index,moveSteps);
        }
        //数组最后一个元素
        elementData[--size] = null;
        return  true;
    }

    /**
     * 修改某索引下的元素为新元素,并返回原来的元素内容
     * @param index ：索引
     * @param newData ：新元素
     * @return
     */
    @Override
    public Object set(int index, Object newData) {
        rangCheck(index);
        Object oldData = elementData[index];//取得修改前的内容
        elementData[index] = newData;
        return oldData;
    }

    /**
     * 根据索引获取指定元素
     * @param index ：索引
     * @return
     */
    @Override
    public Object get(int index) {
        rangCheck(index);
        return elementData[index];
    }

    /**
     * 判断线性表中是否含有指定内容的元素
     * @param data ：要查询的元素内容
     * @return
     */
    @Override
    public boolean contains(Object data) {
        //首先查看元素为空的情况
        if(data == null){
            for (int i = 0; i < size; i++) {
                if(elementData[i] == null){
                    return true;
                }
            }
        }else {
            //不是空的话就可以根据equals方法来判断
            for (int i = 0; i < size; i++) {
                /**
                 * 在这里，还会写成elementData[i].equals(data)，这时就会出现空指针异常。
                 * 切记判断你的输入是否是指定字符串时，一定要把特定字符串写前面。
                 */
                if(data.equals(elementData[i])){
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public int size() {
        return this.size;
}

    @Override
    public Object[] toArray() {
        return this.elementData;
    }

    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            elementData[i] = null;
        }
        this.size = 0;
    }

    /**
     * 判断数组是否越界
     * @param minCap :添加元素后的元素个数
     */
    private void ensureCapacity(int minCap){
        if(minCap - elementData.length > 0){
            //扩容策略
            grow(minCap);
        }
    }

    /**
     * 数组扩容
     * @param minCap :添加元素后的元素个数
     */
    private void grow(int minCap){
        int oldCap = elementData.length;//原来数组的大小
        int newCap = oldCap << 1;//扩容两倍
        if(newCap - minCap < 0){
            newCap = minCap;
        }
        if(newCap - MAX_ARRAY_SIZE > 0){
            throw new ArrayIndexOutOfBoundsException("超过数组最大阈值");
        }
        //数组扩容
        elementData = Arrays.copyOf(elementData,newCap);
    }

    /**
     * 判断索引是否合法
     * @param index :索引
     */
    private void rangCheck(int index){
        if(index <0 || index >=size){
            throw new IndexOutOfBoundsException("索引越界");
        }
    }
}

class Test

package 顺序表;

public class Test {
    public static void main(String[] args) {
        SequenceArrayImpl sequenceArray = new SequenceArrayImpl();
        sequenceArray.add(1);
        sequenceArray.add(2);
        sequenceArray.add(3);
        System.out.println(sequenceArray.get(2));
        System.out.println(sequenceArray.set(1,20));
        System.out.println(sequenceArray.get(1));
        //System.out.println(sequenceArray.get(10));//检测越界情况
        System.out.println(sequenceArray.remove(0));
        System.out.println(sequenceArray.get(0));
        System.out.println(sequenceArray.contains(20));
    }
}