数据结构—线性表

线性表的定义
零个或多个数据元素的有序数列

线性表的主要功能：

//泛型E：该List线性表中传入的具体数据类型由外界决定
public interface List<E>extends Iterable <E>{
    public abstract int getSize();  //获取表中有效元素的个数
    boolean isEmpty();   //判空
    void add(int index ,E e);   //指定角标处插入元素e
    void addFirst(E e);   //头插
    void addLast(E e);    //尾插
    E get(int index);    //获取指定位置元素
    E getFirst();   //获取头部元素
    E getLast();    //获取尾部元素
    void set(int index, E e);   //修改指定位置元素
    boolean contains(E e);   //判断是否含有e
    int find(E e);   //查找e的角标
    E remove(int index);   //删除指定位置元素l
    E removeFirst();       //删除首元素
    E removeLast();         //删除尾元素
    void removeElement(E e);      //删除指定元素
    void clear();    //清空列表
}

功能的具体实现：

import java.util.Iterator;

public class ArrayList<E> implements List<E> {
    private E[] data;   //创建E类型的一维数组
    private int Size;
    private static int DEAFULT_CAPACITY=10;

    public ArrayList(){
        data=(E[])new Object[DEAFULT_CAPACITY];
    }    //无参构造函数
    public ArrayList(int capacity){             //有参构造函数
        if(capacity<0){
            throw new IllegalArgumentException("容量不为负数");
        }
        data=(E[])new Object[capacity];
    }
    public ArrayList(E[] date){    //有参构造函数
        if(data==null){
            throw new IllegalArgumentException("数组不可为空");
        }
        this.data=(E[])new Object[date.length];
        for (int i=0;i<date.length;i++) {
            this.data[i]=date[i];;
        }
        Size=data.length-1;
    }
    @Override
    public int getSize() {
        return Size;
    }

    @Override
    public boolean isEmpty() {
        return Size==0;
    }

    @Override
    public void add(int index, E e) {     //指定角标插入元素
        if(index<0||index>Size){
            throw new IllegalArgumentException("角标越界");
        }
        if(Size==data.length){//扩容
            resize(data.length*2);
        }
        for(int i=Size;i>index;i--){
            data[i]=data[i-1];
        }
        data[index]=e;
        Size++;
    }

    private void resize(int newLength) {        //数组扩容或缩容
        E [] newData=(E [])(new Object[newLength]);
        for(int i=0;i<Size;i++){
            newData[i]=data[i];
        }
        data=newData;
    }

    @Override
    public void addFirst(E e) {
        add(0,e);
    }   //头插

    @Override
    public void addLast(E e) {
        add(Size,e);
    }    //尾插

    @Override
    public E get(int index) {     //获取该角标处的元素
        if(isEmpty()){
            throw new IllegalArgumentException("表为空");
        }
        if(index<0||index>=Size){
            throw new IllegalArgumentException("角标越界");
        }
        return data[index];
    }

    @Override
    public E getFirst() {     //获取一个月元素
        return get(0);
    }

    @Override
    public E getLast() {     //获取最后一个元素
        return get(Size-1);
    }

    @Override
    public void set(int index, E e) {//修改
        if(isEmpty()){
            throw new IllegalArgumentException("表为空");
        }
        if(index<0||index>=Size){
            throw new IllegalArgumentException("角标越界");
        }
        data[index]=e;
    }

    @Override
    public boolean contains(E e) {//判断是否包含e
        return find(e)!=-1;
    }

    @Override
    public int find(E e) {     //查找是否存在元素e  存在返回角标否则返回-1
        if(isEmpty()){
            throw new IllegalArgumentException("表为空");
        }
        for(int i=0;i<Size;i++){
            if(data[i].equals(e)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public E remove(int index) {    //删除指定角标元素
        if(isEmpty())
            throw new IllegalArgumentException("空的");
        if(index<0||index>Size){
            throw new IllegalArgumentException("角标越界了");
        }
        E delete=data[index];
        for(int i=index;i<Size;i++){
            data[i]=data[i+1];
        }
        Size--;
        if(Size>=10&&Size<=data.length/4){
            resize(data.length/2);
        }
        return delete;
    }

    @Override
    public E removeFirst() {    //删除第一个元素
        return remove(0);
    }

    @Override
    public E removeLast() {    //删除最后一个元素
        return remove(Size);
    }

    @Override
    public void removeElement(E e) {   //删除指定元素
        /*删第一个
        * int index=find(e);
        * if(index!=-1){
        *   remove(index);
        * }else{
        *    throw new  IllegalArgumentException("没有元素");}
        * */
        for(int i=Size-1;i>=0;i--){
            if(data[i]==e){
                remove(i);
            }
        }
    }

    @Override
    public void clear() {   //清除列表
        data=(E[])(new Object[DEAFULT_CAPACITY]);
        Size=0;
    }
     public int getCapacity(){ //返回最大长度
        return data.length;
     }
     public String toString(){
        StringBuilder s=new StringBuilder();
        s.append("ArrayList: "+Size+"/"+getCapacity()+"\n");
        s.append('[');
        if(isEmpty()){
            s.append(']');
        }else{
            for (int i = 0; i <Size ; i++) {
                s.append(data[i]);
                if(i==Size-1){
                    return s.append(']').toString();
                }
                s.append(',');
            }
        }
        return "";
     }

     //返回当前数据的迭代器
    //迭代器拥有没有角标支持的环境下遍历元素
    @Override
    public Iterator iterator() {     //创建迭代器
        return new ArrayListIterator();
    }
    private class ArrayListIterator implements Iterator{   //迭代器方法
        private int index=-1;
        @Override
        public boolean hasNext() {
            return index<Size-1;
        }

        @Override
        public E next() {
            index++;
            return data[index];
        }
    }
}

来源：CSDN

作者：qq_45162113

链接：https://blog.csdn.net/qq_45162113/article/details/103487735