MyArrayList (plus)

Iterable

可以被迭代的 interface Iterbale{ I
terator iterator();
//通过iterator方法，返回迭代器（iterator)
}

ArrayList<String> list=new ArrayList<>();
        list.add("y");
        list.add("y");
        list.add("d");
        list.add("s");

        Iterable<String> r1=list;

        //r1 iterable对象,进行iterator方法
//1.
       /* Iterator<String> it=r1.iterator();

        System.out.println(it.hasNext());//true
        String s1=it.next();
        System.out.println(s1);*/


//2.
        Iterator<String> it=r1.iterator();
        while(it.hasNext()){
            System.out.println();
            String s=it.next();
            System.out.println(s);
        }

/*
for(String:r1){
System.out.println(s);
}
 */

Collection

ArrayList<String> list = new ArrayList<>();
        list.add("y");
        list.add("y");
        list.add("d");
        list.add("s");


        /*
        interface Collection<E>{
        boolean add(E e);//在Collection语境下不能说是尾插
        Collection代表的不一定是线性表，没有头/尾概念
        }

		List语境下，add一定返回true
		Collection语境下，add可以返回false

         */


        Collection<String> collection=list;
        System.out.println(collection);//[y, y, d, s]

        for(String e:collection){
            System.out.println(e);
            //y
            //y
            //d
            //s
        }

        collection.add("ds");
        System.out.println(collection);//[y, y, d, s, ds]

        collection.remove("y");
        collection.isEmpty();
        collection.clear();
        collection.size();
        collection.contains("d");

java中所有的引用，主要分为三大类：
1.接口类型引用
2.类类型引用
3.数组类型引用
（下标【】这种运算符，只能用于数组类型的引用
ps: ArratyLista=new ArrayList<>();
…
a[3]=“hehe”;
因为不是数组类型的引用

MyrealArrayList

MyList.java

public interface Mylist {
    boolean add(Integer e);
    void add(int index, Integer e);

    Integer remove(int index);
    boolean remove(Integer e);

    Integer get(int index);
    Integer set(int index, Integer e);

    boolean contains(Integer e);
    int indexOf(Integer e);
    int lastIndexOf(Integer e);

    void clear();
    int size();
    boolean isEmpty();
}

MyArrayListdemo.java

public class MyArrayListdemo {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
    }
}

MyListdemo.java

    public static void main(String[] args) {
            MyList list = new MyrealArrayList();
            System.out.println(list);
            list.add(1);
            list.add(2);
            list.add(3);
        System.out.println(list);

        list.add(2,5);
        System.out.println(list);//1 2 5 3

        list.remove(2);
        System.out.println(list);

    }
}

MyrealArrayList.java

    
public class  MyrealArrayList implements MyList {
    
    private Integer[] array;
    private int size;

    public MyrealArrayList(){
        array=new Integer[16];
        size=0;
    }


    @Override
    public boolean add(Integer e) {
        //尾插
        array[size]=e;
        size++;

        return true;
    }

    @Override
    public void add(int index, Integer e) {

        //1.判断下标是否合法
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("Index:"+index+"Size:"+size);
        }

        for(int before=size-1;before>=index;before--) {
            int after = before + 1;
            array[after] = array[before];
        }
            array[index]=e;
            size++;
        }



    @Override
    public Integer remove(int index) {
        //1.判断下标是否合法
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("Index:"+index+"Size:"+size);
        }
        Integer e = array[index];
        for(int before=index+1;before<size;before++){
            int after=before-1;
            array[after]=array[before];
        }
        array[size - 1] = null;
        size--;

        return e;

    }

    @Override
    public boolean remove(Integer e) {
        int i = indexOf(e);
        if (i < 0) {
            return false;
        }

        remove(i);
        return true;
    }

    @Override
    public Integer get(int index) {
        // 1. 先考虑 index 是否合法
        if (index < 0 || index >= size()) {
            throw new ArrayIndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        return array[index];
    }

    @Override
    public Integer set(int index, Integer e) {
        // 1. 先考虑 index 是否合法
        if (index < 0 || index >= size()) {
            throw new ArrayIndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }

        Integer olde = array[index];
        array[index] = e;
        return olde;
    }

    @Override
    public boolean contains(Integer e) {

            return indexOf(e) >= 0;
    }

    @Override
    public int indexOf(Integer e) {
        for (int i = 0; i < size; i++) {
            if (e.equals(array[i])) {   // 使用的是 equals 进行比较
                return i;
            }
        }

        return -1;
    }

    @Override
    public int lastIndexOf(Integer e) {
        for (int i = size - 1; i >= 0; i--) {
            if (e.equals(array[i])) {
                return i;
            }
        }

        return -1;
    }

    @Override
    public void clear() {

        Arrays.fill(array, null);
        size = 0;
    }

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

    @Override
    public boolean isEmpty() {

            return size == 0;
    }

//essential
    public String toString(){
        Integer[] toshow= Arrays.copyOf(array,size);
        return Arrays.toString(toshow);
    }
}