Modifier and Type 方法描述
void clear()
从该地图中删除所有的映射（可选操作）。

default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
尝试计算指定键的映射及其当前映射值（如果没有当前映射，则 null ）。

default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
如果指定的键尚未与值相关联（或映射到 null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非是 null 。

default V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。

boolean containsKey(Object key)
如果此映射包含指定键的映射，则返回 true 。

boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定的值，则返回 true 。

static <K,V> Map.Entry<K,V> entry(K k, V v)
返回包含给定键和值的不可变Map.Entry 。

Set<Map.Entry<K,V>> entrySet()
返回此地图中包含的映射的Set视图。

boolean equals(Object o)
将指定的对象与此映射进行比较以获得相等性。

default void forEach(BiConsumer<? super K,? super V> action)
对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。

V get(Object key)
返回指定键映射到的值，如果此映射不包含该键的映射，则返回 null 。

default V getOrDefault(Object key, V defaultValue)
返回指定键映射到的值，如果此映射不包含该键的映射，则返回 defaultValue 。

int hashCode()
返回此地图的哈希码值。

boolean isEmpty()
如果此映射不包含键值映射，则返回 true 。

Set<K> keySet()
返回此地图中包含的键的Set视图。

default V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。

static <K,V> Map<K,V> of()
返回一个包含零映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1)
返回包含单个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2)
返回包含两个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3)
返回包含三个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)
返回包含四个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)
返回一个包含五个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)
返回包含六个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)
返回包含七个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)
返回包含八个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)
返回包含九个映射的不可变地图。

static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)
返回包含十个映射的不可变地图。

static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K,? extends V>... entries)
返回包含从给定条目提取的键和值的不可变地图。

V put(K key, V value)
将指定的值与该映射中的指定键相关联（可选操作）。

void putAll(Map<? extends K,? extends V> m)
将指定地图的所有映射复制到此映射（可选操作）。

default V putIfAbsent(K key, V value)
如果指定的键尚未与值相关联（或映射到 null ）将其与给定值相关联并返回 null ，否则返回当前值。

V remove(Object key)
如果存在（从可选的操作），从该地图中删除一个键的映射。

default boolean remove(Object key, Object value)
仅当指定的密钥当前映射到指定的值时删除该条目。

default V replace(K key, V value)
只有当目标映射到某个值时，才能替换指定键的条目。

default boolean replace(K key, V oldValue, V newValue)
仅当当前映射到指定的值时，才能替换指定键的条目。

default void replaceAll(BiFunction<? super K,? super V,? extends V> function)
将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。

int size()
返回此地图中键值映射的数量。

Collection<V> values()
返回此地图中包含的值的Collection视图。

Modifier and Type	方法	描述
`void`	`clear()`	从该地图中删除所有的映射（可选操作）。
`default V`	`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`	尝试计算指定键的映射及其当前映射值（如果没有当前映射，则 `null` ）。
`default V`	`computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)`	如果指定的键尚未与值相关联（或映射到 `null` ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非是 `null` 。
`default V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`	如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。
`boolean`	`containsKey(Object key)`	如果此映射包含指定键的映射，则返回 `true` 。
`boolean`	`containsValue(Object value)`	如果此映射将一个或多个键映射到指定的值，则返回 `true` 。
`static <K,V> Map.Entry<K,V>`	`entry(K k, V v)`	返回包含给定键和值的不可变Map.Entry 。
`Set<Map.Entry<K,V>>`	`entrySet()`	返回此地图中包含的映射的Set视图。
`boolean`	`equals(Object o)`	将指定的对象与此映射进行比较以获得相等性。
`default void`	`forEach(BiConsumer<? super K,? super V> action)`	对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
`V`	`get(Object key)`	返回指定键映射到的值，如果此映射不包含该键的映射，则返回 `null` 。
`default V`	`getOrDefault(Object key, V defaultValue)`	返回指定键映射到的值，如果此映射不包含该键的映射，则返回 `defaultValue` 。
`int`	`hashCode()`	返回此地图的哈希码值。
`boolean`	`isEmpty()`	如果此映射不包含键值映射，则返回 `true` 。
`Set<K>`	`keySet()`	返回此地图中包含的键的Set视图。
`default V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)`	如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。
`static <K,V> Map<K,V>`	`of()`	返回一个包含零映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1)`	返回包含单个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2)`	返回包含两个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2, K k3, V v3)`	返回包含三个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)`	返回包含四个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)`	返回一个包含五个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)`	返回包含六个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)`	返回包含七个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)`	返回包含八个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)`	返回包含九个映射的不可变地图。
`static <K,V> Map<K,V>`	`of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)`	返回包含十个映射的不可变地图。
`static <K,V> Map<K,V>`	`ofEntries(Map.Entry<? extends K,? extends V>... entries)`	返回包含从给定条目提取的键和值的不可变地图。
`V`	`put(K key, V value)`	将指定的值与该映射中的指定键相关联（可选操作）。
`void`	`putAll(Map<? extends K,? extends V> m)`	将指定地图的所有映射复制到此映射（可选操作）。
`default V`	`putIfAbsent(K key, V value)`	如果指定的键尚未与值相关联（或映射到 `null` ）将其与给定值相关联并返回 `null` ，否则返回当前值。
`V`	`remove(Object key)`	如果存在（从可选的操作），从该地图中删除一个键的映射。
`default boolean`	`remove(Object key, Object value)`	仅当指定的密钥当前映射到指定的值时删除该条目。
`default V`	`replace(K key, V value)`	只有当目标映射到某个值时，才能替换指定键的条目。
`default boolean`	`replace(K key, V oldValue, V newValue)`	仅当当前映射到指定的值时，才能替换指定键的条目。
`default void`	`replaceAll(BiFunction<? super K,? super V,? extends V> function)`	将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
`int`	`size()`	返回此地图中键值映射的数量。
`Collection<V>`	`values()`	返回此地图中包含的值的Collection视图。

6、Map注意事项：

Map接口提供了三个集合视图 ，允许将映射的内容视为一组键，值的集合或键值映射集合。地图的顺序被定义为其中在地图上的集合视图迭代返回元素的顺序。一些地图实现，如TreeMap类，对其顺序做出特定的保证; 其他人，像HashMap类，不要。

注意：如果使用可变对象作为地图键，必须非常小心。如果对象的值以影响equals比较的方式更改，而对象是地图中的键，则不会指定映射的行为。这个禁令的一个特殊情况是，地图不允许将自己包含在内。虽然地图可以将其本身作为一个值，但建议您非常小心： equals和hashCode方法在这样的地图上已经不太明确。

所有通用映射实现类应提供两个“标准”构造函数：一个创建空映射的void（无参数）构造函数和一个具有类型为Map的单个参数的构造函数，它创建一个具有相同键值的新映射映射作为参数。实际上，后一个构造函数允许用户复制任何地图，产生所需类的等效地图。没有办法强制执行此建议（因为接口不能包含构造函数），而JDK中的所有通用映射实现都符合要求。

如果此映射不支持此操作，则此接口中包含的“破坏性”方法（即修改其操作的映射的方法）将被指定为抛出UnsupportedOperationException 。如果是这种情况，如果调用对地图没有影响，这些方法可能可以但不是必须抛出UnsupportedOperationException 。例如，在不可修改的地图上调用putAll(Map)方法可能会将其映射为“叠加”的地图空白时，但不是必须抛出异常。

一些地图实现对它们可能包含的键和值有限制。例如，一些实现禁止空键和值，有些对键的类型有限制。尝试插入不合格的键或值会引发未经检查的异常，通常为NullPointerException或ClassCastException 。尝试查询不合格键或值的存在可能会引发异常，或者可能只是返回false; 一些实现将展现出前者的行为，一些实现将展现出后者。更一般来说，尝试对不符合条件的密钥或值的操作，其完成不会导致将不合格元素插入到地图中可能会导致异常或可能成功执行该选项。此异常在此接口的规范中标记为“可选”。

Collections Framework接口中的许多方法都是按照equals方法进行定义的。例如， containsKey(Object key)方法的规范说：“当且仅当此映射包含k的映射关系true时才返回(key==null ? k==null : key.equals(k)) 。该规范不应该被解释为意味着调用Map.containsKey与非空参数key会导致key.equals(k)被调用的任意键k 。实现可以自由地实现优化，从而避免equals调用，例如，首先比较两个密钥的哈希码。（ Object.hashCode()规范保证具有不等的哈希码的两个对象不能相等。）更一般地，各种Collections Framework接口的实现可以随意利用底层的Object方法的指定行为，无论执行者认为合适。

执行递归遍历地图的一些地图操作可能会失败，并且地图直接或间接包含自身的自引用实例有异常。这包括clone() ， equals() ， hashCode()和toString()方法。实现可以可选地处理自引用场景，然而大多数当前实现不这样做。

二、HashMap(让我们来具体看看这Map星云把我迦迷得不要不要的小妖精)

1、盖亚！！！（无不无聊...）...概述：

“不好意思......我不无聊！！”

HashMap是基于哈希表的实现的Map接口。该实现提供了所有可选的映射操作，并允许null值和null密钥。（ HashMap类大致相当于Hashtable ，除了它是不同步的，并允许null）。这个类不能保证地图的顺序; 特别是，它不能保证订单在一段时间内保持不变。

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

“只要我足够强，谁来都没用！Map星云都是我的。”

“来啊，造作啊，来哇，快活啊。”

2、可惜，我迦不是我迪啊，呵呵，大威天龙！！！（看法宝）：

Modifier and Type 方法描述
void clear()
从这张地图中删除所有的映射。

Object clone()
返回此 HashMap实例的浅拷贝：键和值本身不被克隆。

V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
尝试计算指定密钥及其当前映射值的映射（如果没有当前映射，则 null ）。

V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
如果指定的键尚未与值相关联（或映射到 null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 null 。

V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。

boolean containsKey(Object key)
如果此映射包含指定键的映射，则返回 true 。

boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定的值，则返回 true 。

Set<Map.Entry<K,V>> entrySet()
返回此地图中包含的映射的Set视图。

void forEach(BiConsumer<? super K,? super V> action)
对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。

V get(Object key)
返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。

V getOrDefault(Object key, V defaultValue)
返回指定键映射到的值，如果此映射不包含该键的映射，则返回 defaultValue 。

boolean isEmpty()
如果此映射不包含键值映射，则返回 true 。

Set<K> keySet()
返回此地图中包含的键的Set视图。

V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。

V put(K key, V value)
将指定的值与此映射中的指定键相关联。

void putAll(Map<? extends K,? extends V> m)
将指定地图的所有映射复制到此地图。

V putIfAbsent(K key, V value)
如果指定的键尚未与值相关联（或映射到 null ）将其与给定值相关联并返回 null ，否则返回当前值。

V remove(Object key)
从该地图中删除指定键的映射（如果存在）。

boolean remove(Object key, Object value)
仅当指定的密钥当前映射到指定的值时删除该条目。

V replace(K key, V value)
只有当目标映射到某个值时，才能替换指定键的条目。

boolean replace(K key, V oldValue, V newValue)
仅当当前映射到指定的值时，才能替换指定键的条目。

void replaceAll(BiFunction<? super K,? super V,? extends V> function)
将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。

int size()
返回此地图中键值映射的数量。

Collection<V> values()
返回此地图中包含的值的Collection视图。

Modifier and Type	方法	描述
`void`	`clear()`	从这张地图中删除所有的映射。
`Object`	`clone()`	返回此 `HashMap`实例的浅拷贝：键和值本身不被克隆。
`V`	`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`	尝试计算指定密钥及其当前映射值的映射（如果没有当前映射，则 `null` ）。
`V`	`computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)`	如果指定的键尚未与值相关联（或映射到 `null` ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 `null` 。
`V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`	如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。
`boolean`	`containsKey(Object key)`	如果此映射包含指定键的映射，则返回 `true` 。
`boolean`	`containsValue(Object value)`	如果此映射将一个或多个键映射到指定的值，则返回 `true` 。
`Set<Map.Entry<K,V>>`	`entrySet()`	返回此地图中包含的映射的Set视图。
`void`	`forEach(BiConsumer<? super K,? super V> action)`	对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
`V`	`get(Object key)`	返回指定键映射到的值，如果此映射不包含键的映射，则返回 `null` 。
`V`	`getOrDefault(Object key, V defaultValue)`	返回指定键映射到的值，如果此映射不包含该键的映射，则返回 `defaultValue` 。
`boolean`	`isEmpty()`	如果此映射不包含键值映射，则返回 `true` 。
`Set<K>`	`keySet()`	返回此地图中包含的键的Set视图。
`V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)`	如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。
`V`	`put(K key, V value)`	将指定的值与此映射中的指定键相关联。
`void`	`putAll(Map<? extends K,? extends V> m)`	将指定地图的所有映射复制到此地图。
`V`	`putIfAbsent(K key, V value)`	如果指定的键尚未与值相关联（或映射到 `null` ）将其与给定值相关联并返回 `null` ，否则返回当前值。
`V`	`remove(Object key)`	从该地图中删除指定键的映射（如果存在）。
`boolean`	`remove(Object key, Object value)`	仅当指定的密钥当前映射到指定的值时删除该条目。
`V`	`replace(K key, V value)`	只有当目标映射到某个值时，才能替换指定键的条目。
`boolean`	`replace(K key, V oldValue, V newValue)`	仅当当前映射到指定的值时，才能替换指定键的条目。
`void`	`replaceAll(BiFunction<? super K,? super V,? extends V> function)`	将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
`int`	`size()`	返回此地图中键值映射的数量。
`Collection<V>`	`values()`	返回此地图中包含的值的Collection视图。

3、只是终究还是错付了，我迪还是受不鸟辣么的诱惑，实在是给得太多了。所以，注意了，这些事情早知道，早...快乐！（注意注意）：

HashMap的键和值的类型可以是String类型，也可以是其他数据的包装类类型

Map集合的元素的添加并不是Collection集合的add（）方法，而是Put()方法。

Map的遍历也不再是for循环或是while循环去integer迭代什么了，而是用到两种新的遍历方式，通过keySet或是entrySet的方法。

只是终究，噩梦都会到来，再美好的一切，都会失去，哭也没用了：

4、方法代码实例，让我们呼唤光吧，净化那丑陋的一切：

让我们来整一个全局观，测试测试这些方法。

定义一个Map接口类型的变量，引用一个实现类，添加键值对，

判断集合中是否包含某一key值，通过某一key值得到value值，

通过某一key删除键值对，

把另一个map集合添加到此map集合，

判断是否为空，

清除集合，

返回集合里元素的个数等常用操作（返回一个长度的问题，就自己想办法吧，给我数（三声）！）。

通过两种方法遍历上题中的map集合。

（代码如下）

package MapDemo;

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

public class Map001 {
    public static void main(String[] args) {

        //创建Map集合
        Map<String,String> map=new HashMap<String, String>();

        //存入数据，put方法
        map.put("LAOZI","《道德经》");
        map.put("KONGZI","《论语》");
        map.put("ZHUANGZI","《南华经》");

        map.put("GEHONG","《抱朴子》");

        //根据键key，找值value
        String s = map.get("LAOZI");
        System.out.println(s);
        System.out.println("--------------");

        //根据键key，删除值value
        String s1 = map.remove("GEHONG");
        System.out.println(s1);
        System.out.println("--------------");

        Map<String,String> map1=new HashMap<>();
        map1.put("wuming","万剑归宗");
        
        //全局存入，一个双列集合，存入另一个双列集合
        map.putAll(map1);

        //判断集合是否为空
        boolean empty = map.isEmpty();
        System.out.println(empty);
        System.out.println("-------------");

        //遍历方法之entrySet
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> me:entrySet){
            String key= me.getKey();
            String value=me.getValue();
            System.out.println(key+","+value);
        }
        System.out.println("------------");

        //清盘，清空集合中数据
        map.clear();

        //遍历方法之keySet
        Set<String> keySet = map.keySet();
        for (String key:keySet){
            String value=map.get(key);
            System.out.println(key+","+value);
        }
    }
}

三、人间体大古，为了人界和平，再次使命召来，让我们高举代码，呼唤，光！！（案例怪兽来了）

模拟斗地主洗牌发牌。

分析：

首先应准备牌：完成数字与纸牌的映射关系：使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系。

洗牌：通过数字完成洗牌发牌（借助工具类）

发牌：将每个人以及底牌设计,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌给3个玩家。存放的过程中要求数字大小与斗地主规则的大小对应排序。将代表不同纸牌的数字分配给不同的玩家与底牌。

看牌：通过Map集合找到对应字符展示。通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。

“地噶！！！”

“以雷霆击碎黑暗！”

package MapDemo;

import java.util.*;

public class Map03 {
    public static void main(String[] args) {

        //Map集合
        HashMap<Integer, String> map = new HashMap<Integer, String>();

        //创建Arraylist集合存储编号
        ArrayList<Integer> list = new ArrayList<Integer>();

        //创建花色与点数数组
        String[] colors = {"♠", "♥", "♦", "♣"};
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};

        //从0开始往map里面存编号与牌，同时往list集合里面存编号。
        int index = 0;

        //循环嵌套内外层很重要，如果外层是颜色，存储的时候就是花色+3456...,如果外层是数值，存储时就是33334444...
        for (String number : numbers) {
            for (String color : colors){
                map.put(index, color + number);
                list.add(index);
                index++;
            }
        }

        //存大小王
        map.put(index, "小王");
        list.add(index);
        index++;
        map.put(index, "大王");
        list.add(index);

        //洗牌
        Collections.shuffle(list);

        //收牌的人（集合），发编号（顺序）
        TreeSet<Integer> zgrSet = new TreeSet<Integer>();
        TreeSet<Integer> myfSet = new TreeSet<Integer>();
        TreeSet<Integer> ljlSet = new TreeSet<Integer>();
        TreeSet<Integer> dpSet = new TreeSet<Integer>();

        //发牌到三个玩家手上
        for (int i = 0; i < list.size(); i++) {
            int x = list.get(i);
            if (i >= list.size() - 3) {
                dpSet.add(x);
            } else if (i % 3 == 0) {
                zgrSet.add(x);
            } else if (i % 3 == 1) {
                myfSet.add(x);
            } else if (i % 3 == 2) {
                ljlSet.add(x);
            }
        }

        //调用看牌方法
        lookPoker("张国荣", zgrSet, map);
        lookPoker("梅艳芳", myfSet, map);
        lookPoker("刘嘉玲", ljlSet, map);
        lookPoker("底牌", dpSet, map);

    }

    //定义方法看牌（遍历TreeSet集合，获取编号，到HashMap集合中找到对应的牌）
    public static void lookPoker(String name, TreeSet<Integer> treeSet, HashMap<Integer, String> map) {
        System.out.println(name + "的牌是： ");
        for (Integer key : treeSet) {
            String poker = map.get(key);
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}