List

List对比

ArrayList:底层实现时数组,线程不安全，效率高。所以，查询快。修改、插入、删除慢。
LinkedList:底层实现是链表,线程不安全，效率高。所以，查询慢。修改、插入、删除快。
Vector:线程安全的，效率低。

自己实现ArrayList

public class MyArrayList {
    private Object[] elementData;
    private int size;
    public MyArrayList() {
    	// TODO Auto-generated constructor stub
    	this(10);
    }
    public MyArrayList(int initialCapacity) {
    	if(initialCapacity<0) {
    		try {
    			throw new Exception();
    		}catch(Exception e) {
    			e.printStackTrace();
    		}
    	}
    	elementData= new Object[initialCapacity];
    }
    // 数组扩容
    public void ensureCapacity() {
    	if(size>=elementData.length) {
    		Object[] newArray = new Object[size*2+1];
    		System.arraycopy(elementData, 0, newArray,0, elementData.length);
    		elementData = newArray;
    	}
    }
    // 添加元素
    public void add(Object obj) {
    	//数组扩容
    	ensureCapacity();
    	elementData[size++]= obj;
    }
    // 数组是否为空
    public boolean isEmpty(){
    	return size == 0;
    }
    // 检查传入索引是否合适
    private void rangeCheck(int index) {
    	if(index<0||index>size) {
    		try {
    			throw new Exception();
    		}catch (Exception e) {
    			// TODO: handle exception
    		}
    	}
    }
    // 获取指定位置的元素
    public Object get(int index) {
    	rangeCheck(index);
    	return elementData[index];
    }
    //删除指定位置的元素
    public void remove(int index) {
    	rangeCheck(index);
    	int numMoved = size- index -1;
    	System.arraycopy(elementData, index+1, elementData, index, numMoved);
    }
    //删除指定元素
    public boolean remove(Object obj) {
    	for(int i=0;i<size;i++) {
    		if(get(i).equals(obj)) {
    			remove(i);
    			return true;
    		}
    	}
    	return false;
    }
    //设置某个元素的值
    public Object set(int index,Object obj) {
    	rangeCheck(index);
    	elementData[index] =obj;
    	return obj;
    }
    //在某个位置添加元素
    public void add (int index,Object obj) {
    	rangeCheck(index);
    	ensureCapacity();
    	System.arraycopy(elementData, index, elementData, index+1, size-index);
    	size++;
    }
}
复制代码

自己实现LinkedList

// Node
class Node{
	private Node pre;
	private Object obj;
	private Node next;
	
	public Node() {
		// TODO Auto-generated constructor stub
	}

	public Node getPre() {
		return pre;
	}

	public void setPre(Node pre) {
		this.pre = pre;
	}

	public Object getObj() {
		return obj;
	}

	public void setObj(Object obj) {
		this.obj = obj;
	}

	public Node getNext() {
		return next;
	}

	public void setNext(Node next) {
		this.next = next;
	}
}
复制代码

// linkedNode
public class MyLinkedList {
	private Node first;
	private Node last;
	private int size;
	
	public void add(Object obj) {
		if(first==null) {
			Node n =new Node();
			n.setPre(null);
			n.setObj(obj);
			n.setNext(null);
			first = n;
			last = n;
		}else {
			//直接向last节点后增加新的节点
			Node node=new Node();
			node.setPre(last);
			node.setObj(obj);
			node.setNext(null);
			last.setNext(node);
			last = node;
		}
		size++;
	}
	public int size() {
		return size;
	}
	// 检查传入索引是否合适
	private void rangeCheck(int index) {
		if(index<0||index>=size) {
			try {
				throw new Exception();
			}catch (Exception e) {
				// TODO: handle exception
			}
		}
	}
	public Object get(int index) {
		rangeCheck(index);
		
		return getNode(index).getObj();
	}
	private Node getNode(int index) {
		Node tmp =null;
		if(first!=null) {
			tmp = first;
			for(int i=0;i<index;i++) {
				tmp = tmp.getNext();
			}
		}
		return tmp;
	}
	public void remove(int index) {
		rangeCheck(index);
		Node tmp =getNode(index);
		if(tmp!=null) {
			Node pre = tmp.getPre();
			Node next = tmp.getNext();
			pre.setNext(next);
			next.setPre(pre);
			size--;
		}
	}
	public void add(int index,Object obj) {
		Node tmp  = getNode(index);
		Node newNode = new Node();
		newNode.setObj(obj);
		if(tmp!=null) {
			Node pre = tmp.getPre();
			pre.setNext(newNode);
			newNode.setPre(pre);
			
			newNode.setNext(tmp);
			tmp.setPre(newNode);
			size++;
		}
	}
}
复制代码

转载于:https://juejin.im/post/5a5ca87851882573351a4ae4