JAVA基础-容器篇

注：原文来源于http://www.sxt.cn

容器中的接口层次如下：

特点说明：

Set：集合，无序，不可重复。

List：列表，有序，可重复。

Map：键值对，无序，key不可重复。

底层实现：

ArrayList:  底层用数组实现的List, 特点是：查询效率高 ，增删效率低，线程不安全。

LinkedList:  底层是双向链表实现的List, 特点是：查询效率低，增删效率高，线程不安全。

Vector: 底层用数组实现的List,特点：线程安全.

HashMap：底层用数组和单向链表实现，根据key的hashcode，散列到数组中（简单散列计算：默认16取余数，余数为数组的下标），数组元素使用单向链表（如果链表超过8，则使用红黑树结构）。

HashSet：底层是用HashMap实现的，key值保存HashSet的存储对象，value静态的唯一的Object实例。

自简单实现ArrayList：

package com.sxt.collection;

public class MyList<E> {
	private final static int DEFAULT_CAPACITY = 10;
	private Object[] elementData;
	private int size;
	
	public MyList(int initialCapacity) {
		if (initialCapacity==0) {
			elementData = new Object[DEFAULT_CAPACITY];
		}else if (initialCapacity>0) {
			elementData = new Object[initialCapacity];
		}else {
			throw new RuntimeException("传参错误:"+initialCapacity);
		}
	}
	
	public MyList() {
		
		elementData = new Object[DEFAULT_CAPACITY];
	}
	
	public void add(E element) {
		checkCapacity(size);
		elementData[size++]=element;
	}
	
	
	@SuppressWarnings("unchecked")
	public E get(int index) {
		indexCheck(index);
		return (E) elementData[index];
	}
	
	public void remove(int index) {
		indexCheck(index);
		System.arraycopy(elementData, index+1, elementData, index, size-index-1);
		elementData[size--]= null;
	}
	
	public int getSize() {
		return size;
	}
	
	public int indexOf(Object o) {
		if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
	}
	
	private void checkCapacity(int capacity) {
		if (capacity+1>elementData.length) {
			Object[] temp = new Object[(elementData.length>>1)+elementData.length];
			System.arraycopy(elementData, 0, temp, 0, size);
			elementData = temp;
		}
	}
	
	private void indexCheck(int index) {
		if(index<0 || index>size-1) {
			throw new RuntimeException("越界");
		}
	}

	@Override
	public String toString() {
		StringBuilder strings = new StringBuilder("[");
		for (int i = 0; i < size; i++) {
			strings.append(elementData[i]+",");
		}
		strings.setCharAt(strings.length()-1, ']');
		return strings.toString();
	}
	
	
}

自简单实现LinkedList：

package com.sxt.mylinkedlist;

public class Node {
	Node next;
	Node pre;
	Object element;
	
	public Node(Object element) {
		super();
		this.element = element;
	}

}

public class MyLinkedList<E> {
	private Node first;
	private Node last;
	private int size;
	
	public void add(E element) {
		Node node = new Node(element);
		if(first == null) {
			first = node;
			last = node;
		}else {
			last.next = node;
			node.pre = last;
			last = node;
		}
		size++;
	}


	public E get(int index) {
		Node node = getNode(index);
		return (E)node.element;
	}
	
	private Node getNode(int index) {
		indexCheck(index);
		Node temp;
		if (index <(size>>1)) {
			temp = first;
			for (int i = 0; i < index; i++) {
				temp = temp.next;
			}
		}else {
			temp = last;
			for (int i = size-1; i > index; i--) {
				temp = temp.pre;
			}
		}
		return temp;
	}
	
	public void remove(int index) {
		Node node = getNode(index);
		if (null!=node) {
			if(node==first) {
				first = node.next;
				node.next.pre = null;
				node.next = null;
			}else if(node==last){
				last = node.pre;
				node.pre.next = null;
				node.pre = null;
			}else {
				node.pre.next = node.next;
				node.next.pre = node.pre;
				node.next = null;
				node.pre = null;
			}
			size--;
		}
		
	}
	
	
	@Override
	public String toString() {
		Node temp = first;
		StringBuilder strs = new StringBuilder("[");
		for (int i = 0; i < size; i++) {
			strs.append(temp.element+",");
			temp = temp.next;
		}
		strs.setCharAt(strs.length()-1, ']');
		return strs.toString();
	}	
	
	private void indexCheck(int index) {
		if(index<0 || index>size-1) {
			throw new RuntimeException("越界");
		}
	}
	
}

 

自简单实现HashMap：

package com.sxt.mymap;

public class MyHashMap<K,V> {
	
	Node[] table;
	int size;
	
	
	public MyHashMap() {
		table = new Node[16];
	}
	
	public void put(K k, V v) {
		boolean replaceFlag = false;
		Node node = new Node();
		node.hash = myHashCode(k.hashCode(), table.length);
		node.key = k;
		node.value = v;
		Node temp = table[node.hash];
		if(null == temp) {
			table[node.hash] = node;
			size++;
		}else {
			while(null!=temp){
				if(temp.key.equals(k)) {
					replaceFlag = true;
					break;
				}
				temp=temp.next;
			}
			if(true == replaceFlag) {
				temp.value = node.value;
			}else {
				temp.next=node;
				size++;
			}
		}
		
	}
	
	public V get(K k) {
		int index = myHashCode(k.hashCode(), table.length);
		Node temp = table[index];
		V value = null;
		if (null == temp) {
			return value;
		}
		while(null!=temp) {
			if (temp.key.equals(k)) {
				return (V)temp.value;
			}
			temp = temp.next;
		}
		return value;
	}
	
	private int myHashCode(int v, int length) {
		return v&(length-1); //length 必须为2的整数幂，不然就使用%取余
	}

	@Override
	public String toString() {
		StringBuilder strs = new StringBuilder("[");
		for (int i = 0; i < table.length; i++) {
			if(null != table[i]) {
				Node temp = table[i];
				while(null != temp) {
					strs.append("(key="+temp.key+",value="+temp.value+"),");
					temp = temp.next;
				}
			}
		}
		strs.setCharAt(strs.length()-1, ']');
		return strs.toString();
	}
	
	
	
	
}

class Node<K,V> {
	int hash;
	K value;
	V key;
	Node<K,V> next;
	
}

 

自简单实现HashSet：

package com.sxt.myhashset;

import java.util.HashMap;
import java.util.Map;

public class MyHashSet<E> {
	private static final Object obj = new Object();
	Map<E, Object> mymap;
	
	public MyHashSet() {
		mymap = new HashMap<>();
	}
	
	public int size() {
		return mymap.size();
	}
	
	public void add(E element) {
		mymap.put(element, obj);
	}

	@Override
	public String toString() {
		StringBuilder strs = new StringBuilder("[");
		for (Object key : mymap.keySet()) {
			strs.append(key.toString()+",");
		}
		strs.setCharAt(strs.length()-1, ']');
		return strs.toString();
	}
	
	
	
	
}