目录
Java 集合
1. Collection集合（单列集合）
集合概述
- 集合：集合是Java提供的一种容器，可以用来存储多个数据。
- 数组的长度是固定的，而集合的长度是可变的。
- 数组中存储的是同一类型的元素，可以存储基本类型的值。集合存储的都是对象，是引用类型，而且对象的类型可以不一样。在开发中一般当对象多的时候，使用集合进行存储。
集合的架构
Collection常用的方法
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（list和set）通用的一些方法，这些方法可用于操作所有的单列集合，共性方法如下：
- public boolean add(E e)：把给定的对象添加到当前集合当中。
- public void clear()：清空集合当中所有的元素。
- public boolean remove(E e)：把给定的对象从当前集合当中删除。
- public boolean contains (E e)：判断当前集合中是否包含给定的对象。
- public boolean isEmpty(E e)：判断当前集合是否为空。
- public int size()：返回集合中元素的个数。
- public Object[] toArray()：把集合中的元素，存储到数组中。
import java.util.ArrayList; import java.util.Collection; /* public boolean add(E e); public void clear(); public boolean remove(E e); public int size(); public boolean isEmpty(); public Object[] toArray(); public boolean contains(E e); */ public class DemoCollection { public static void main(String[] args) { Collection<String> coll = new ArrayList<>(); System.out.println(coll); // add 添加元素 coll.add("迪丽热巴"); coll.add("古力娜扎"); coll.add("马尔扎哈"); coll.add("鹿晗"); coll.add("赵丽颖"); System.out.println(coll); // isEmpty 判断是否为空 System.out.println(coll.isEmpty()); // size 当前集合的大小 System.out.println(coll.size()); // remove 清除一个元素 coll.remove("马尔扎哈"); // Object[] toArray Object[] objects = coll.toArray(); for (int i = 0; i < objects.length; i++) { System.out.println(objects[i]); } // contains 判断当前集合是否包含给定的对象 boolean b1 = coll.contains("赵丽颖"); System.out.println(b1); // clear 清空集合中的元素，但集合仍然存在，只不过为空 coll.clear(); System.out.println(coll.isEmpty()); } } Iterator
- 迭代：即Collection集合元素的通用获取方式。在取元素之前先判断集合中有没有元素，如果有，就把这个元素取出来，再继续判断，如果还有就再取出来。一直把集合中所有元素取出。这种取出的方式专业术语称为迭代。
- java.util.Iterator接口：迭代器（对集合进行遍历）
有两个常用的方法
- public boolean hasNext()：判断集合当中还有没有下一个元素，有就返回true，没有就返回false。
- public E next()：取出集合当中的下一个元素。
Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获得实现类的方式比较特殊，Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现对象。
- Iterator
<E>iterator()：返回在此 Collection 的元素上进行迭代的迭代器。
Iterator迭代器的使用步骤：
- 使用集合当中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接受（多态）。
- 使用Iterator接口当中的方法hasNext()判断还有没有下一个元素。
- 使用Iterator接口当中的方法next()取出集合当中的下一个元素。
注意事项：
Iterator<E>接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型。
迭代器的实现原理
public class DemoCollection { public static void main(String[] args) { Collection<String> coll = new ArrayList<>(); coll.add("迪丽热巴"); coll.add("马儿扎哈"); coll.add("赵丽颖"); coll.add("鹿晗"); Iterator<String> it = coll.iterator(); while (it.hasNext()){ String str = it.next(); System.out.println(str); } } } coll.iterator()：获取集合的实现类对象，并且会把指针（索引）指向集合的-1索引。it.hasNext()：判断集合还有没有下一个元素。it.next()：做了两件事- 取出下一个元素
- 会把指针向后移动一位
2. 增强for（for each）
- 增强for循环（也称 for each循环）是JDK 1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
- public interface Collection
<E>extends Iterable<E>：所有的单列 集合都可以使用增强for。 public interface Iterable
<T>实现这个接口允许对象成为 "foreach" 语句的目标。格式：
for (元素的数据类型 变量名称 : Collection集合 or 数组){ // 写操作代码 } 注意事项：
- 不要在遍历的过程中对集合元素进行增删操作。
- 增强 for循环必须有被遍历的对象，目标只能是Collection集合或者数组，新式for仅仅作为遍历操作出现。
3. 泛型(Generic)
泛型概念
泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，就可以使用泛型。
泛型也可以看作是一个变量，用来接受数据类型。
E e：Element 元素
T t：Type 类型
创建集合对象的时候，就会确定泛型的数据类型。
使用泛型的好处
创建集合对象，不使用泛型
- 好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。
- 弊端：不安全，容易引发异常。
创建集合，使用泛型
- 好处 ：
- 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
- 把运行期异常（代码运行之后会抛出的异常），提升到了编译期（写代码的时候会报错）。
- 弊端：
泛型是什么类型，只能存储什么类型。
定义含有泛型的类
- 格式：
修饰符 class 类名<泛型>{ // ... } - 示例：
public class GenericClass <E> { private E name; public void setName(E name){ this.name = name; } public E getName(){ return this.name; } } 定义含有泛型的方法
泛型定义在方法的修饰符和返回值类型之间
- 格式：
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){ // ... } - 示例：
public class GenericMethod { // 定义泛型普通方法 public <E> void methodNormal(E e){ System.out.println(e); } // 定义泛型静态方法 public static <E> void methodStatic(E e){ System.out.println(e); } } 定义含有泛型的接口
- 格式：
修饰符 interface 接口名称<泛型>{ // ... } - 第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型。
public interface Iterator`<E>`{ E next(); } Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String。
public final class Scanner implements Iterator<String>{ public String next(); } - 第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走，就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型。
public class ArrayList<E>implements List<E>{ public boolean add(E e); public E get(int index); } public interface List<E> extends Collection<E> { boolean add(E e); E get(int index); } 泛型的通配符
- ？：代表任意的数据类型
- 使用方式：不能创建对象使用，只能作为方法的参数使用。
- 不知道使用什么类型来接收的时候，此时可以使用 ？ ，？表示未知通配符。
- 但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身的方法无法使用。
- 练习：
/* 题目要求： 定义一个方法，能遍历所有类型的ArrayList集合 分析： 这时候我们不知道ArrayList集合使用什么数据类型， 可以使用泛型的通配符 ? 来接受数据类型 */ public class DemoGeneric01 { public static void main(String[] args) { ArrayList<Integer> listA = new ArrayList<>(); listA.add(10); listA.add(20); ArrayList<String> listB = new ArrayList<>(); listB.add("马尔扎哈"); listB.add("格利纳扎"); printArray(listA); printArray(listB); } public static void printArray(ArrayList<?> list){ Iterator<?> it = list.iterator(); while (it.hasNext()){ Object o = it.next(); System.out.println(o); } } } 注意事项：
泛型不存在继承关系。
Collection<Object>list = new ArrayList<String>(); 这种是错误的！
通配符的高级使用—泛型受限
泛型的上限：
- 格式：类型名称 < ? extends 类 > 对象名称
- 意义：只能接受该类本身及其子类
泛型的下限：
- 格式：类型名称 < ? super 类 > 对象名称
- 意义：只能接收该类本身及其父类
4. 综合案例：斗地主（单列集合）
/* 题目： 使用单列集合实现斗地主 分析： 1. 准备牌 创建一个集合poker用来存储54张牌 准备两个数组，分别存储花色和编号 两个for循环放入集合poker当中 2. 洗牌 调用Collections工具类中的shuffle()方法随机打乱牌 3. 发牌 用四个集合分别存储玩家A、B、C和底牌hand 使用索引 i % 3来进行对玩家分牌，当i >= 51时，给底牌 4. 看牌 输出四个集合存储的牌 */ import java.util.ArrayList; import java.util.Collections; public class PokerGame { public static void main(String[] args) { // 准备牌 ArrayList<String> poker = new ArrayList<>(); String[] colors = {"♥", "♠", "♣", "♦"}; String[] numbers = {"2","A","K","Q","J","10","9", "8","7","6","5","4", "3"}; poker.add("大王"); poker.add("小王"); for (String color : colors) { for (String number : numbers) { poker.add(color + number); } } // System.out.println(poker); // System.out.println(poker.size()); // 洗牌 Collections.shuffle(poker); // 准备存储玩家的牌 ArrayList<String> playA = new ArrayList<>(); ArrayList<String> playB = new ArrayList<>(); ArrayList<String> playC = new ArrayList<>(); ArrayList<String> hand = new ArrayList<>(); // 发牌 for (int i = 0; i < poker.size(); i++) { String o = poker.get(i); int j = i % 3; if (i >= 51){ hand.add(o); }else if (j == 0){ playA.add(o); }else if (j == 1){ playB.add(o); }else if (j == 2){ playC.add(o); } } // 看牌 System.out.println("选手A：" + playA); System.out.println("选手B：" + playB); System.out.println("选手C：" + playC); System.out.println("底牌：" + hand); } } 5. List集合
- java.util.List 接口 extends Collection 接口
List接口的特点：
- 有序的集合：存储和取出元素的顺序是一样的。
- 有索引：包含一些带索引的方法。
- 允许存储重复的元素。
List接口中带索引的方法（特有）：
- public void add(int index, E element)：将指定的元素，添加到该集合的指定位置。
- public E get(int index)：返回集合中指定位置的元素。
- public E remove(int index)：移除列表中指定位置的元素，返回值是被移除的元素。
- public E set(int index, E element)：用指定元素替换集合中指定位置的元素，返回值是被替换的元素。
注意事项：
- 操作索引的时候，一定防止索引越界异常。
- IndexOutOfBoundsException：索引越界异常，集合会报。
- ArrayIndexOutOfBoundsException：数组索引越界异常。
- StringIndexOutOfBoundsException：字符串索引越界异常。
6. List的实现类
1. ArrayList集合
- 底层是一个数组。
- 查询快，增删慢。
- List 接口的大小可变数组的实现。
- 注意，此实现不是同步的。（多线程）
2. LinkList集合
- 底层是一个链表结构。
- 查询慢，增删快。
- List 接口的链接列表实现。
- 注意，此实现不是同步的。（多线程）
- 里面包含了大量操作首尾元素的方法。
注意事项：使用 LinkList特有的方法，不能使用多态，多态的弊端就是不能使用子类特有的方法。
添加方法：
- public void addFirst(E e)：将指定元素插入到列表的开头。
- public void addLast(E e)：将指定元素插入到列表的结尾。
- public void push(E e)：将元素推入此列表所表示的堆栈，此方法等效于addFirst。
得到方法：
- public E getFirst()：返回此列表的第一个元素。
- public E getLast()：返回此列表的最后一个元素。
删除方法：
- public E removeFirst()：移除并返回此列表的第一个元素。
- public E removeLast()：移除并返回此列表的最后一个元素。
- public E pop()：从此列表所表示的堆栈处弹出一个元素。此方法等效于removeFirst。
判断列表是否为空：
- public boolean isEmpty()：如果此列表不包含元素，则返回true。
3. Vector集合
- Vector 类可以实现可增长的对象数组。
- 与新 collection 实现不同，Vector 是同步的。
7. Set集合
- java.util.Set接口 extends Collection接口
Set接口的特点：
- 不允许存储重复的元素。
- 没有索引，没有带索引的方法，也不能使用普通的for循环遍历。
- java.util.HashSet集合 implements Set接口
HashSet集合的特点：
- 是一个无序集合，存储元素和取出元素的顺序有可能不一样。
- 底层是一个哈希表结构（查询的速度非常的快）
public class DemoSet { public static void main(String[] args) { Set<Integer> set = new HashSet<>(); set.add(10); set.add(20); set.add(30); set.add(20); System.out.println(set); // [20, 10, 30] Iterator<Integer> it = set.iterator(); while (it.hasNext()){ Integer next = it.next(); System.out.println(next); } System.out.println("============"); for (Integer i : set) { System.out.println(i); } } } 哈希值
- 哈希值：是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到的地址，不是数据实际存储的物理地址。
- 在Object类中有个一个方法，可以获取对象的哈希值。
int hashCode()：返回该对象的哈希码值。
hashCode方法的源码：public native int hashCode();
native：代表该方法调用的是本地操作系统的方法。 - Object类中toString方法的源码： return getClass().getName() + "@" + Integer.toHexString(hashCode());
// 巧了，"通话"和"重地"的哈希码值一样 System.out.println("重地".hashCode()); // 1179395 System.out.println("通话".hashCode()); // 1179395 HashSet存储数据的结构（哈希表）
- 什么是哈希表呢？
在JDK 1.8之前，哈希表底层采用数组 + 链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK 1.8中，哈希表存储采用 数组 + 链表 + 红黑树实现，当链表长度超过阈值（8）时，将链表装换为红黑树，这样大大减少了查找时间。
- 简单来说，哈希表是由 数组 + 链表 + 红黑树（JDK 1.8增加的红黑树部分）实现的。
Set集合存储不重复元素的原理
使用add方法添加元素的时候，add方法会调用元素的hashCode方法和equals方法，判断元素是否重复。
注意事项：
存储的元素必须重写hashCode方法和equals方法。
HashSet存储自定义类型的元素
- 前提：需要重写类中的hashCode方法和equals方法。才能使集合中的元素唯一。
- 注意，此实现不是同步的。
- 示例：
@Override public boolean equals(Object o) { if (this == o) return true; // 使用反射技术判断 o 是否是Person类型 等效于 o instanceof Person if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } @Override public int hashCode() { return Objects.hash(name, age); } // ============================= HashSet<Person> set = new HashSet<>(); Person one = new Person("小美女", 19); Person two = new Person("小美女", 19); Person three = new Person("大美女", 20); System.out.println(one == two); // false System.out.println("one hashCoe:" + one.hashCode()); // one hashCoe:734175840 System.out.println("two hashCode:" + two.hashCode()); // two hashCode:734175840 set.add(one); set.add(three); set.add(two); System.out.println(set); // [Person{name='小美女', age=19}, Person{name='大美女', age=20}] LinkedHashSet集合
- java.util.LinkedHashSet集合 extends HashSet集合
- 特点：底层是一个哈希表（数组+链表 / 数组+红黑树）+链表，多了一条链表（记录元素的存储顺序），保证元素有序。
- 以上特点JDK1.6中是这样说的：具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
- 注意，此实现不是同步的。
可变参数
在JDK 1.5之后，如果我们定义一个方法需要接受多个参数，，并且参数的类型一致，我们可以使用可变参数。=
- 格式：
修饰符 返回值类型 函数名称(参数类型...参数名称){ // 函数体 } 其实这个写法完全等价于
修饰符 返回值类型 函数名称(参数类型[]参数名称){ // 函数体 } 只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
JDK 1.5以后，出现了简化操作。...用在参数上，称之为可变参数。
注意事项：
- 一个方法的参数列表，只能有一个可变参数。
- 如果方法的参数有多个，那么可变参数必须写在参数列表的末尾。
8. Collections工具类
- java.util.Collections是集合工具类。
- public static
<T>boolean addAll(Collection<T>c, T ... elements)：往集合当中添加一些元素。 - public static void shuffle(List
<?>, list)：打乱集合顺序。 - public static
<T>void sort(List<T>list)：将集合中的元素按照默认规则排序。
注意事项：sort(List
<T>list)：使用前提：
被排序的集合里面元素，必须实现Comparable接口，重写接口中的方法：compartTo定义排序的规则。
Comparable接口的排序规则：自己（this）- 参数：升序
- public static
<T>void sort(List<T>list, Comparator<? super T>)：将集合中的元素按照指定规则排序。
Comparable与Comparator的区别：
Comparable：自己（this）和别人（参数）比较，自己需要是实现Comparable接口，重写compareTo方法；
Comparator：相当于找一个第三方裁判，比较两个。
Comparator比较规则：o1 - o2 ：升序。
Collections.sort(listB, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o1 - o2; } }); 9. Map集合（双列集合）
Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个一个元素的方式完成存储。Map中的集合，元素是成对存在的（理解为夫妻），每个元素由键和值两部分组成，通过键可以找到对应的值。Collection中的集合称为单列集合，Map中的集合称为双列集合。
概述
- java.util.Map<k, v>集合
Map集合的特点：
- Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）。
- Map集合中的元素，key和value的数据类型可以相同，也可以不同。
- Map集合中的元素，key是不允许重复的，value是可以重复的。
- Map集合中的元素，key和value是一一对应的。
Map常用子类
HashMap集合的特点：
- java.util.HashMap<k, v>集合 implements Map<k, v>接口
- HashMap集合底层是哈希表：查询的速度特别快。
- JDK 1.8之前：数组+链表
- JDK 1.8之后：数组+链表 / 红黑树
- HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致。
LinkedHashMap集合的特点：
- java.util.LinkedHashMap<k, v>集合 extends HashMap<k, v>集合
- LinkedHashMap集合的底层是哈希表+链表（保证迭代的顺序）。
- LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的。
Map接口中的常用方法
- public V put(K key, V value)：把指定的键和指定的值添加到Map集合当中去。
- 返回值：V
- 存储键值对的时候，key不重复，返回值V是：null
- 存储键值对的时候，key重复，会使用新的value替换Map集合中重复的value，返回被替换的value值。
- public V remove(Object key)：把指定的键，所对应的键值对元素，在Map集合中删除，返回被删除元素的值。
- 返回值：V
- key存在，V返回被删除的值
- key不存在，V返回null
- public V get(Object key)：根据指定的键，在Map集合中获取指定的值。
- 返回值：V
- key存在，返回对应的value值
- key不存在，返回null
- boolean containsKey(Object key)：判断集合中是否包含指定的键。
- 包含返回：true
- 不包含返回：false
- Set
keySet() ：返回此映射中包含的键的 Set 视图。
1. Map集合的第一种遍历方式：通过键找值的方式。
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /* 1. public V put(K key, V value) 2. public V remove(Object key) 3. public V get(Object key) 4. public boolean containsKey(Object key) */ public class DemoMap { public static void main(String[] args) { Map<String, String> map = new HashMap<>(); // put(K key, V value) String put1 = map.put("萧炎", "彩鳞"); map.put("林动", "欢欢"); map.put("牧尘", "洛璃"); // remove(Object key) String put2 = map.remove("牧尘"); // containsKey(Object key) boolean b1 = map.containsKey("萧炎"); // V get(Object key) String put4 = map.get("林动"); // Map集合的第一种遍历方式：通过键找值 Set<String> set = map.keySet(); // 1. 使用迭代器 Iterator<String> it = set.iterator(); while (it.hasNext()){ String key = it.next(); String value = map.get(key); System.out.println(key + "=" + value); } System.out.println("================="); // 2. 使用增强for for (String key : map.keySet()) { String value = map.get(key); System.out.println(key + "=" + value); } } } 2. Map集合的第二种遍历方式：Entry对象。
static interface Map.Entry<K,V> ：映射项（键-值对）。
Map.Entry<K,V>：在Map接口中有一个内部接口Entry。
作用：当Map集合一创建，就会在Map集合中创建一个Entry对象，用来记录键与值（键值对对象，键与值的映射关系） --> 结婚证
Map集合中的方法：
- Set<Map<K, V>> entrySet()：返回此映射中包含的映射关系的 Set 视图。
使用步骤：
- 使用Map集合当中的方法entrySet()，把Map集合当中的多个entry对象取出来，存放到一个Set集合中。
- 遍历Set集合，获取每一个Entry对象。
- 使用Entry对象中的方法，getKey()和getValue()获取键与值。
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class DemoMapEntry { public static void main(String[] args) { Map<String, Integer> map = new HashMap<>(); map.put("赵丽颖", 168); map.put("冯宝宝", 173); map.put("高圆圆", 178); map.put("林志玲", 180); System.out.println(map); // 1. 将每一个entry对象存放到set集合中 Set<Map.Entry<String, Integer>> set = map.entrySet(); // 2. 遍历entry对象，获取每一个entry对象 // 首先获得set集合的迭代器 Iterator<Map.Entry<String, Integer>> it = set.iterator(); while (it.hasNext()) { Map.Entry<String, Integer> entry = it.next(); // 3. getKey()和getValue() String key = entry.getKey(); Integer value = entry.getValue(); System.out.println(key+ "=" + value); } System.out.println("============"); // 通过增强for实现 for (Map.Entry<String, Integer> entry : set) { String key = entry.getKey(); Integer value = entry.getValue(); System.out.println(key+"="+value); } } } HashMap存储自定义类型键值
Map集合保证key是唯一的，作为key的元素，必须重写hashCode和equals方法，以保证key是唯一的。
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class DemoHashMapSavePerson { public static void main(String[] args) { // key：String // value：Person HashMap<String, Person> mapA = new HashMap<>(); mapA.put("北京", new Person("聂离", 19)); mapA.put("上海", new Person("陆飘", 19)); mapA.put("广州", new Person("杜泽", 20)); mapA.put("上海", new Person("叶紫芸", 18)); // 使用keySet+增强for遍历 Set<String> setA = mapA.keySet(); for (String key : setA) { Person value = mapA.get(key); System.out.println(key + "-->" + value); } System.out.println("=================="); // key：Person // value：String HashMap<Person, String> mapB = new HashMap<>(); mapB.put(new Person("海波东",30), "冰皇"); mapB.put(new Person("雅妃", 25), "金之女皇"); mapB.put(new Person("萧炎", 20), "炎帝"); mapB.put(new Person("古河", 30), "丹王"); mapB.put(new Person("雅妃", 25), "女皇"); // 使用entrySet+迭代器遍历 Set<Map.Entry<Person, String>> setB = mapB.entrySet(); // 获取迭代器 Iterator<Map.Entry<Person, String>> it = setB.iterator(); while (it.hasNext()) { Map.Entry<Person, String> entry = it.next(); Person key = entry.getKey(); String value = entry.getValue(); System.out.println(key+"-->"+value); } System.out.println("===================="); // 使用增强for + enteySet for (Map.Entry<Person, String> entry : setB) { Person key = entry.getKey(); String value = entry.getValue(); System.out.println(key+"-->"+value); } } } LinkedHashMap集合
- java.util.LinkedHashMap<K, V> extends HashMap<K, V>
- Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
- 底层原理：哈希表 + 链表（记录元素的顺序）
- 注意，此实现不是同步的。
Hashtable集合
- java.util.Hashtable<K, V>集合 implements Map<K, V>接口。
- 任何非 null 对象都可以用作键或值。
- 不像新的 collection 实现，Hashtable 是同步的
Hashtable：底层也是一个哈希表，是一个线程安全的集合，是单线程集合，访问速度慢。
HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程集合，访问速度快。
HashMap集合（之前学的所有集合）：可以存储null值，null键
Hashtable集合：不可以存储null值，null键
Hashtable和Vector集合一样，在JDK1.2之后被更先进的集合（HashMap、ArrayList）替代。
但是，Hashtable的子类Properties依然在使用，Properties集合是唯一一个和 IO流相结合的集合。
练习
import java.util.HashMap; import java.util.Scanner; /* 题目要求： 输入一个字符串，判断其中每个字符出现的次数？ 分析： 1. 使用Scanner类中的next方法，接受键盘输入的字符串 2. 创建Map集合， 其中字符作为key，字符出现的次数作为value 3. 遍历字符串，取出每一个字符 4. 使用获取到的字符，去Map集合判断key是否存在 key存在 通过key（字符）获取value（次数） value++ put(key, value)，更新value的值 key不存在 put(key, 1) 5. 遍历Map集合，输出结果 遍历字符串的两种方式： 1. 使用String的toCharArray()方法，将字符串变成字符数组，循环遍历 2. 使用String的length()方法和charAt(int index)：获取每个索引处的单个字符，来遍历 */ public class DempMapPractise { public static void main(String[] args) { System.out.println("请输入一个字符串："); // 使用Scanner类中的next方法 Scanner sc = new Scanner(System.in); String str = sc.next(); // 创建HashMap集合，存储字符和相应的次数 HashMap<Character, Integer> map = new HashMap<>(); // 遍历字符串，方法1： /*for (char c : str.toCharArray()){ // 如果map中包含c if (map.containsKey(c)){ Integer value = map.get(c); value++; map.put(c, value); }else{ // 如果不包含c map.put(c, 1); } }*/ // 遍历字符串，方法2： for (int i = 0; i < str.length(); i++){ char c = str.charAt(i); if (map.containsKey(c)){ Integer value = map.get(c); value++; map.put(c, value); }else { map.put(c, 1); } } // 遍历map集合，打印结果 for (Character key : map.keySet()) { Integer value = map.get(key); System.out.println(key + "=" + value); } // System.out.println(map); } } JDK9对集合添加的优化
JDK9的新特性：
List接口，Set接口，Map接口，里边增加了一个静态方法of，可以给集合一次性添加多个元素。
static
使用前提：当集合中存储的元素个数是确定的，不再改变时使用。
注意事项：
- of 方法只适用于：List接口、Set接口、Map接口，不适用于接口的实现类。
- of 方法的返回值是一个不能改变的集合，集合不能再使用add、put方法添加元素，会抛出异常：UnsupportedOperationException：不支持操作异常。
- Set接口和Map接口在调用 of 方法的时候，不能有重复的元素，否则后抛出异常：IllegalArgumentException：非法参数异常，有重复的元素。
示例：
import java.util.List; import java.util.Map; import java.util.Set; public class DemoStaticMehodof { public static void main(String[] args) { List<String> list = List.of("a", "b", "c", "d"); System.out.println(list); // list.add("r"); // UnsupportedOperationException：不支持操作异常 // System.out.println(list.remove("a"));// UnsupportedOperationException // Set<String> set = Set.of("a", "b", "a", "c"); // System.out.println(set); // IllegalArgumentException：非法参数异常 // IllegalArgumentException：非法参数异常，有重复元素 // Map<String, Integer> map = Map.of("聂离", 20, "聂离", 21, "杜泽", 22); // System.out.println(map); } } 10. 综合案例：斗地主（双列集合）
import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; /* 1. 准备牌 2. 洗牌 3. 发牌 4. 排序 5. 看牌 */ public class PokerGamePlus { public static void main(String[] args) { // 用来存储扑克的编号和 54张扑克 HashMap<Integer, String> poker = new HashMap<>(); // 扑克的编号 ArrayList<Integer> pokerIndex = new ArrayList<>(); // 先把大王小王及其编号存储进扑克 poker.put(0, "大王"); pokerIndex.add(0); poker.put(1, "小王"); pokerIndex.add(1); // 两个集合分别存储花色和编号 String[] colors = {"♥", "♦", "♣", "♠"}; String[] numbers = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"}; int index = 2; for (String number : numbers) { for (String color : colors) { poker.put(index, color + number); pokerIndex.add(index); index++; } } // System.out.println(poker); // 2. 洗牌 Collections.shuffle(pokerIndex); // System.out.println(pokerIndex); // 3. 发牌 // 3个玩家 + 1个底牌 ArrayList<Integer> playerA = new ArrayList<>(); ArrayList<Integer> playerB = new ArrayList<>(); ArrayList<Integer> playerC = new ArrayList<>(); ArrayList<Integer> hand = new ArrayList<>(); for (int i = 0; i < pokerIndex.size(); i++) { Integer in = pokerIndex.get(i); int j = i % 3; if (i >= 51) { hand.add(in); } else if (j == 0) { playerA.add(in); } else if (j == 1) { playerB.add(in); } else if (j == 2) { playerC.add(in); } } // 4. 排序，默认为从小到大 Collections.sort(playerA); Collections.sort(playerB); Collections.sort(playerC); Collections.sort(hand); // 5. 发牌 seePoker("周润发", playerA, poker); seePoker("刘德华", playerB, poker); seePoker("周星驰", playerC, poker); seePoker("底牌", hand, poker); } public static void seePoker(String name, ArrayList<Integer> keys, HashMap<Integer, String> poker) { System.out.print(name + ":"); for (Integer key : keys) { String value = poker.get(key); System.out.print(value + " "); } System.out.println(); } }