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

- 日理万妓 2022-05-19 03:46 251阅读 0赞

# 一、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 集合中的对象进行排序。

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

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 最多只能映射到一个值。

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

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李四