Java学习笔记之--------容器类及部分底层代码实现（Collection、List、Set、Queue，Map、HashMap、HashSet）

容器

容器可以管理对象的生命周期、对象与对象之间的依赖关系，您可以使用一个配置文件（通常是XML），在上面定义好对象的名称、如何产生（Prototype 方式或Singleton方式）、哪个对象产生之后必须设定成为某个对象的属性等，在启动容器之后，所有的对象都可以直接取用，不用编写任何一行程序代码来产生对象，或是建立对象与对象之间的依赖关系。

Java中的容器类主要有Collection和Map，它们的区别如下：

Collection：Collection表示一组对象，这些对象也称为collection的元素。一些collection允许有重复的元素，而另一些则不允许。

Map：将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

1. Collection

Collection是层次结构中的根接口。Collection表示一组对象，这些对象也称为collection的元素。一些collection允许有重复的元素，而另一些则不允许。一些collection是有序的，而另一些则是无序的。JDK不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递collection，并在需要最大普遍性的地方操作这些collection。

Collection与数组的不同：数组的容量是有限制的，而collection没有这样的限制，它的容量可以自动的调节。Collection只能用来存放对象，而数组没有这样的限制。

注意：Set、List、Queue是Collection的子接口，Map不是。

主要介绍一下Set、List、Queue。

1.1 List

List是有序的collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

List的方法：

add(E e)	向列表的尾部添加指定的元素（可选操作）
add(int index, E element)	在列表的指定位置插入指定元素（可选操作）
remove(int index)	移除列表中指定位置的元素（可选操作）
remove(Object o)	从此列表中移除第一次出现的指定元素（如果存在）（可选操作）
set(int index, E element)	用指定元素替换列表中指定位置的元素（可选操作）
get(int index)	返回列表中指定位置的元素
equals(Object o)	比较指定的对象与列表是否相等
size()	返回列表中的元素数
isEmpty()	如果列表不包含元素，则返回 true

这里我们需要注意的是：

1.empty和null

empty：容器存在，但是容器中没有元素了。

null：空，表示什么都没有。

2.remove和delete

remove：从容器中移出去，但是对象本身还在。

delete：删除对象。

3.size()方法返回的是元素的个数，不是数组的长度。

我们来测试一下List的一些常用方法：

public class Test0001 {
	public static void main(String[] args) {
		List list = new ArrayList();
		String str = new String("元素1");
		list.add(str);
		list.add(123);
		System.out.println("元素个数：" + list.size());
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		list.remove(str);
		System.out.println("=====================================");
		System.out.println(str);
		System.out.println("移除元素1之后的元素个数：" + list.size());
	}
}

结果如下：

我们可以看出，str只是从容器中移除，但是对象本身还是存在的。

主要需要了解的实现类有三个：ArrayList、LinkedList和Vector。

1.1.1 ArrayList

ArrayList是List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector类，除了此类是不同步的。）

ArrayList的底层实现是数组，在查询的时候是很快的，插入和删除效率较低。

这里我自己实现了一下它的add(Object obj)，get(int index)，remove(int index)方法，代码示例如下，其中remove方法，注释的一部分代码为Java源码的实现。

public class MyArrayList {

	private Object[] elementData;     //定义数组

	private int size;    //元素的个数

	public int size(){
		return size;
	}

	public MyArrayList(){
		this(3);  //源码默认数组长度为10，为了方便测试，这里默认为3
	}

	public MyArrayList(int initialCapacity){
		if (initialCapacity < 0){
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		elementData = new Object[initialCapacity];
	}

	//将指定的元素添加到此列表的尾部
	public void add(Object obj){
		//数组扩容，
		//数组长度定义之后是不可以改变的，所以这里是产生一个新的数组，将原来数据拷贝到新数组中，
		//表象是数组扩容
		if (size >= elementData.length){
			Object[] newArray = new Object[size*2 + 2];
			System.arraycopy(elementData, 0, newArray, 0, elementData.length);
			elementData = newArray;
		}
		elementData[size++] = obj;
	}

	//返回此列表中指定位置上的元素
	public Object get(int index){
		if (index < 0 || index >= size){
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return elementData[index];
	}

	//移除此列表中指定位置上的元素
	public void remove(int index){
		rangeCheck(index);
		for (int i = index; index < size; index++){
			Object temp = elementData[index];
			elementData[index++] = temp;
		}
		elementData[--size] = null;
		//java源码实现
		/*int numMoved = size - index - 1;
		if (numMoved > 0){
			System.arraycopy(elementData, index+1, elementData, index,
					numMoved);
		}
		elementData[--size] = null;*/
	}

	//检查传入的下标值是否合法
	public void rangeCheck(int index){
		if (index < 0 || index >= size){
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		MyArrayList list = new MyArrayList();
		list.add("1231");
		list.add("1232");
		list.add("1233");
		list.add("1234");
		list.add("1235789");
		System.out.println("元素个数为：" + list.size());
		System.out.println("获取某下标对应元素值：" + list.get(4));
		list.remove(0);
		System.out.println("剩余元素个数为：" + list.size());
	}
}

执行结果如下图：

我们可以看到，这三个方法已经实现。

1.1.2 LinkedList

LinkedList是List接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括null）。除了实现List接口外，LinkedList类还为在列表的开头及结尾get、remove和insert元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

LinkedList的用链表实现的，因此它的新增和删除的效率比较高，查询的效率比较低。

注意，此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用Collections.synchronizedList方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问。

这里我自己实现了一下它的add(int index, E element)，add(Object obj)，get(int index)，remove(int index)方法，代码示例如下。

public class Node {
	Node previous;   //上一个节点
	Object obj;
	Node next;        //下一个节点
	public Node() {
	}
	public Node(Node previous, Object obj, Node next) {
		super();
		this.previous = previous;
		this.obj = obj;
		this.next = next;
	}
	public Node getPrevious() {
		return previous;
	}
	public void setPrevious(Node previous) {
		this.previous = previous;
	}
	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;
	}
}

public class MyLinkedList {

	private Node first;
	private Node last;
	private int size;

	public int size(){
		return size;
	}

	//将指定元素添加到此列表的结尾
	public void add(Object obj){
		Node n = new Node();
		if(first==null){
			n.setPrevious(null);
			n.setObj(obj);
			n.setNext(null);
			first = n;
			last = n;
		}else{
			//直接往last节点后增加新的节点
			n.setPrevious(last);
			n.setObj(obj);
			n.setNext(null);
			last.setNext(n);
			last = n;
		}
		size++;
	}

	//检查传入的下标值是否合法
	private void rangeCheck(int index){
		if( index < 0 || index >= size){
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	//返回此列表中指定位置处的元素
	public Object get(int index){
		rangeCheck(index);
		Node temp = node(index);
		if(temp!=null){
			return temp.obj;
		}
		return null;
	}

	public Node node(int index){
		Node temp = null;
		if(first!=null){
			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.previous;
				}
			}

		}
		return temp;
	}

	//移除此列表中指定位置处的元素
	public void remove(int index){
		Node temp = node(index);
		if(temp != null){
			Node up = temp.previous;
			Node down = temp.next;
			up.next = down;
			down.previous = up;
			size--;
		}
	}

	//在此列表中指定的位置插入指定的元素
	public void add(int index,Object obj){
		Node temp = node(index);
		Node newNode = new Node();
		newNode.obj = obj;
		if(temp != null){
			Node up = temp.previous;
			up.next = newNode;
			newNode.previous = up;
			newNode.next = temp;
			temp.previous = newNode;
			size++;
		}
	}

	public static void main(String[] args) {
		MyLinkedList list = new MyLinkedList();
		list.add("aaa");
		list.add("bbb");
		System.out.println("元素个数为：" + list.size());
		list.add(1,"BBBB");
		System.out.println("插入后的元素个数：" + list.size() + "，插入的元素为" + list.get(1));
		list.remove(1);
		System.out.println("移除后的元素个数：" + list.size());
	}
}

结果如下：

从运行结果可以看出这几个方法都实现了。

1.1.3 Vector

Vector类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector的大小可以根据需要增大或缩小，以适应创建 Vector后进行添加或移除项的操作。

 

 

1.2 Set

Set是一个不包含重复元素的collection。更确切地讲，set不包含满足e1.equals(e2) 的元素对e1和e2，并且最多包含一个null元素。正如其名称所暗示的，此接口模仿了数学上的set抽象。

Set的主要方法：

add(E e)	如果 set 中尚未存在指定的元素，则添加此元素（可选操作）
contains(Object o)	如果 set 包含指定的元素，则返回 true
remove(Object o)	如果 set 中存在指定的元素，则将其移除（可选操作）
size()	返回 set 中的元素数（其容量）
hashCode()	返回 set 的哈希码值

因为Set中不允许出现重复的元素，所以添加两个相同的元素，第二个会覆盖第一个，这样仍然是一个元素，测试一下Set的主要方法：

public class TestSet {
	public static void main(String[] args) {
		Set set = new HashSet();
		set.add("aaa");
		set.add("bbb");
		set.add("ccc");
		System.out.println("元素个数为：" + set.size());
		set.add(new String("aaa"));
		System.out.println("元素个数为：" + set.size());
		System.out.println(set.contains("aaa"));
		set.remove("aaa");
		System.out.println("元素个数为：" + set.size());
	}
}

运行结果如下：

我们可以看到，添加相同的元素，Set元素个数不增加。

Set接口主要需要了解的实现类有两个：HashSet、TreeSet。

1.2.1 HashSet

HashSet实现Set接口，由哈希表（实际上是一个HashMap 例）支持。它不保证set的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用null元素。

HashSet的底层由HashMap支持，将HashMap的值对象设置为默认值，HashMap的键对象就作为set中的元素，我们知道，set中不可以包含重复的元素，set元素不可重复就是利用了map里面键对象的不可重复性。

HashSet的底层实现比较简单，这里只实现了它的add(E e)方法：

public class MyHashSet {

	HashMap map;
	private static final Object PRESENT = new Object();

	public MyHashSet(){
		map = new HashMap();
	}

	public int size(){
		return map.size();
	}

	public void add(Object o){
		map.put(o, PRESENT); 
	}

	public static void main(String[] args) {
		MyHashSet s = new MyHashSet();
		s.add("aaa");
		s.add(new String("aaa"));
		System.out.println(s.size());
	}
}

运行结果如下：

我们可以看到，添加两个相同元素，后添加的元素覆盖先前的元素，set的元素个数为1。

1.2.2 TreeSet

 

 

1.3 Queue

Queue是在处理元素前用于保存元素的collection。除了基本的Collection操作外，队列还提供其他的插入、提取和检查操作。每个方法都存在两种形式：一种抛出异常（操作失败时），另一种返回一个特殊值（null或false，具体取决于操作）。插入操作的后一种形式是用于专门为有容量限制的Queue 实现设计的；在大多数实现中，插入操作不会失败。

Queue常用的方法如下，这些方法都分为两类，一类方法在出错时抛出异常，一类方法在出错时返回特殊值（offer()返回false，pool()和peek()返回null。右面方法优于左面方法）：

	出错时抛出异常	出错时返回特殊值
插入	add(e)	offer(e)
移除	remove()	pool()
获取	element()	peek()

队列通常（但并非一定）以FIFO（First In First Out 先进先出）的方式排序各个元素。不过优先级队列和LIFO（Last In First Out 后进先出）队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者按LIFO（后进先出）的方式对元素进行排序。无论使用哪种排序方式，队列的头 都是调用remove()或pool()所移除的元素。在FIFO队列中，所有的新元素都插入队列的末尾。其他种类的队列可能使用不同的元素放置规则。每个Queue实现必须指定其顺序属性。

Queue的主要方法：

add(E e)	将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出IllegalStateException。
element()	获取，但是不移除此队列的头。
offer(E e)	将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于add(E)，后者可能无法插入元素，而只是抛出一个异常。
peek()	获取但不移除此队列的头；如果此队列为空，则返回null。
poll()	获取并移除此队列的头，如果此队列为空，则返回null。
remove()	获取并移除此队列的头。

扩展：

Queue是单向队列，Deque是一个线性collection，支持在两端插入和移除元素。名称deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数Deque实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

1.Deque扩展了Queue，在将双端队列用作队列时，将得到FIFO（先进后出）行为。

2.Deque可用作LIFO（后进先出）堆栈。

 

---------------------------源码实现暂留空白-----------------------------

 

2. Map

实现Map接口的类用来存储键（key）——值（value）对。Map中存储的键值对通过键来标识，所以键值不能重复。

Map接口提供三种collection视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序定义为迭代器在映射的collection视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如TreeMap类；另一些映射实现则不保证顺序，如HashMap类。

Map的主要方法：

containsKey(Object key)	如果此映射包含指定键的映射关系，则返回true。
containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回true。
equals(Object o)	比较指定的对象与此映射是否相等。
get(Object key)	返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。
hashCode()	返回此映射的哈希码值。
isEmpty()	如果此映射未包含键-值映射关系，则返回 true。
put(K key, V value)	将指定的值与此映射中的指定键关联（可选操作）。
size()	返回此映射中的键-值映射关系数。

我们来测试一下：

public class TestMap {
	public static void main(String[] args) {
		Map map = new HashMap();
		map.put("张三", new Wife("赵六"));
		map.put("张三", new Wife("孙七"));
		map.put("李四", new Wife("王五"));

		Wife w = (Wife) map.get("张三");
		System.out.println("张三的妻子名字为：" + w.name);
		System.out.println("元素个数为：" + map.size());
		map.remove("张三");
		System.out.println("移除张三后，是否包含键值为张三的元素：" + map.containsKey("张三"));
		System.out.println("张三的妻子名字为：" + w.name);
		System.out.println("元素个数为：" + map.size());
	}
}

class Wife {
	String name;
	public Wife(String name){
		this.name  = name;
	}
}

运行结果为：

可以看出，我们重复添加键值为“张三”的元素，value会被覆盖。我们将键值为“张三”的元素移除后，元素个数减少，但是初始化的数据仍然存在，并不会因为从容器中移除而被删除。

主要介绍一下HashMap、Hashtable、TreeMap。

2.1 HashMap

HashMap是基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用null值和null键。（除了非同步和允许使用null之外，HashMap类与Hashtable大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

注意，此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问。

HashMap的底层是以链表+数组的方式实现的。

有关哈希函数，可以参考以下文章（还没写）。

这里重写了一下HashMap的put和get方法，代码示例如下：

public class MyHashMap {

	LinkedList[]  arr  = new LinkedList[9]; //MyHashMap的底层结构就是：数组+链表
	int size;

	//put(K key, V value)方法
	public void put(Object key, Object value){
		MyEntry e = new MyEntry(key,value);
		int hash = key.hashCode();
		hash = hash < 0 ? - hash : hash;
		int a = hash % arr.length;
		if(arr[a]==null){
			LinkedList list = new LinkedList();
			arr[a] = list;
			list.add(e);
		}else{
			LinkedList list = arr[a];
			for(int i=0; i<list.size(); i++){
				MyEntry e2 = (MyEntry) list.get(i);
				if(e2.key.equals(key)){
					e2.value = value;  //键值重复直接覆盖
					return;
				}
			}
			arr[a].add(e);
		}
	}

	//get(Object key)方法
	public Object get(Object key){
		int a = key.hashCode()%arr.length;
		if(arr[a]!=null){
			LinkedList list = arr[a];
			for(int i=0;i<list.size();i++){
				MyEntry e = (MyEntry) list.get(i);
				if(e.key.equals(key)){
					return e.value;
				}
			}
		}
		return null;
	}

	public static void main(String[] args) {
		MyHashMap m = new MyHashMap();
		m.put("王小七", new Wife("张三"));
		m.put("王小七", new Wife("李四"));
		Wife w = (Wife) m.get("王小七");
		System.out.println(w.name);
	}

}

class  MyEntry {
	Object key;
	Object value;
	public MyEntry(Object key, Object value) {
		super();
		this.key = key;
		this.value = value;
	}
}

class Wife {
	String name;
	public Wife(String name){
		this.name  = name;
	}
}

测试结果如下：

根据输出结果我们可以看出，相同的key值，value值会被覆盖，根据key值我们可以获得value值。其余的方法没有实现，感兴趣的朋友们可以自己实现。

这里需要注意的是，JDK1.8中，HashMap是数组+链表+红黑树实现的（链表长度大于8时，转换为红黑树），这个也是JDK1.8的新特性之一。

2.2 Hashtable

 

 

2.3 TreeMap

 

 

 

emmmmmmmmmmmm。未完待续，不定时更新。