自定义ArrayList和LinkedList

 

一. 总结
 1.Array List中引入capacity和size的概念，capacity表示数组容量，对于用户来说没有意义
 size表示实际元素数量，供用户读取，该值被设置为private，防止用户肆意篡改，但是剋以
 通过size（）获取
 2.capacity的初始值可以有用户指订，如果没有 系统默认为10
 3.modCount的作用
 用于存储当前ArrayList结构的修改次数
 4.Arraylist以1.5倍的扩容方式去扩容
 5.Max_ARRAY_SIZE=Integer.MAX_VALUE-8
 数组的对象头-length 表示数组的长度
1.总结数组和ArrayList区别和联系
a. 数组和ArrayList都表示可以存一组同类型的对象；都使用下标定位和查找元素；
b. 数组的定义：
int[] num=new int[10];
Employee[] staff=new Employee[100];
c. ArrayList的使用：
List list＝new ArrayList();
list.add();
1. List和ArrayList的区别和联系.
 联系：两者都继承了IList接口
 区别：1.ArrayList不是类型安全的，而List已经声明过其数据的对象类型，是类型安全的
       2.ArrayList为了兼容所有类型对象,使用了Object数组，在使用元素的时候会有装箱和拆箱的操作
       3.ArrayList只有把元素添加进去之后才可以通过下标访问相应的元素.
       4.数组在创建的时候就已经确定了数据类型,并且它的长度是固定的，只能通过下标改变各个元素的值和访问.
2.Vector和ArrayList区别和联系
相同：ArrayList和Vector底层数据结构相同也是一个动态数组存放数据。都实现了List等接口。
当两者容量不够时，都会进行对Object数组的扩容
异处：Vector是一个同步容器并不是一个并发容器。而ArrayList是一个支持并发的容器。

二.1 ArrayList的属性及构造函数：

class MyArrayList<T>{
    private T[] elements;
    private int size;
    public MyArrayList(){
        this(5);
    }
    public MyArrayList(int capacity){
        elements=(T[])new Object[capacity];
    }

ArrayList底层实现就是数组；

无参构造函数，初始化默认数组大小为5；

有参构造，创建一个长度为capacity的Object类型的数组；

2.checkIndex方法判断合法性；

    public void checkIndex(int index){
        if(index<0||index>elements.length){
            throw new UnsupportedOperationException("the index is illegal");
        }
    }

3.自定义添加数据方法：add();

    public void add(T value){
        //判断是否需要扩容
        if(size==elements.length){
            this.elements= Arrays.copyOf(this.elements,this.elements.length*2);
        }
        //添加元素
        elements[size++]=value;
    }

Arrays.coypyOf方法扩容数组；

Arrays.copyOf(原数组，当前扩容数组长度);

4.自定义删除数据方法：remove();

 public boolean remove(int index){
        try{
            checkIndex(index);
            System.arraycopy(this.elements,index+1,this.elements,index ,size-1-index);
            elements[--size]=null;
            return true;
        }catch(UnsupportedOperationException e){
            System.out.println(e.getMessage());
            return false;
        }
    }

首先判断下标是否存在，如果不存在则抛出异常；

存在则将当前坐标下的数据删除，后面的数据往前移动；

elements[--size] = null;    方便垃圾回收；

5.自定义改变数据方法：set();

   public void set(int index,T newValue) {
        try {
            checkIndex(index);
            elements[index] = newValue;
        } catch (UnsupportedOperationException e) {
            System.out.println(e.getMessage());
        }
    }

先判断下标是否存在，再将新值覆盖旧值；

6.自定义查找数据方法：get();

    public T get(int index) {
        try {
            checkIndex(index);
            return elements[index];
        } catch (UnsupportedOperationException e) {
            System.out.println(e.getMessage());
            return null;
        }
    }

判断下标是否存在，如若不存在，则抛出异常；反之如果查找的下标下存在数据，则返回坐标下的数据，否则返回null；

7.自定义重写方法：toString();

    public String toString(){
        StringBuilder strs=new StringBuilder();
        for(int i=0;i<size;i++){
            strs.append(elements[i]+" ");
        }
        return strs.toString();
    }

三.自定义LinkedList：

LinkedList的属性及构造函数：

class MyLinkedList<E>{
    protected Node<E> first; //指向链表的第一个元素
    protected Node<E> last; //指向链表的最后一个元素
    protected int size; //当前链表的元素个数

    class Node<E>{
        private E data; //元素内容
        private Node<E> prev; //前驱引用
        private Node<E> next; //后驱引用

        public Node(E data, Node<E> prev, Node<E> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }

LinkedList底层使用链表实现；

2.尾插法添加元素：

    public void add(E value){
        Node<E> tmp = last;
        Node<E> newNode = new Node<>(value, tmp, null);
        last = newNode;

        if(tmp == null){
            first = newNode;
        }else{
            tmp.next = newNode;
        }
        size++;
    }

定义tmp保存last节点，再定义一个新的节点，在链表尾部增添元素；

3.在指定位置添加元素：

    public void add(int index, E value){
        if(index < 0 || index > size){
            return;
        }
        if(index == size){
            add(value);
        }else{
            Node<E> succ = findNodeByIndex(index);
            Node<E> succPre = succ.prev;
            Node<E> newNode = new Node(value, succPre, succ);
            succ.prev = newNode;

            if(succPre == null){
                //说明原先链表只有一个节点
                first = newNode;
            }else{
                succPre.next = newNode;
            }
        }
        size++;
    }

    public Node<E> findNodeByIndex(int index){

        Node<E> tmp = first;
        for(int i=0; i<index; i++){
            tmp = tmp.next;
        }
        return tmp;
    }

定义方法findNodeByIndex判断下标是否合法，再定义succ，succPre和一个newNode保存添加的元素，

succ.prev = newNode;      succPre.next = newNode;

4.删除元素：

 public boolean remove(E value){
        Node<E> succ = findNodeByValue(value);
        if(succ == null){
            return false;
        }

        //考虑删除的是第一个元素和最后一个元素的情况
        Node<E> succPrev = succ.prev;
        Node<E> succNext = succ.next;

        if(succPrev == null){
            first = succNext;
        }else{
            succPrev.next = succNext;
            succ.prev = null;
        }

        if(succNext == null){
            last = succPrev;
        }else{
            succNext.prev = succPrev;
            succ.next = null;
        }

        succ.data = null;
        size--;

        return true;
    }

    public Node<E> findNodeByValue(E value){
        for(Node<E> tmp=first; tmp!=null; tmp=tmp.next){
            if(value.equals(tmp.data)){
                return tmp;
            }
        }
        return null;
    }

先定义方法判断想要删除的元素是否存在，然后考虑删除的是第一个元素还是最后一个元素；

5.得到某一坐标下元素的值：

    public E get(int index){
        Node<E> tmp = first;
        for(int i=0; i<index; i++){
            tmp = tmp.next;
        }
        if(tmp != null){
            return tmp.data;
        }
        return null;
    }

6.重写toString方法：

    public String toString(){
        StringBuilder strs = new StringBuilder();
        Node<E> tmp = first;
        for(; tmp != null; tmp = tmp.next){
            strs.append(tmp.data + " ");
        }
        return strs.toString();
    }

使用StringBuilder中的append方法进行重写；