自定义容器

容器
容器主要是指Collection所包含的实现类。Java集合类是一种特别有用的工具类,可以用于存储数量不等的对象,并可以实现常用的数据结构,如栈,队列等.Java集合就像一种容器,可以把多个对象(实际上是对象的引用,但习惯上都称对象) “丢进” 该容器中. 

具体结构如下：

• Collection
  • List
    • ArrayList
    • LinkedList
    • Vector
    • Stack
  • Set
    • HashSet
    • LinkedHashSet
    • TreeSet
• Map
  • HashMap
    • LinkedHashMap
  • TreeMap
  • ConcurrentHashMap
  • Hashtable

ArrayList和LinkList的区别？

ArrayList（数组结构）：

• 优点：get和set调用花费常数时间，也就是查询的速度快

• 缺点：新项的插入和现有项的删除代价昂贵，也就是添加删除的速度慢

LinkedList（链表结构）：

• 优点：新项的插入和和现有项的删除开销很小，即添加和删除的速度快

• 缺点：对get和set的调用花费昂贵，不适合做查询

List、Set、Map 之间的区别是什么？

List、Set、Map 的区别主要体现在两个方面：元素是否有序、是否允许元素重复。

ArraylList:

public class MyArrayList {
    private int size;
    private int DEFAULT_CAPACITY = 10;
    private Object[] elements;

    MyArrayList(int capacity) {
        elements = new Object[capacity];
    }

    MyArrayList() {
        elements = new Object[DEFAULT_CAPACITY];
    }
    public void add(Object o) {
        ensureCapacity();
        elements[size++] = o;
    }

    public void add(int index, Object o) throws Exception {
        indexCheck(index);
        ensureCapacity();
        System.arraycopy(elements, index, elements, index + 1, size - index);
        elements[index] = o;
        ++size;
    }

    private void ensureCapacity() {
        if (size >= elements.length) {
            int oldSize = elements.length;
            Object[] newElements = new Object[oldSize + (oldSize >> 1)];
            System.arraycopy(elements, 0, newElements, 0, size);
            elements = newElements;
        }
    }
    public Object get(int index) throws Exception {
        indexCheck(index);
        return elements[index];
    }

    /**
     * 下标合法性检测
     *
     * @param index
     * @return
     * @throws Exception
     */
    private boolean indexCheck(int index) throws Exception {
        if (index < 0 || index >= size) {
            throw new Exception("输入不合法");
        }
        return true;
    }

    public void remove(int index) throws Exception {
        indexCheck(index);
        System.arraycopy(elements, index + 1, elements, index, size - index);
        --size;
    }
    public void remove(Object o) {
        if (o == null) {
            return;
        } else {
            for (int i = 0; i < size; i++) {
                if (elements[i].equals(o)) {
                    System.arraycopy(elements, i + 1, elements, i, size - i);
                    --size;
                    return;
                }
            }
        }
    }

    public int size() {
        return size;
    }

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

    public static void main(String[] args) throws Exception {
        MyArrayList myArrayList = new MyArrayList();
        for (int i = 1; i <= 12; i++){
            myArrayList.add(i + "a");
        }
        myArrayList.add(2, "cccc");
        for (int i = 0; i < myArrayList.size(); i++){
            System.out.println(myArrayList.get(i));
        }
        System.out.println(myArrayList.size());
        myArrayList.clear();
        System.out.println(myArrayList.size());
    }
}

linkList:

public class MyLinkedList {
    private class Node{
        private Node per;
        private Node next;
        private Object val;
        Node(Object o){
            val = o;
        }
    }

    private int size;
    private Node root;
    private Node last;

    public void add(Object o){
        Node node = new Node(o);
        if(root == null){
            root = node;
            last = node;
        }else {
            last.next = node;
            node.per = last;
            last = node;
        }
        ++size;
    }

    public void add(int index, Object o) throws Exception {
        indexCheck(index);
        Node tmp = root;
        for (int i = 0; i < index; i++){
            tmp = tmp.next;
        }
        Node node = new Node(o);
        node.next = tmp;
        node.per = tmp.per;
        tmp.per.next = node;
        ++size;
    }

    private void indexCheck(int index) throws Exception {
        if (index < 0 || index > size)
            throw new Exception("输入错误");
    }

    public Object get(int index) throws Exception {
        indexCheck(index);
        Node tmp = root;
        for (int i = 0; i < index; i++){
            tmp = tmp.next;
        }
        return tmp.val;
    }

    public int size(){
        return size;
    }

    public void clear(){
        Node tmp = last;
        for (int i = size - 1; i > 0; i--){
            last = last.per;
            tmp = null;
        }
        size = 0;
    }

    public static void main(String[] args) throws Exception {
        MyLinkedList myLinkedList = new MyLinkedList();
        for (int i = 1; i <= 12; i++){
            myLinkedList.add(i + "a");
        }

        myLinkedList.add(2, "cccc");
        for (int i = 0; i < myLinkedList.size(); i++){
            System.out.println(myLinkedList.get(i));
        }
        System.out.println(myLinkedList.size());
        myLinkedList.clear();
        System.out.println(myLinkedList.size());
    }
}