ArrayList以及顺序表

线性表

是n个具有相同特性的数据元素的有限序列,线性表是一种在实际中广泛使用的数据结构,常见的线性表有:顺序表,链表,栈,队列

线性表在逻辑上为线性结构,也就是连续的一条直线,但物理上并不一定是连续的,线性表在物理上存储的时候,通常是以数组和链式结构的形式存储

顺序表

类似于图中,在物理上以及在逻辑上,都是为连续的
底层是数组

在数据结构中,每次存储数据的时候,一定要记住,必须有一个前驱信息
首先创建一个自己的接口MyList类

public interface MyList {
    //新增元素,默认在数组最后新增
    public void add (int data);

    //在pos位置新增元素
    public void add(int pos, int data);

    //判断是否包含某个元素
    public boolean contain(int toFind);

    //查找某个元素对应位置
    public int indexof(int toFind);

    //查找pos位置的元素
    public int get(int pos);

    //给pos位置元素设为value
    public void set(int pos,int value);

    //删除第一次出现的关键字
    public void remove(int toRemove);

    //获取顺序表的长度
    public int size();

    //清空顺序表
    public void clear();

    //打印顺序表
    public void display();

    //判断数组是否满了
    boolean isFull();
}

然后再写一个MyAaaryList的实现类

public class MyArrayList implements MyList{
    public int[] elem;
    //判断数组的长度,数组每增加一个,+1
    public int usedSize;
    //给顺序表定义一个初始的大小
    public static final int DEFAULT_SIZE = 10;
    public MyArrayList(){
        this.elem  = new int[DEFAULT_SIZE];
    }


    @Override
    public void add(int data) {
        checkIsFull();
        this.elem[this.usedSize] = data;
        usedSize++;
    }
    //检查数组长度是否要扩容
    private void checkIsFull(){
        if (isFull()){
            elem = Arrays.copyOf(elem,elem.length*2);
        }
    }

    @Override
    public void add(int pos, int data) {
        try {
            checkPosOnAdd(pos);
        }catch (PosIllegality e){
            e.printStackTrace();
            return;
        }
        checkIsFull();
        for (int i = usedSize - 1; i >= pos ;i--){
            elem[i+1] = elem[i];
        }
        elem[pos]  = data;
        usedSize++;
    }
    //自定义一个异常
    public class PosIllegality extends RuntimeException{
        public PosIllegality(String msg){
            super(msg);
        }
    }
    //我们在这边要先判断一下,pos是否是合法的,有无越界,提示可能抛出异常
    private void checkPosOnAdd(int pos) throws PosIllegality{
        if (pos < 0 || pos > usedSize){
            System.out.println("不合法");
            throw new PosIllegality("插入下标越界:" + pos);
        }
    }
    //查找元素前,先判断一下,数组是不是空的
    public boolean checkusedSize(){
        return usedSize == 0;
    }
    @Override
    public boolean contain(int toFind) {
        if(checkusedSize()){
            return false;
        }
        for (int i = 0; i < usedSize; i++) {
            if (elem[i] == toFind){
                return true;
            }
        }
        return false;
    }

    @Override
    public int indexof(int toFind) {
        if(checkusedSize()){
            return -1;
        }
        for (int i = 0; i < usedSize; i++) {
            if (elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }


    //写一个判断usedSize是否为空的异常
    public class MyArrayListusedSize extends RuntimeException{
        public MyArrayListusedSize(String msg){
            super(msg);
        }
    }
    @Override
    public int get(int pos) throws MyArrayListusedSize{
        try {
            checkPosOnAdd(pos);
        }catch (PosIllegality e){
            e.printStackTrace();
            return -1;
        }
        if (checkusedSize()){
            throw new MyArrayListusedSize("顺序表为空");
        }
        return elem[pos];
    }

    @Override
    public void set(int pos, int value) {
        checkPosOnAdd(pos);
        elem[pos] = value;
    }

    @Override
    public void remove(int toRemove) {
        int index = indexof(toRemove);
        if(index == -1){
            System.out.println("没有这个数");
            return;
        }
        for (int i = index; i < usedSize-1; i++){
            elem[i] = elem[i + 1];
        }
        usedSize--;
    }

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

    @Override
    public void clear() {
        this.usedSize = 0;
    }

    @Override
    public void display() {
        for (int i  =0; i < this.usedSize; i++){
            System.out.print(this.elem[i]+ " ");
        }
        System.out.println( );
    }

    @Override
    public boolean isFull() {
        if(elem.length == usedSize){
            return true;
        }
        return false;
    }
}

最后在main方法中实习这个MyArrayList

public class Test {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);//0
        myArrayList.add(2);//1
        myArrayList.add(199);//2
        myArrayList.display();
        System.out.println("============================");

        System.out.println(myArrayList.indexof(3));

        /* myArrayList.clear();
        myArrayList.display();*/
    }
}

上面就是我们自己实现ArrayList的具体过程,像在ArrayList中,在创建对象的时候,是不会给初始空间的,只有在add的时候,才会给一个10的空间,而且在扩容的时候,是1.5倍扩容

ArrayList的遍历一共有三种;
1>通过for循环访问下标
2>通过for-each来打印
3>通过迭代器(实现interable就可以用)

Iterator <Interger> int = list.iterator();
while(it.hasNext() ){
     System.out.print(it.next() + " ");
}