容器剖析

主要用于容器类的遍历
容器：不用关心数组的边界问题，动态扩展。

所有的容器类都实现Collection或Map接口，用Iterator迭代器进行元素得带，且java中提供了容器的工具类Collections和Arrays

模拟ArrayList类
ArrayList内部是数组

package test;
//手动写一个容器类,用数组模拟
public class ArrayList {

    //数组大小为10，当数组中装满时，扩展空间，这样就可以实现无限多个
    Object[] objects=new Object[10];
    //index记录装了多少个对象
    int index;

    //添加对象
    public void add(Object o){
        if(index==objects.length){
            //当现有数组满了就创建一个新的数组对象，这个数组对象创建 
            //为多大，java内部会有一个加权算法
            Object[] newObjects=new Object[objects.length*2];
            //把原数组内容copy到新数组中
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
            //元素组引用指向新数组
            objects=newObjects;
        }
        objects[index]=o;
        index++;
    }   
    //容器已装元素的个数，添加的时候就记录，而不是要得到size的时候还得遍历
    public int size(){
        return index;
    }
}

用链表模拟容器
链表包含数据本身和执行下一个节点的引用

1、Node对象

package test;
public class Node {
    private Object data;//数据本身
    private Node next;//指向下一个节点 
    public Node(Object data, Node node) {
        super();
        this.data = data;
        this.next = node;
    }
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node node) {
        this.next = node;
    }
}

2、LinkedList

package test;

public class LinkedList {

    Node head=null;//头节点
    Node tail=null;//尾节点
    int size=0;

    //添加
    public void add(Object o){
        Node n=new Node(o,null);
        //如果添加进入的节点是第一个节点，即为head和tail赋值
        if(head==null){
            head=n;
            tail=n;
        }
        //把尾节点tail指向新加入的节点
        tail.setNext(n);
        //新加入的节点变成尾节点
        tail=n;
        size++;
    }

    public int size(){
        return size;
    }
}

带泛型的容器
带泛型的容器，就只能往容器中装固定类型的元素，且取出元素的时候就需要强制类型转换

未完待续。。。。。。。。。。