浅谈Java容器及原理

学java其实学了很久了，但其实一直对容器没有一个深入的了解。了解的东西其实都是最简单的、常用的一些方法。

在这里我将对java的容器做一个系统的，比较浅显的回顾。包括容器的类型、容器的底层实现原理、具体的实例。

一、容器的原理与底层

容器：Collection收集，集合。本身也是一个对象，只不过它可以容纳其他的对象。前面比较典型的容器是数组Array[]

在这里我们主要要关注以下几个接口：Collection（容器）、Map（键值对）

Collection接口：定义了存取一组对象的方法，子接口Set、List、接口
Set：无序不可重复，若重复则后面的值会把前面的覆盖掉，子类Hashset
List：有序可重复

Map接口：（注意Map不是继承Collection的）单独的接口，键值对，子类有HashMap、TreeMap,允许值重复，键不能重复

Collection接口：size、isEmpty、contains、iterator、toArray、add、remove、containsAll（是否包含另一个集合里的所有对象）、addAll、equals、hashCode

1、List的底层实现：数组实现，它的特点是每个元素都有索引，因此优点也显而易见就是查询速度快。但是修改删除插入效率低。由于删除和插入会引起元素的移动，因此效率低下。

自定义ArrayList，实现list 的获取、增加、删除元素。Arraylist由于是数组实现，因此在扩容的时候采取的是将容量扩大到两倍。

import java.util.ArrayList;
import java.util.Date;

public class MyArrayList {
    private Object[] element;
    private int size;

    public MyArrayList(){
        this(10);
    }
    public MyArrayList(int capacity){
        if(capacity<0){
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        element = new Object[capacity];
    }
    public void add(Object e){
//        数组扩容
        if(size == element.length){
            Object[] newArr = new Object[size*2+1];
            System.arraycopy(element,0 ,newArr,0,element.length);
            element = newArr;
        }
        element[size++] = e;

    }
    public Object get(int index){
        changeIndex(index);
        return element[index];
    }
    public void remove(int index){
        if(index <0 || index >=size){
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //需要移动元素 ，未写完
    }
    public void changeIndex(int index){
        if(index<0||index>=size){
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        MyArrayList ml=new MyArrayList();
        ArrayList l = new ArrayList();
        ml.add("1");
        ml.add(new Date());
        System.out.println(ml.get(1));
    }
}

2、LinkedList原理+自定义实现

采用双向链表实现，他的特点是采用链表的原理，因此查询较List更慢，因为它没有索引，因此必须遍历整个链表，插入修改删除效率较高，无需移动元素。

自定义实现add、remove、get方法

public class MyLinkedList {
    private Node first;
    private Node last;
    private int size;

    public MyLinkedList() {

    }
    public void add(Object e){
        if(null == first){
            Node n = new Node();
            n.setPre(null);
            n.setObj(e);
            n.setNext(null);
            first = n;
            last = n;
        }else{
            Node n = new Node();
            n.setPre(last);
            n.setObj(e);
            n.setNext(null);

            last.setNext(n);

            last = n;
        }

        size++;
    }
    public int size(){
        return size;
    }