数组实现增删查改操作

package data.practice;

/**
 * 线性表规范
 * @author: yuisama
 * @date: 2019-02-28 19:46
 * @description:
 */
public interface bittech1 {



    /**
     * 向线性表中添加元素
     * @param data 要存储的元素
     */
    void add(Object data);

    /**
     * 线性表中删除元素
     * @param index 要删除的元素下标
     * @return 是否删除成功
     */
    boolean remove(int index);

    /**
     * 在线性表中查找指定索引的元素
     * @param index 要查找的索引
     * @return
     */
   Object get(int index);

    /**
     * 判断线性表中是否有指定元素
     * @param data 要查找的元素内容
     * @return
     */
    boolean contains(Object data);

    /**
     * 修改线性表中指定索引的内容
     * @param index 要修改的元素下标
     * @param newData 修改后的内容
     * @return
     */
    Object set(int index,Object newData);

    /**
     * 返回当前线性表元素个数
     * @return
     */
    int size();

    /**
     * 直接清空线性表内容
     */
    void clear();

    /**
     * 将线性表转为数组
     * @return
     */
    Object[] toArray();
}

package data.practice;

import java.util.Arrays;
public class bittench1ArrayImpl implements bittech1 {
//    存放元素的对象数组
    public Object[] elementData;
//    默认容量
    private  final  static int DEFAULT_CAPACITY=10;
//  存放的元素个数
    private  int size;
//    线性表的最大容量
    private final static int MAX_CAPACITY=Integer.MAX_VALUE-8;

    public bittench1ArrayImpl() {
        this.elementData = new Object[DEFAULT_CAPACITY];
//        初始化存储元素数组，初始化为10
    }
    public bittench1ArrayImpl(int capacity){
        if(capacity>0){
            this.elementData=new Object[capacity];
        }
    }

    @Override
    public void add(Object data) {
//        首先判断元素知否越界
//        如果越界先进扩容，而后存储元素
     ensureCapacityInternal(size+1);
     elementData[size++]=data;
    }

    @Override
    public boolean remove(int index) {
        rangeCheck(index);
        int moveSteps=size-index-1;
        if(moveSteps>0){
            System.arraycopy(elementData,index+1,elementData,index,moveSteps);
        }
        elementData[--size]=null;
        return true;
    }
    public Object get(int index) {
        rangeCheck(index);
        return elementData[index];
    }
    @Override
    public boolean contains(Object data) {
//        判断之前是否有指定内容
        if(data==null){
            for(int i=0;i<size;i++){
                if(elementData[i]==null){
                    return true;
                }
            }
        }else
            for(int i=0;i<size;i++){
            if(data.equals(elementData[i])){
                return true;
            }
        }
        return false;
    }
    @Override
    public Object set(int index, Object newData) {
        rangeCheck(index);
//        取得修改前的内容
        Object oldData=elementData[index];
        elementData[index]=newData;
        return oldData;
    }
    @Override
    public int size() {
        return this.size();
    }
    @Override
    public void clear() {
     for(int i=0;i<size;i++){
         elementData[i]=null;
     }
     this.size=0;
    }
    @Override
    public Object[] toArray() {

        return this.elementData;
    }
    private void ensureCapacityInternal(int cap){
        if(cap-elementData.length>0){
//            扩容
            grow(cap);
        }
    }
    private void grow(int cap){
        int oldCap=elementData.length;
        int newCap=oldCap<<1;
        if (cap-newCap>0){
            newCap=cap;
        }
        if(newCap-MAX_CAPACITY>0){
            throw new IndexOutOfBoundsException("线性表超出最大值");
        }
        elementData= Arrays.copyOf(elementData,newCap);
    }
    private void rangeCheck(int index){
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("索引非法");
        }
    }
}

package data.practice;

public class Test {
    public static void main(String[] args){
//        bittech1 bit=new bittech1LinkedImpl();
          bittech1 bit1=new bittench1ArrayImpl(2);
          bit1.add(1);
          bit1.add(2);
          bit1.add(3);
          bit1.add(4);
          System.out.println(bit1.get(2) );
          System.out.println(bit1.set(3,20));
          System.out.println(bit1.get(3));
          System.out.println(bit1.remove(3 ));
          System.out.println(bit1.get(3));
          
    }
}