【Java】-NO.16.EBook.4.Java.1.008-【疯狂Java讲义第3版 李刚】- 集合/容器

1.0.0 Summary

Tittle：【Java】-NO.16.EBook.4.Java.1.008-【疯狂Java讲义第3版 李刚】- 集合

Style：EBook

Series：Java

Since：2017-09-22

End：....

Total Hours：...

Degree Of Diffculty：2

Degree Of Mastery：2

Practical Level：2

Desired Goal：2

Archieve Goal：....

Gerneral Evaluation：...

Writer:kingdelee

Related Links：

http://www.cnblogs.com/kingdelee/

1.

1.Iterator在迭代的过程中，不允许添加/删除对象，可以修改对象

2.想要在迭代中过滤/删除某个元素，使用Predicate

public class PredicateTest
{
    public static void main(String[] args)
	{
		// 创建一个集合
		Collection books = new HashSet();
		books.add(new String("轻量级Java EE企业应用实战"));
		books.add(new String("疯狂Java讲义"));
		books.add(new String("疯狂iOS讲义"));
		books.add(new String("疯狂Ajax讲义"));
		books.add(new String("疯狂Android讲义"));
		// 使用Lambda表达式（目标类型是Predicate）过滤集合
		books.removeIf(ele -> ((String)ele).length() < 10);
		System.out.println(books);
	}
}

　　

public class PredicateTest2
{
    public static void main(String[] args)
	{
		// 创建books集合、为books集合添加元素的代码与前一个程序相同。
		Collection books = new HashSet();
		books.add(new String("轻量级Java EE企业应用实战"));
		books.add(new String("疯狂Java讲义"));
		books.add(new String("疯狂iOS讲义"));
		books.add(new String("疯狂Ajax讲义"));
		books.add(new String("疯狂Android讲义"));
		// 统计书名包含“疯狂”子串的图书数量
		System.out.println(calAll(books , ele->((String)ele).contains("疯狂")));
		// 统计书名包含“Java”子串的图书数量
		System.out.println(calAll(books , ele->((String)ele).contains("Java")));
		// 统计书名字符串长度大于10的图书数量
		System.out.println(calAll(books , ele->((String)ele).length() > 10));
	}
	public static int calAll(Collection books , Predicate p)
	{
		int total = 0;
		for (Object obj : books)
		{
			// 使用Predicate的test()方法判断该对象是否满足Predicate指定的条件
			if (p.test(obj))
			{
				total ++;
			}
		}
		return total;
	}
}

3.Stream提供了常用的几个数据流的操作

public class IntStreamTest
{
    public static void main(String[] args)
	{
		IntStream is = IntStream.builder()
			.add(20)
			.add(13)
			.add(-2)
			.add(18)
			.build();
		// 下面调用聚集方法的代码每次只能执行一个
		System.out.println("is所有元素的最大值：" + is.max().getAsInt());
		System.out.println("is所有元素的最小值：" + is.min().getAsInt());
		System.out.println("is所有元素的总和：" + is.sum());
		System.out.println("is所有元素的总数：" + is.count());
		System.out.println("is所有元素的平均值：" + is.average());
		System.out.println("is所有元素的平方是否都大于20:"
			+ is.allMatch(ele -> ele * ele > 20));
		System.out.println("is是否包含任何元素的平方大于20:"
			+ is.anyMatch(ele -> ele * ele > 20));
		// 将is映射成一个新Stream，新Stream的每个元素是原Stream元素的2倍+1
		IntStream newIs = is.map(ele -> ele * 2 + 1);
		// 使用方法引用的方式来遍历集合元素
		newIs.forEach(System.out::println); // 输出41 27 -3 37
	}
}

中间方法：

filter(Predicate predicate)：

mapToXxxx(ToXxxFunction mapper)：一对一进行转换

peek(Consumer action)：

distinct():：

sorted():

limit(long maxSize)

末端方法：

forEach(Consumer action):

toArray():

min():

max():

count():

anyMatch(Predicate predicate)

findFirst()：

findAny();

public class CollectionStream
{
    public static void main(String[] args)
	{
		// 创建books集合、为books集合添加元素的代码与8.2.5小节的程序相同。
		Collection books = new HashSet();
		books.add(new String("轻量级Java EE企业应用实战"));
		books.add(new String("疯狂Java讲义"));
		books.add(new String("疯狂iOS讲义"));
		books.add(new String("疯狂Ajax讲义"));
		books.add(new String("疯狂Android讲义"));
		// 统计书名包含“疯狂”子串的图书数量
		System.out.println(books.stream().filter(ele->((String)ele).contains("疯狂")).count()); // 输出4
		// 统计书名包含“Java”子串的图书数量
		System.out.println(books.stream().filter(ele->((String)ele).contains("Java") ).count()); // 输出2
		// 统计书名字符串长度大于10的图书数量
		System.out.println(books.stream().filter(ele->((String)ele).length() > 10).count()); // 输出2
		// 先调用Collection对象的stream()方法将集合转换为Stream,
		// 再调用Stream的mapToInt()方法获取原有的Stream对应的IntStream
		books.stream().mapToInt(ele -> ((String)ele).length())// 调用forEach()方法遍历IntStream中每个元素
			.forEach(System.out::println);// 输出8  11  16  7  8

		List<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(3);
		list.add(3);
		list.add(2);
		list.add(4);
		list.add(4);
		list.add(5);
		list.add(5);
		list.add(5);
		System.out.println("--------1");
		list.stream().filter(f -> f == 3).forEach(System.out::println);
		System.out.println("--------2");
		list.stream().distinct().forEach(System.out::println);
		System.out.println("--------3");
		list.stream().sorted().forEach(System.out::println);
		System.out.println("--------4");
		System.out.println(list.stream().min((a, b) -> a - b).get());
		System.out.println("--------5");
		list.stream().limit(5).forEach(System.out::println);
		System.out.println(list.stream().count());
		System.out.println(list.stream().anyMatch(a -> a == 5));
		System.out.println(list.stream().findAny().get());
		System.out.println(list.stream().findAny().get());
		list.stream().mapToInt(a -> a*10).forEach(System.out::println);
		list.stream().map(a -> a * a).forEach(System.out::println);
//		list.stream().flatMap((a, b) -> a * b).forEach(System.out::println);

	}
}

　　

4. Set：

Set实际上就是Collection，只是不允许添加重复元素。

HashSet、TreeSet、EnumSet

4.1 HashSet：

Hash排序

非同步

可以存null

比较集合中的元素是否相等的充要条件是，对应的hashcode()与equals()都要相等

// 1.判断Set集合中两个对象相等的条件是，equals和hashcode都要一样。
// 类A的equals方法总是返回true，但没有重写其hashCode()方法
class A
{
    public boolean equals(Object obj)
	{
		return true;
	}
}
// 类B的hashCode()方法总是返回1，但没有重写其equals()方法
class B
{
	public int hashCode()
	{
		return 1;
	}
}
// 类C的hashCode()方法总是返回2，且重写其equals()方法总是返回true
class C
{
	public int hashCode()
	{
		return 2;
	}
	public boolean equals(Object obj)
	{
		return true;
	}
}
public class HashSetTest
{
	public static void main(String[] args)
	{
		HashSet books = new HashSet();
		// 分别向books集合中添加两个A对象，两个B对象，两个C对象
		books.add(new A());
		books.add(new A());
		books.add(new B());
		books.add(new B());
		books.add(new C());
		books.add(new C());
		books.forEach(System.out::println);
	}
}

//com.lee.test.java.ebook.crazy_java.u_8_container.c_8_3_set.B@1
//com.lee.test.java.ebook.crazy_java.u_8_container.c_8_3_set.B@1
//com.lee.test.java.ebook.crazy_java.u_8_container.c_8_3_set.A@610455d6
//com.lee.test.java.ebook.crazy_java.u_8_container.c_8_3_set.C@2
//com.lee.test.java.ebook.crazy_java.u_8_container.c_8_3_set.A@511d50c0

　　

// 1. HashSet查找/删除元素的时候，是根据hashcode去操作的，所以有规律的重写hashcode可以避免某个撞桶
class R
{
    int count;
    int count2;
	public R(int count)
	{
		this.count = count;
	}

	public R(int count, int count2) {
		this.count = count;
		this.count2 = count2;
	}

//	public String toString()
//	{
//		return "R[count:" + count + "]";
//	}

	@Override
	public String toString() {
		return "R{" +
				"count=" + count +
				", count2=" + count2 +
				'}';
	}

	public boolean equals(Object obj)
	{
		if(this == obj)
			return true;
		if (obj != null && obj.getClass() == R.class)
		{
			R r = (R)obj;
			return this.count == r.count;
		}
		return false;
	}
	public int hashCode()
	{
		return this.count;
	}
}
public class HashSetTest2
{
	public static void main(String[] args)
	{
		HashSet hs = new HashSet();
		hs.add(new R(5, 1));
		hs.add(new R(-3, 2));
		hs.add(new R(9, 3));
		hs.add(new R(-2, 4));
		// 打印HashSet集合，集合元素没有重复
		System.out.println(hs);
		// 取出第一个元素
		Iterator it = hs.iterator();
		R first = (R)it.next();
		// 为第一个元素的count实例变量赋值
		first.count = -3;     // ①
		// 再次输出HashSet集合，集合元素有重复元素
		System.out.println(hs);
		// 删除count为-3的R对象
		hs.remove(new R(-3));    // ②
		// 可以看到被删除了一个R元素
		System.out.println(hs);
		System.out.println("hs是否包含count为-3的R对象？"
			+ hs.contains(new R(-3))); // 输出false
		System.out.println("hs是否包含count为-2的R对象？"
			+ hs.contains(new R(-2))); // 输出false
		System.out.println("hs是否包含count为5的R对象？"
				+ hs.contains(new R(5))); // 输出false
	}
}

　　

6.LinkHashSet：

LinkHashSet是HashSet的子类，根据hashcode决定存储位置，并通过链表维护元素次序使得元素插入有序。故可以有序的迭代读取元素。

7.TreeSet：

TreeSet是SortedSet接口的实现类，采用红黑树结构存储。排序规则：自然排序、自定义排序。

应注意：

7.1 TreeSet中的对象，应该是同一类型或者父子关系，且实现了Comapble接口。

7.2 TreeSet中的对象，应实现Comaprable接口，否则再加入第二个元素时，因为排序会调用Comaprable所以会报错。

7.3 TreeSet判断是否为同一对象，取决于compareTo()是否返回0

class A1 implements Comparable{

	@Override
	public int compareTo(Object o) {
		return 0;
	}
}
class B1 extends A1{

}
public class TreeSetErrorTest2
{
    public static void main(String[] args)
	{
		TreeSet ts = new TreeSet();
		// 向TreeSet集合中添加两个对象
//		ts.add(new String("疯狂Java讲义"));
//		ts.add(new Date());   // ①
		ts.add(new A1());   // ①
		ts.add(new B1());   // ①
	}
}

　　

// 1. 当Set中的对象影响compareTo的元素被修改后，对该对象的删除和查找都将失效，而其他未被修改的对象正常。故不宜修改。
class R2 implements Comparable
{
    int count;
	public R2(int count)
	{
		this.count = count;
	}
	public String toString()
	{
		return "R[count:" + count + "]";
	}
	// 重写equals方法，根据count来判断是否相等
	public boolean equals(Object obj)
	{
		if (this == obj)
		{
			return true;
		}
		if(obj != null && obj.getClass() == R2.class)
		{
			R2 r = (R2)obj;
			return r.count == this.count;
		}
		return false;
	}
	// 重写compareTo方法，根据count来比较大小
	public int compareTo(Object obj)
	{
		R2 r = (R2)obj;
		return count > r.count ? 1 :
			count < r.count ? -1 : 0;
	}
}
public class TreeSetTest3
{
	public static void main(String[] args)
	{
		TreeSet ts = new TreeSet();
		ts.add(new R2(5));
		ts.add(new R2(-3));
		ts.add(new R2(9));
		ts.add(new R2(-2));
		// 打印TreeSet集合，集合元素是有序排列的
		System.out.println(ts);    // ①
		// 取出第一个元素
		R2 first = (R2)ts.first();
		// 对第一个元素的count赋值
		first.count = 20;
		// 取出最后一个元素
		R2 last = (R2)ts.last();
		// 对最后一个元素的count赋值，与第二个元素的count相同
		last.count = -2;
		// 再次输出将看到TreeSet里的元素处于无序状态，且有重复元素
		System.out.println(ts);   // ②
		// 删除实例变量被改变的元素，删除失败
		System.out.println(ts.remove(new R2(-2)));   // ③
		System.out.println(ts);
		// 删除实例变量没有被改变的元素，删除成功
		System.out.println(ts.remove(new R2(5)));    // ④
		System.out.println(ts);
	}
}

　　

// 1.定制排序
class M
{
    int age;
	public M(int age)
	{
		this.age = age;
	}
	public String toString()
	{
		return "M[age:" + age + "]";
	}
}
public class TreeSetTest4
{
	public static void main(String[] args)
	{
		// 此处Lambda表达式的目标类型是Comparator
		TreeSet ts = new TreeSet((o1 , o2) ->
		{
			M m1 = (M)o1;
			M m2 = (M)o2;
			// 根据M对象的age属性来决定大小，age越大，M对象反而越小
			return m1.age > m2.age ? -1
				: m1.age < m2.age ? 1 : 0;
		});
		ts.add(new M(5));
		ts.add(new M(-3));
		ts.add(new M(9));
		System.out.println(ts);
	}
}

　　

8.EmunSet

EmunSet

enum Season
{
    SPRING,SUMMER,FALL,WINTER
}
public class EnumSetTest
{
	public static void main(String[] args)
	{
		// 创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值
		EnumSet es1 = EnumSet.allOf(Season.class);
		System.out.println(es1); // 输出[SPRING,SUMMER,FALL,WINTER]
		// 创建一个EnumSet空集合，指定其集合元素是Season类的枚举值。
		EnumSet es2 = EnumSet.noneOf(Season.class);
		System.out.println(es2); // 输出[]
		// 手动添加两个元素
		es2.add(Season.WINTER);
		es2.add(Season.SPRING);
		es2.add(Season.SPRING);
		System.out.println(es2); // 输出[SPRING,WINTER]
		// 以指定枚举值创建EnumSet集合
		EnumSet es3 = EnumSet.of(Season.SUMMER , Season.WINTER);
		System.out.println(es3); // 输出[SUMMER,WINTER]
		EnumSet es4 = EnumSet.range(Season.SUMMER , Season.WINTER);
		System.out.println(es4); // 输出[SUMMER,FALL,WINTER]
		// 新创建的EnumSet集合的元素和es4集合的元素有相同类型，
		// es5的集合元素 + es4集合元素 = Season枚举类的全部枚举值
		EnumSet es5 = EnumSet.complementOf(es4);
		System.out.println(es5); // 输出[SPRING]
	}
}

　　

public class EnumSetTest2
{
    public static void main(String[] args)
	{
		Collection c = new HashSet();
		c.clear();
		c.add(Season.FALL);
		c.add(Season.SPRING);
		// 复制Collection集合中所有元素来创建EnumSet集合
		EnumSet enumSet = EnumSet.copyOf(c);   // ①
		System.out.println(enumSet); // 输出[SPRING,FALL]
		c.add("疯狂Java讲义");
		c.add("轻量级Java EE企业应用实战");
		// 下面代码出现异常：因为c集合里的元素不是全部都为枚举值
		enumSet = EnumSet.copyOf(c);  // ②
	}
}

　　

各种Set的实现类比较：

8.1.在add(), get()操作，性能 HashSet > TreeSet，理由TreeSet需要额外的红黑树来维持次序。

8.2.在add(), delete()操作，性能 HashSet > LinkedHashSet，遍历操作，性能 HashSet < LinkedHashSet，理由 LinkedHashSet有链表维护次序。

8.3,EnumSet是性能最好的，只能保存同一种枚举类的值作为集合元素。

8.4.HashSet，TreeSet，EnumSet都不是线程安全的，同步时应使用类似：

TreeSet<Object> objects = new TreeSet<>();
Collections.synchronizedNavigableSet(objects);

9. List

1.根据元素的equals判断List中两个元素是否相等，如果重写某元素equals=true，则该元素与集合中的任意一元素恒等。

// 1.根据元素的equals判断List中两个元素是否相等，如果重写某元素equals=true，则该元素与集合中的任意一元素恒等。
class A
{
    public boolean equals(Object obj)
	{
		return true;
	}
}
public class ListTest2
{
	public static void main(String[] args)
	{
		List books = new ArrayList();
		books.add(new String("轻量级Java EE企业应用实战"));
		books.add(new String("疯狂Java讲义"));
		books.add(new String("疯狂Android讲义"));
		System.out.println(books);
		// 删除集合中A对象，将导致第一个元素被删除
		books.remove(new A());     // ①
		System.out.println(books);
		// 删除集合中A对象，再次删除集合中第一个元素
		books.remove(new A());     // ②
		System.out.println(books);
	}
}
//[轻量级Java EE企业应用实战, 疯狂Java讲义, 疯狂Android讲义]
//[疯狂Java讲义, 疯狂Android讲义]
//[疯狂Android讲义]

　　

public class ListTest3
{
    public static void main(String[] args)
	{
		List books = new ArrayList();
		// 向books集合中添加4个元素
		books.add(new String("轻量级Java EE企业应用实战"));
		books.add(new String("疯狂Java讲义"));
		books.add(new String("疯狂Android讲义"));
		books.add(new String("疯狂iOS讲义"));
		// 使用目标类型为Comparator的Lambda表达式对List集合排序
		// [疯狂iOS讲义, 疯狂Java讲义, 疯狂Android讲义, 轻量级Java EE企业应用实战]
//		books.sort((o1, o2)->((String)o1).length() - ((String)o2).length());
		// [轻量级Java EE企业应用实战, 疯狂Android讲义, 疯狂Java讲义, 疯狂iOS讲义]
//		books.sort((o1, o2)->((String)o2).length() - ((String)o1).length());
		// [疯狂iOS讲义, 疯狂Java讲义, 疯狂Android讲义, 轻量级Java EE企业应用实战]
		books.sort(Comparator.comparing(String::length));
		System.out.println(books);
		// 使用目标类型为UnaryOperator的Lambda表达式来替换集合中所有元素
		// 该Lambda表达式控制使用每个字符串的长度作为新的集合元素
		books.replaceAll(ele->((String)ele).length());
		System.out.println(books); // 输出[7, 8, 11, 16]

	}
}

　　

Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

// 1.　Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
public class ListIteratorTest
{
    public static void main(String[] args)
	{

		String[] books = {
			"疯狂Java讲义", "疯狂iOS讲义",
			"轻量级Java EE企业应用实战"
		};
		List bookList = new ArrayList();
		for (int i = 0; i < books.length ; i++ )
		{
			bookList.add(books[i]);
		}

		ListIterator lit = bookList.listIterator();
		while (lit.hasNext())
		{
			System.out.println(lit.next());
			lit.add("-------分隔符-------");
		}
		System.out.println("=======下面开始反向迭代=======");
		while(lit.hasPrevious())
		{
			System.out.println(lit.previous());
		}
	}
}

　　

10. Vector Stack ArrayList ArrayDeque

10.1 Vector是线程安全的，ArrayList是线程不安全的，然而，要保证线程安全，只需使用Collections.synchronizedList()即可，故Vector没卵用。

10.2 Vector是古老的类，存在诸多缺点，性能低下，远不如ArrayList，所以Vector应不使用。

10.3 Stack是Vector的子类，模拟实现栈结构，然而远不如ArrayDeque，故Stack应不使用。

10.4 特别注意 Arrays.ArrayList返回的是一个固定长度的数组，是Arrays里边的一个静态内部类，不是util包的ArrayList，故不能使用add remove等方法。

11. Queue

11.1 队列不允许随机访问，使用的是FIFO（先进先出）策略操作存储。

11.2 Deque是双端队列的接口，可以使用实现类ArrayDeqeue LinkedList同时操作两端，ArrayDeqeue既是队列也是栈。

11.3 PriorityQueue，queue中的异端，采取元素的大小而非FIFO的策略进行存储。

对于ArrayDeque：

入栈：

push、addFirst ：加头，无返回，null会异常。

offerFirst：加头，有返回值，null会异常。调用addFirst。

add：加头，返回boolean，null会异常。

offer、offerLast：加尾，返回boolean，null会异常。

出栈：

pop、removeFirst：取头，删除。null会异常。

peek、peekFirst：取头，不删除。null返null。

peekLast：取尾，不删除。null返null

public class PriorityQueueTest
{
    public static void main(String[] args)
	{
		PriorityQueue pq = new PriorityQueue();
		// 下面代码依次向pq中加入四个元素
		pq.offer(6);
		pq.offer(-3);
		pq.offer(20);
		pq.offer(18);
		// 输出pq队列，并不是按元素的加入顺序排列
		System.out.println(pq); // 输出[-3, 6, 20, 18]
		// 访问队列第一个元素，其实就是队列中最小的元素：-3
		System.out.println(pq.poll());
	}
}

public class LinkedListTest
{
    public static void main(String[] args)
	{
		LinkedList books = new LinkedList();
		// 将字符串元素加入队列的尾部
		books.offer("疯狂Java讲义");
		// 将一个字符串元素加入栈的顶部
		books.push("轻量级Java EE企业应用实战");
		// 将字符串元素添加到队列的头部（相当于栈的顶部）
		books.offerFirst("疯狂Android讲义");
		// 以List的方式（按索引访问的方式）来遍历集合元素
		for (int i = 0; i < books.size() ; i++ )
		{
			System.out.println("遍历中：" + books.get(i));
		}
		// 访问、并不删除栈顶的元素
		System.out.println(books.peekFirst());
		// 访问、并不删除队列的最后一个元素
		System.out.println(books.peekLast());
		// 将栈顶的元素弹出“栈”
		System.out.println(books.pop());
		// 下面输出将看到队列中第一个元素被删除
		System.out.println(books);
		// 访问、并删除队列的最后一个元素
		System.out.println(books.pollLast());
		// 下面输出：[轻量级Java EE企业应用实战]
		System.out.println(books);
	}
}

public class ArrayDequeStack
{
    public static void main(String[] args)
	{
		ArrayDeque stack = new ArrayDeque();
		// 依次将三个元素push入"栈"
		stack.push("1");
//		stack.push("3");
//		stack.push("4");
//		stack.push("2");
//		stack.push("5");

		// add与Off是一样的方法
		stack.addFirst("8");
		stack.offer("8");
		stack.add("8");
		stack.addFirst("8");
		stack.addLast("8");
		stack.offer("8");

		//
		System.out.println(stack);
		System.out.println(stack.peekLast());
		System.out.println(stack.pop());
		System.out.println(stack.peekLast());
		System.out.println(stack);
	}
}

public class ArrayDequeQueue
{
    public static void main(String[] args)
	{
		ArrayDeque queue = new ArrayDeque();
		// 依次将三个元素加入队列
		queue.offer("疯狂Java讲义");
		queue.offer("轻量级Java EE企业应用实战");
		queue.offer("疯狂Android讲义");
		// 输出：[疯狂Java讲义, 轻量级Java EE企业应用实战, 疯狂Android讲义]
		System.out.println(queue);
		// 访问队列头部的元素，但并不将其poll出队列"栈"，输出：疯狂Java讲义
		System.out.println(queue.peek());
		// 依然输出：[疯狂Java讲义, 轻量级Java EE企业应用实战, 疯狂Android讲义]
		System.out.println(queue);
		// poll出第一个元素，输出：疯狂Java讲义
		System.out.println(queue.poll());
		// 输出：[轻量级Java EE企业应用实战, 疯狂Android讲义]
		System.out.println(queue);
	}
}

　　

12. ArrayList LinkedList

ArrayList 基于数组的线性表，以一块连续内存区保存所有元素，具有较好的随机访问效率。遍历使用get获取元素。

LinkedList 基于链表的线性表，在插入、删除元素时具有较好效率。遍历时使用Iterator。

13.Map

13.1 HashMap Hashtable

Hashtable与Vector一样都是过时的玩意，同步也没卵用，用 Collections.synchronizedMap() 就能够使HashMap具备同步效果。

class A
{
    int count;
	public A(int count)
	{
		this.count = count;
	}
	// 根据count的值来判断两个对象是否相等。
	public boolean equals(Object obj)
	{
		if (obj == this)
			return true;
		if (obj != null && obj.getClass() == A.class)
		{
			A a = (A)obj;
			return this.count == a.count;
		}
		return false;
	}
	// 根据count来计算hashCode值。
	public int hashCode()
	{
		return this.count;
	}
}
class B
{
	// 重写equals()方法，B对象与任何对象通过equals()方法比较都返回true
	public boolean equals(Object obj)
	{
		return true;
	}
}
public class HashtableTest
{
	public static void main(String[] args)
	{
		Hashtable ht = new Hashtable();
		ht.put(new A(60000) , "疯狂Java讲义");
		ht.put(new A(87563) , "轻量级Java EE企业应用实战");
		ht.put(new A(1232) , new B());
		System.out.println(ht);
		// 只要两个对象通过equals比较返回true，
		// Hashtable就认为它们是相等的value。
		// 由于Hashtable中有一个B对象，
		// 它与任何对象通过equals比较都相等，所以下面输出true。
		System.out.println(ht.containsValue("测试字符串")); // ① 输出true
		// 只要两个A对象的count相等，它们通过equals比较返回true，且hashCode相等
		// Hashtable即认为它们是相同的key，所以下面输出true。
		System.out.println(ht.containsKey(new A(87563)));   // ② 输出true
		// 下面语句可以删除最后一个key-value对
		ht.remove(new A(1232));    //③
		System.out.println(ht);
	}
}

　　

// 1.当用于equals判断的值被修改时，该元素就无法被操作
public class HashMapErrorTest
{
    public static void main(String[] args)
	{
		HashMap ht = new HashMap();
		// 此处的A类与前一个程序的A类是同一个类
		ht.put(new A(60000) , "疯狂Java讲义");
		ht.put(new A(87563) , "轻量级Java EE企业应用实战");
		System.out.println("--------------1：" + ht);
		// 获得Hashtable的key Set集合对应的Iterator迭代器
		Iterator it = ht.keySet().iterator();
		// 取出Map中第一个key，并修改它的count值
		A first = (A)it.next();
		first.count = 87563;   // ①
		// 输出{A@1560b=疯狂Java讲义, A@1560b=轻量级Java EE企业应用实战}
		System.out.println("--------------2：" + ht);
		// 只能删除没有被修改过的key所对应的key-value对
		ht.remove(new A(87563));

		System.out.println("--------------3：" + ht);
		// 无法获取剩下的value，下面两行代码都将输出null。
		System.out.println(ht.get(new A(87563)));   // ② 输出null
		System.out.println(ht.get(new A(60000)));   // ③ 输出null
	}
}
//--------------1：{com.lee.test.java.ebook.crazy_java.u_8_container.c_8_6_map.A@ea60=疯狂Java讲义, com.lee.test.java.ebook.crazy_java.u_8_container.c_8_6_map.A@1560b=轻量级Java EE企业应用实战}
//--------------2：{com.lee.test.java.ebook.crazy_java.u_8_container.c_8_6_map.A@1560b=疯狂Java讲义, com.lee.test.java.ebook.crazy_java.u_8_container.c_8_6_map.A@1560b=轻量级Java EE企业应用实战}
//--------------3：{com.lee.test.java.ebook.crazy_java.u_8_container.c_8_6_map.A@1560b=疯狂Java讲义}
//null
//null

　　

13.2 LinkedHashMap

13.2.1 LinkedHashMap 是 HashMap的子类，如同LinkedHashSet是HashSet的子类一样，用双向链表维护key-value的顺序，使得迭代的顺序与插入的顺序是一致的。

13.2.2 LinkedHashMap 不用像HashMap一样靠hash控制key-value顺序，同时有避免TreeMap增加的成本，因为要维护插入顺序，故插入速度低于HashMap，但迭代速度要优于HashMap

public class LinkedHashMapTest
{
    public static void main(String[] args)
	{
		LinkedHashMap scores = new LinkedHashMap();
		scores.put("语文" , 80);
		scores.put("英文" , 82);
		scores.put("数学" , 76);
		// 调用forEach方法遍历scores里的所有key-value对
		scores.forEach((key, value) -> System.out.println(key + "-->" + value));
	}
}

　　

14. Properties

Properties是Hashtable的子类

public class PropertiesTest
{
    public static void main(String[] args)
		throws Exception
	{
		Properties props = new Properties();
		// 向Properties中增加属性
		props.setProperty("username" , "yeeku");
		props.setProperty("password" , "123456");
		// 将Properties中的key-value对保存到a.ini文件中
		props.store(new FileOutputStream("a.ini")
			, "comment line");   //①
		// 新建一个Properties对象
		Properties props2 = new Properties();
		// 向Properties中增加属性
		props2.setProperty("gender" , "male");
		// 将a.ini文件中的key-value对追加到props2中
		props2.load(new FileInputStream("a.ini") );   //②
		System.out.println(props2);
	}
}

　　

15.SortedMap

SortedMap是Map的子类接口，TreeMap是接口SortedMap的实现类，与TreeSet的SortedSet关系一样，红黑树结构控制存储。

1.定制排序，传入Comparator的实现类实现compare(a,b)的方法

 2.自然排序，让TreeMap中的key元素对象实现Comparable的compareTo(O o)方法

class R implements Comparable
{
    int count;
	public R(int count)
	{
		this.count = count;
	}
	public String toString()
	{
		return "R[count:" + count + "]";
	}
	// 根据count来判断两个对象是否相等。
	public boolean equals(Object obj)
	{
		if (this == obj)
			return true;
		if (obj != null	&& obj.getClass() == R.class)
		{
			R r = (R)obj;
			return r.count == this.count;
		}
		return false;
	}
	// 根据count属性值来判断两个对象的大小。
	public int compareTo(Object obj)
	{
		R r = (R)obj;
		return count > r.count ? 1 :
			count < r.count ? -1 : 0;
	}
}
// 1.定制排序，传入Comparator的实现类实现compare(a,b)的方法
// 2.自然排序，让TreeMap中的key元素对象实现Comparable的compareTo(O o)方法
public class TreeMapTest
{
	public static void main(String[] args)
	{
		TreeMap tm = new TreeMap((a, b) -> (int)b - (int)a);
		tm.put(new R(3) , "轻量级Java EE企业应用实战");
		tm.put(new R(-5) , "疯狂Java讲义");
		tm.put(new R(9) , "疯狂Android讲义");
		System.out.println(tm);
		// 返回该TreeMap的第一个Entry对象
		System.out.println(tm.firstEntry());
		// 返回该TreeMap的最后一个key值
		System.out.println(tm.lastKey());
		// 返回该TreeMap的比new R(2)大的最小key值。
		System.out.println(tm.higherKey(new R(2)));
		// 返回该TreeMap的比new R(2)小的最大的key-value对。
		System.out.println(tm.lowerEntry(new R(2)));
		// 返回该TreeMap的子TreeMap
		System.out.println(tm.subMap(new R(-1) , new R(4)));
	}
}

　　

16.WeakHashMap

与HsahMap的区别在于，HashMap里边对key的存储是强引用，而WeakHashMap是弱引用。即进行GC后，WeakHashMap里边的key因为不是强引用，而有可能会回收。缓冲区的除外。

// 1.new String()只保留了弱引用，而""是字符串缓冲区的，不会被GC。
public class WeakHashMapTest
{
    public static void main(String[] args)
	{
		WeakHashMap whm = new WeakHashMap();
		// 将WeakHashMap中添加三个key-value对，
		// 三个key都是匿名字符串对象（没有其他引用）
		whm.put(new String("语文") , new String("良好"));
		whm.put(new String("数学") , new String("及格"));
		whm.put(new String("英文") , new String("中等"));
		//将 WeakHashMap中添加一个key-value对，
		// 该key是一个系统缓存的字符串对象。
		whm.put("java" , new String("中等"));    // ①
		// 输出whm对象，将看到4个key-value对。
		System.out.println(whm);
		// 通知系统立即进行垃圾回收
		System.gc();
		System.runFinalization();
		// 通常情况下，将只看到一个key-value对。
		System.out.println(whm);
	}
}
//{英文=中等, java=中等, 数学=及格, 语文=良好}
//{java=中等}

　　

17.IdentityHashMap

IdentityHashMap 判断相等需要key1 == key2 严格相等才可以，而HashMap只需要key1和key2通过equals比较相等且hashcode相等。

public class IdentityHashMapTest
{
    public static void main(String[] args)
	{
		IdentityHashMap ihm = new IdentityHashMap();
		// 下面两行代码将会向IdentityHashMap对象中添加两个key-value对
		ihm.put(new String("语文") , 89);
		ihm.put(new String("语文") , 78);
		// 下面两行代码只会向IdentityHashMap对象中添加一个key-value对
		ihm.put("java" , 93);
		ihm.put("java" , 98);
		System.out.println(ihm);
	}
}
//{语文=78, java=98, 语文=89}

　　

18.EnumMap

Enum内部以数组实现，所以非常高效

enum Season
{
    SPRING,SUMMER,FALL,WINTER
}
public class EnumMapTest
{
	public static void main(String[] args)
	{
		// 创建EnumMap对象，该EnumMap的所有key都是Season枚举类的枚举值
		EnumMap enumMap = new EnumMap(Season.class);
		enumMap.put(Season.SUMMER , "夏日炎炎");
		enumMap.put(Season.SPRING , "春暖花开");
		System.out.println(enumMap);
	}
}

　　

桶概念：

HashMap和HashSet通过hash算法存储key元素，而这个key有可能会有重复的情况，所以用了一个集合桶去装这些重复的hash值的元素。相同的桶里边的元素之间是通过链表实现的，必须按顺序存储，故桶内的查找效率就会低了。