java数据结构——顺序表（MyArrayList的实现）

目录

1.ArrayList——顺序表

 2.实现自定义的一个顺序表

（1）定义一个Mylist接口

（2）创建一个MyArrayList类

---

1.ArrayList——顺序表

ArrayList继承自List      ArrayList  implements List

List的特征：List当中的元素在逻辑上有先后的关系

                    每个元素都有唯一的位置与之相关联

List的方法

 2.实现自定义的一个顺序表

（1）定义一个Mylist接口

在接口当中定义出要实现的相应的抽象方法如：add（），remove（），get（），set（）等

package javaDS;

public interface MyList {
    int size();
    boolean add(Long e);

    /**
     * 将 e 插入到线性表的 index 位置，从 [index, size()) 向后移
     * index 的合法下标 [0, size()]
     * 如果下标不合法：抛出一个 ArrayIndexOutOfBoundsException
     * @param index
     * @param e
     */
    void add(int index, Long e);

    /**
     * 删除 index 位置的元素
     * index 的合法下标：[0, size())
     * 如果下标不合法：抛出一个 ArrayIndexOutOfBoundsException
     * @param index
     * @return 从线性表中删除掉的元素
     */
    Long remove(int index);

    /**
     * 从前到后，删除第一个遇到的 e（ equals() == true）
     * @param e
     * @return 删除成功：true，没有该元素：false
     */
    boolean remove(Long e);

    /**
     * 直接返回 index 位置的元素
     * index: [0, size())
     * @param index
     * @return
     */
    Long get(int index);

    /**
     * 使用 e 替换 index 位置的元素
     * @param index [0, size())
     * @param e
     * @return 原来 index 位置的元素
     */
    Long set(int index, Long e);

    /**
     * 返回第一次遇到 e 的下标（equals() == true）
     * @param e
     * @return 如果没有找到，返回 -1
     */
    int indexOf(Long e);

    /**
     * 从后往前，返回第一次遇到 e 的下标（equals() == true）
     * @param e
     * @return 如果没有找到，返回 -1
     */
    int lastIndexOf(Long e);

    /**
     * 线性表中是否包含 e（equals）
     * @param e
     * @return
     */
    boolean contains(Long e);

    /**
     * 清空线性表
     */
    void clear();

    /**
     * 判断线性表是否是空的（empty） 等价于一个元素都没有
     * @return
     */
    boolean isEmpty();
}

（2）创建一个MyArrayList类

再自己的MyArrayList类当中去去一个个实现定义好的接口当中的抽象方法

（1）将MyArrayList与MyList接口进行连接

（2）先定义好Array数组来存储相应的元素

（3）实现不同的构造方法（有参    无参）

（4）重写接口当中的各种方法

（5）写主函数进行调试和测试

package javaDS;

import java.sql.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MyArrayList implements MyList {
    private Long [] Array;
    int size;
    public MyArrayList(){
        this.size=0;
        this.Array=new Long[20];
    }

    @Override
    public String toString() {
        return "MyArrayList{" +
                "Array=" + Arrays.toString(Array) +
                ", size=" + size +
                '}';
    }

    public MyArrayList(int initialCapacity){
        this.size=0;
        this.Array=new Long[initialCapacity];
    }
    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean add(Long e) {
        Array[size]=e;
        size++;
        return true;
    }

    @Override
    public void add(int index, Long e) {
        if(index<0|index>size){
            throw new ArrayIndexOutOfBoundsException("插入下标有误！");
        }
        for (int i = size-1; i >=index ; i--) {
            Array[i+1]=Array[i];
        }
        Array[index]=e;
        size++;
    }

    @Override
    public Long remove(int index) {
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("删除下标有误！");
        }
        else if(Array[index]==null) {
            return null;
        }
        Long e=Array[index];
        for (int i = index+1; i <size ; i++) {
            Array[i-1]=Array[i];
        }
        Array[size-1]=null;
        size--;
        return  e;//返回删除的元素
    }

    @Override
    public boolean remove(Long e) {
        for (int i = 0; i <size ; i++) {
            if(Array[i]==e){
                for (int j = i+1; j <size ; j++) {
                    Array[j-1]=Array[j];
                }
                Array[size-1]=null;
                size--;
                return true;
            }
        }
        return false;
    }

    @Override
    public Long get(int index) {
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("删除下标有误！");
        }
        return Array[index];
    }

    @Override
    public Long set(int index, Long e) {
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("删除下标有误！");
        }
        Long old=Array[index];
        Array[index]=e;
        return old;
    }

    @Override
    public int indexOf(Long e) {
        for (int i = 0; i < size; i++) {
            if(Array[i]==e){
                return i;
            }
        }
        return -1;
    }

    @Override
    public int lastIndexOf(Long e) {
        for (int i = size-1; i >=0 ; i--) {
            if(Array[i]==e){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(Long e) {
        for (int i = 0; i < size; i++) {
            if (Array[i]==e) {
                return true;
            }
        }
        return false;
    }

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

    @Override
    public boolean isEmpty() {
        if(size==0){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        MyArrayList myArrayList=new MyArrayList();
        myArrayList.add(10L);
        myArrayList.add(20L);
        myArrayList.add(30L);
        myArrayList.add(40L);
        myArrayList.add(50L);
        System.out.println(myArrayList.toString());
    }
}