Java核心(集合类2-Set 集合、Map 集合）

一、Set 集合

Set 集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，但 Set 集合中不能包含重复对象。Set 集合由 Set 接口和 Set 接口的实现类组成。 Set 接口继承了 Collection 接口，因此包含 Collection 接口的所有方法。

ps ：Set 的构造由一个约束条件，传入的 Colletion 对象不能有重复值，必须小心操作可变对象（Mutable Object）。如果一个 Set 中的可变元素改变了自身状态导致 Object.equals(Object)=true ，则会出现一些问题。

Set 接口常用的实现类有  HashSet 类与 TreeSet 类。

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

( 2 ) ：TreeSet 类不仅实现了 Set 接口，还实现了 java.util.SortedSet 接口，因此，TreeSet 类实现的 Set 集合在遍历集合时按照自然顺序递增排序，也可以按照指定比较器递增排序，既可以通过比较器对用 TreeSet 类实现的 Set 集合中的对象进行排序。

表 1.1 TreeSet 类增加的方法

方法	功能描述
first()	返回此 Set 中当前第一个（最低）元素
last()	返回此 Set 中当前最后一个（最高）元素
comparator()	返回对此 Set 中的元素进行排序的比较器。如果此 Set 使用自然顺序，则返回 null
headSet(E toElement)	返回一个新的 Set 集合，新集合包含 toElement （不包含）之前的所有对象
subSet(E fromElement , EfromElement)	返回一个新的 Set 集合，包含 fromElement（包含）对象与 fromElement（不包含）对象之间的所有对象
tailSet(E fromElement)	返回一个新的 Set 集合，心机和包含对象 fromElement（包含）之后的所有对象

eg 1.1 在项目中创建类 UpdateStu ，实现 Comparable 接口，重写该接口中的 compareTo() 方法。在主方法中创建 UpdateStu 对象，创建集合，并将 UpdateStu 对象添加到集合中。遍历该集合中的全部元素，以及通过 headSet()、subSet() 方法获取的部分集合。

package com.CollectionDemo;

import java.util.Iterator;
import java.util.TreeSet;

public class UpdateStu implements Comparable<Object> {// 创建类实现 Comparable接口
	String name;
	long id;

	public UpdateStu(String name, long id) {
		this.id = id;
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	@Override
	public int compareTo(Object o) {
		UpdateStu uStu = (UpdateStu) o;
		int result = id > uStu.id ? 1 : (id == uStu.id ? 0 : -1);
		return result;
	}

	public static void main(String[] args) {
		// 创建 UpdateStu 对象
		UpdateStu stu1 = new UpdateStu("李同学", 01011);
		UpdateStu stu2 = new UpdateStu("陈同学", 01021);
		UpdateStu stu3 = new UpdateStu("王同学", 01031);
		UpdateStu stu4 = new UpdateStu("林同学", 01041);
		//集合添加对象
		TreeSet<UpdateStu> treeSet = new TreeSet<>();
		treeSet.add(stu1);
		treeSet.add(stu2);
		treeSet.add(stu3);
		treeSet.add(stu4);
		// Set 集合中的所有对象的迭代器
		Iterator<UpdateStu> iterator = treeSet.iterator();
		System.out.println("Set 集合中的所有元素:");
		while (iterator.hasNext()) {// 遍历集合
			UpdateStu stu = (UpdateStu) iterator.next();
			System.out.println(stu.getId() + "" + stu.getName());
		}
		// 截取排在 stu2 对象之前的对象
		iterator = treeSet.headSet(stu2).iterator();
		System.out.println("截取前面部分的集合:");
		while (iterator.hasNext()) {
			UpdateStu stu = (UpdateStu) iterator.next();
			System.out.println(stu.getId() + "" + stu.getName());
		}
		// 截取排在 stu2 与 stu3 之前的对象
		iterator = treeSet.subSet(stu2, stu3).iterator();
		System.out.println("截取中间部分的集合:");
		while (iterator.hasNext()) {
			UpdateStu stu = (UpdateStu) iterator.next();
			System.out.println(stu.getId() + "" + stu.getName());
		}
	}
}

运行结果为 ：

Set 集合中的所有元素:
521李同学
529陈同学
537王同学
545林同学
截取前面部分的集合:
521李同学
截取中间部分的集合:
529陈同学

存入 TreeSet 类实现的 Set 集合必须实现 Comparable 接口，该接口中的 compareTo(Object o) 方法比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、0 或正整数。

ps : headSet() 、subSet() 、tailSet() 方法截取对象生成新集合时是否包含指定的参数，可通过如下方法来判别：如果指定参数位于新集合的起始位置，则包含该对象，如 subSet() 方法的第一个参数和 tailSet() 方法的参数；如果指定参数时新集合的终止位置，则不包含该参数，如 headSet() 方法的入口参数和 subSet() 方法的第一个入口参数。

二、Map 集合

Map 集合没有 Collection接口，其提供的是 key 到 value 的映射。Map 中不能包含相同的 key ，每个 key 只能映射一个 value 。key 还决定了存储对象在映射中的存储位置，但不是由 key 对象本身决定的，而是通过一个 ” 散列技术 ” 进行处理，产生一个散列码的整数值，散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置。 Map 集合包括 Map 接口以及 Map 接口的所有实现类。

2.1 Map 接口

Map 接口提供了将 key 映射到值的对象。一个映射不能包含重复的 key ，每个 key 最多只能映射到一个值。

表 2.1 Map 接口中的常用方法

方法	功能描述
put(K key , V value)	向集合中添加指定的 key 与 value 的映射关系
containsKey(Object key)	如果此映射包含指定 key 的映射关系，则返回 true
containsValue（Object value）	如果此映射将一个或多个 key 映射到指定值，则返回 true
get（Object key）	如果存在指定的 key 对象，则返回该对象对应的值，否则返回 null
keySet()	返回该集合中的所有 key 对象形成的 Set 集合
values()	返回该集合中所有值对象形成的 Collection 集合

eg 2.1 在项目中创建类 UpdateStuMap ,在主方法中创建 Map 集合，并获取 Map 集合中的所有 key 对象集合和所有 values() 值集合，最后遍历集合。

package com.CollectionDemo;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class UpdateStuMap {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();// 创建 Map 实例
		// 向集合中添加元素
		map.put("01", "李同学");
		map.put("02", "魏同学");
		// 构建 Map 集合中所有 key 对象的集合
		Set<String> set = map.keySet();
		// 创建集合迭代器
		Iterator<String> iterator = set.iterator();
		System.out.println("key 集合中的元素");
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		// 构建 Map 集合中所有 values 对象的集合
		Collection<String> collection = map.values();
		iterator = collection.iterator();
		System.out.println("values 集合中的元素");
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

运行结果为：

key 集合中的元素
01
02
values 集合中的元素
李同学
魏同学

ps ：Map 集合中允许值对象是  null ，而且没有个数限制，例如，可通过 map.put("05",null); 语句向集合中添加对象。

2.2 Map 接口的实现类

Map 接口常用的实现类由 HashMap 和 TreeMap 。建议使用 HashMap 类实现 Map 集合，因为由  HashMap 类实现的 Map 集合添加和删除映射关系效率更高。HashMap 是基于哈希表的 Map 接口的实现，HashMap 通过哈希表码对其内部的映射关系进行快速查找；而 TreeMap 中的映射关系存在一定的顺序，如果希望 Map 集合中的对象也存在一定的顺序，应该使用 TreeMap 类实现 Map 集合。

( 1 ) ：HashMap 类是基于哈希表的 Map 的接口实现，此实现提供所有可选的映射操作，并允许使用 null 值和 null 键，但必须保证键的唯一性。 HashMap 通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

( 2 ) ：TreeMap 类不仅实现了 Map 接口，还实现了 java.util.SortedMap 接口，因此，集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系时， TreeMap 类比 HashMap 类性能稍差。由于 TreeMap 类实现的 Map集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是 null 。

可以通过 HashMap 类创建 Map 集合，当需要顺序输出时，在创建一个完成相同映射关系的 TreeMap 类实例。

eg 2.2 通过 HashMap 类实例化 Map 集合，并遍历该 Map 集合，然后创建 TreeMap 实例实现将集合中的元素顺序输出。

（1）首先创建 Emp 类。

package com.CollectionDemo;

public class Emp {
	private String e_id;
	private String e_name;

	public String getE_id() {
		return e_id;
	}

	public void setE_id(String e_id) {
		this.e_id = e_id;
	}

	public String getE_name() {
		return e_name;
	}

	public void setE_name(String e_name) {
		this.e_name = e_name;
	}

	public Emp(String e_id, String e_name) {
		this.e_id = e_id;
		this.e_name = e_name;
	}
}

（2）创建一个用于测试的主类。首先新建一个 Map 集合，并添加集合对象。分别遍历由 HashMap 类与 TreeMap 类实现的 Map 集合，观察两者的不同点。

package com.CollectionDemo;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapTest {

	public static void main(String[] args) {
		// 由 HashMap实现的 Map 对象
		Map<String, String> map = new HashMap<>();
		// 创建 EMP 对象
		Emp emp1 = new Emp("001", "张三");
		Emp emp2 = new Emp("005", "李四");
		Emp emp3 = new Emp("003", "王五");
		// 将对象添加到集合中
		map.put(emp1.getE_id(), emp1.getE_name());
		map.put(emp2.getE_id(), emp2.getE_name());
		map.put(emp3.getE_id(), emp3.getE_name());
		// 获取 Map 集合中的 key 对象的集合
		Set<String> set = map.keySet();
		Iterator<String> iterator = set.iterator();
		System.out.println("HashMap 类实现的 Map 集合，无序:");
		while (iterator.hasNext()) {
			String str = (String) iterator.next();
			String name = (String) map.get(str);
			System.out.println(str + "" + name);
		}
		// 由 TreeMap实现的 Map 对象
		TreeMap<String, String> treeMap = new TreeMap<>();
		// 将对象添加到集合中
		treeMap.putAll(map);
		Iterator<String> iterator2 = treeMap.keySet().iterator();
		System.out.println("TreeMap 类实现的 Map 集合，键对象升序:");
		while (iterator2.hasNext()) {
			String str = (String) iterator2.next();
			String name = (String) treeMap.get(str);
			System.out.println(str + "" + name);
		}
	}
}

运行结果为 ：

HashMap 类实现的 Map 集合，无序:
001张三
003王五
005李四
TreeMap 类实现的 Map 集合，键对象升序:
001张三
003王五
005李四