一、Map接口
1. 概述和特点
概念：Collection 每次只能保存一个对象，所以属于单值保存父接口。而在类集中又提供了保存偶对象的集合：Map 集合，利用 Map 结合可以保存一对关联数据（key=value），如下图所示，这样就可以实现根据 key 取得 value 的操作。
012.png
特点：
1. 将键映射到值的对象
2. 一个映射不能包含重复的键
3. 每个键最多只能映射到一个值
2. Map接口与Collection接口的不同
1. Map是双列的,Collection是单列的
2. Map的键唯一,Collection的子体系Set是唯一的
3. Map集合的数据结构值针对键有效，跟值无关
4. Collection集合的数据结构是针对元素有效
3. 成员方法
//1.将指定的值与此映射中的指定键关联，如果此映射以前包含一个该键的映射关系，则用指定值替换旧值，返回值为以
//钱与key关联的值
//参数1：key 键
//参数2：value 值
V put(K key,V value)
//2.如果存在一个键的映射关系，则将其从此映射中移除，返回值为以前与key关联的值
//参数:key 键
V remove(Object key)
//3.从此映射中移除所有映射关系。此调用返回后，该映射将为空。
void clear()
//4.如果此映射包含指定键的映射关系，则返回 true。
//参数:key 键
boolean containsKey(Object key)
//5. 如果此映射将一个或多个键映射到指定值，则返回 true。
//参数：value 值
boolean containsValue(Object value)
//6.如果此映射未包含键-值映射关系，则返回 true。
boolean isEmpty()
//7.返回此映射中的键-值映射关系数。
int size()
//8.返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
//参数:key 键
V get(Object key)
//9.返回此映射中包含的键的Set视图。
Set<K> keySet()
//10.返回此映射中包含的值的Collection视图。
Collection<V> values()
//11.返回此映射中包含的映射关系的Set视图。
Set<Map.Entry<K,V>> entrySet()
项目案例，测试以上部分方法：
public class Test {
public static void main(String[] args) {
Map m = new HashMap();
//第一次对指定值与映射的键进行关联，返回null
System.out.println(m.put(1, 3));//集合中存入一个键 1 一个值 3
//对已有的键操作，指定值替换旧值，打印输出旧值
System.out.println(m.put(1, 5));//替换上一次 给键 1 存入的值3替换为5
//添加两个键值对
m.put(2, 3);
m.put(3, 4);
//值可以存null
m.put(4, null);
//移除一个键的映射关系
m.remove(2);
//打印map集合
System.out.println("集合内的元素为" + m);
//查看map长度
System.out.println("集合的长度为" + m.size());
//获取指定键映射的值
System.out.println(m.get(1));
//集合中是否存在此键
System.out.println(m.containsKey(1));
//集合中是否存在此值
System.out.println(m.containsValue(1));
//集合清空
m.clear();
//集合是否为空
System.out.println(m.isEmpty());
}
}
编译运行以上程序，结果如下：
002.png
上面的程序已经尽可能的去介绍Map中常用的方法，有不详尽处可以去查看api的详细方法说明。希望读者可以通过以上案例中方法的使用，更好的理解以上案例。
4. Map集合遍历（特点）
项目案例，直接演示四种Map集合遍历方式
public class Test {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "ab");
System.out.println("集合长度为：" + map.size());
//第一种方式
System.out.println("第一种：通过Map.keySet遍历key和value：");
for (Integer in : map.keySet()) { // map.keySet()返回的是所有key的值
String str = map.get(in);// 得到每个key多对用value的值
System.out.println(in + " " + str);
}
//第二种方式
System.out.println("第二种：通过Map.entrySet使用iterator遍历key和value：");
Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Integer, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= "
+ entry.getValue());
}
//第三中方式
System.out.println("第三种：通过Map.entrySet遍历key和value");
for (Map.Entry<Integer, String> entry : map.entrySet()) {
// Map.entry<Integer,String> 映射项（键-值对） 有几个方法：用上面的名字entry
// entry.getKey() ;entry.getValue(); entry.setValue();
// map.entrySet() 返回此映射中包含的映射关系的 Set视图。
System.out.println("key= " + entry.getKey() + " and value= "
+ entry.getValue());
}
//第四中方式
System.out.println("第四种：通过Map.values()遍历所有的value，但不能遍历key");
for (String v : map.values()) {
System.out.println("value= " + v);
}
}
}
编译运行以上程序，结果如下：
003.png
二、集合HashMap类概述
键是哈希表结构，可以保证键的唯一性 。
1. 子类一HashMap类概述
存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
①键值为HashMap<String,String>
HashMap<String,String> map = new HashMap<String,String>();
map.put("3", "abc");
map.put("2", "ab");
map.put("1", "ac");
//通过键 遍历值
// 获得 map 集合中的 所有 键 组成一个 set 集合
Set<String> keySet = map.keySet();
//遍历 set 集合中的每个键 通过每个键 获取每个值
for (String string : keySet) {
System.out.println(map.get(string));
}
②键值为HashMap<Integer,String>
HashMap<Integer,String>
HashMap<Integer,String> map = new HashMap<Integer,String>();
map.put(3, "abc");
map.put(2, "ab");
map.put(1, "ac");
//通过键 遍历值
// 获得 map 集合中的 所有 键 组成一个 set 集合
Set<Integer> keySet = map.keySet();
//遍历 set 集合中的每个键 通过每个键 获取每个值
for (Integer in : keySet) {
System.out.println(map.get(in));
}
③键值为HashMap<String,Student>
public static void main(String[] args) {
//创建集合
HashMap<String,Student> hm = new HashMap<String,Student>();
// 给集合添加元素
hm.put("1", new Student(18,"小王"));
hm.put("2", new Student(20,"老王"));
hm.put("3", new Student(20,"老宋"));
//获取所有 键 组成集合 keySet
Set<String> keySet = hm.keySet();
for (String string : keySet) {// 增强 for 遍历 所有的键
Student student = hm.get(string); // 通过键 获取对应的值
System.out.println("姓名 ："+student.getName()+" 年龄 : +student.getAge());
}
}
public class Student {
int age;
String name;
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
④键值为HashMap<Student,String>
public static void main(String[] args) throws Exception {
//创建集合自定义类作为键要保证键的唯一需要在自定义类中重写equals 和hashCode
HashMap<Student, String> hm = new HashMap<Student, String>();
// 给集合添加元素
hm.put(new Student(18, "小王"), "1");
hm.put(new Student(18, "老王"), "2");
hm.put(new Student(18, "小王"), "3");
//获取所有 键 组成集合 keySet
Set<Student> keySet = hm.keySet();
for (Student student : keySet) {// 增强 for 遍历 所有的键
System.out.println(hm.get(student));
}
}
public class Student {
int age;
String name;
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
三、LinkedHashMap类概述
1. LinkedHashMap类概述
Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
四、 TreeMap类概述
键是红黑树结构，可以保证键的排序和唯一性
项目案例，HashMap和TreeMap的区别：
public class Test {
public static void main(String[] args) {
System.out.println("开始：");
Person person1 = new Person("马先生", 220181);
Person person2 = new Person("李先生", 220193);
Person person3 = new Person("王小姐", 220186);
Map<Number, Person> map = new HashMap<Number, Person>();
map.put(person1.getId_card(), person1);
map.put(person2.getId_card(), person2);
map.put(person3.getId_card(), person3);
// HashMap
System.out.println("HashMap，无序：");
for (Iterator<Number> it = map.keySet().iterator(); it.hasNext(); ) {
Person person = map.get(it.next());
System.out.println(person.getId_card() + " " + person.getName());
}
// TreeMap
System.out.println("TreeMap，升序：");
TreeMap<Number, Person> treeMap = new TreeMap<Number, Person>();
treeMap.putAll(map);
for (Iterator<Number> it = treeMap.keySet().iterator(); it.hasNext(); ) {
Person person = treeMap.get(it.next());
System.out.println(person.getId_card() + " " + person.getName());
}
System.out.println("TreeMap，降序：");
TreeMap<Number, Person> treeMap2 =
new TreeMap<Number, Person>(Collections.reverseOrder());
treeMap2.putAll(map);
for (Iterator it = treeMap2.keySet().iterator(); it.hasNext(); ) {
Person person = (Person) treeMap2.get(it.next());
System.out.println(person.getId_card() + " " + person.getName());
}
System.out.println("结束！");
}
}
public class Person {
private String name;
private int id_card;
@Override
public String toString() {
return "姓名：" + name + ",卡号：" + id_card + "]";
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, int id_card) {
super();
this.name = name;
this.id_card = id_card;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId_card() {
return id_card;
}
public void setId_card(int id_card) {
this.id_card = id_card;
}
}
在添加、删除和定位映射关系上，TreeMap类要比HashMap类的性能差一些，但是其中的映射关系具有一定的顺序。
如果不需要一个有序的集合，则建议使用HashMap类；如果需要进行有序的遍历输出，则建议使用TreeMap类。在这种情况下，可以先使用 HashMap。
TreeMap的两种排序方式
- 自然排序，集合中元素的类实现comparable接口，重写compare(Obje obj)方法。
- 比较器排序，定义一个类实现comparetor接口，将该类的实例化对象作为参数传递给集合，使集合具备比较性，也可以使用匿名内部类。
五、子类Hashtable的概述特点
1.子类Hashtable的概述特点
HashMap和Hashtable都是Map接口的典型实现类，他们之间的关系完全类似于ArrayList和Vector的关系：Hashtable是一个古老的实现类，它的出现没有完全遵循java的命名规范，并没有进行每个单词首字母大写的规范。
六、 集合案例
1. “aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
具体代码如下：
public class Test {
public static void main(String[] args) {
String str = "aababcabcdabcde";
//创建TreeMap集合
TreeMap<Character, Integer> map = new TreeMap<Character, Integer>();
char[] chs = str.toCharArray();
for (Character ch : chs) {
//判断集合中是否包含此字符，如果有，利用put方法特性进行存储
Integer value = map.get(ch);
if (value == null) {
map.put(ch, 1);
} else {
value++;
map.put(ch, value);
}
}
//遍历集合
Set<Character> set = map.keySet();
StringBuffer sb = new StringBuffer();
for (Character s : set) {
Integer value = map.get(s);
sb.append(s).append("(").append(value).append(")");
}
System.out.println(sb.toString());
}
}
2. ArrayList 嵌套 ArrayList
具体代码如下：
public class test {
public static void main(String[] args) throws Exception {
ArrayList<ArrayList<Person>> list = new ArrayList<>();
ArrayList<Person> first = new ArrayList<>(); //创建第一个班级
first.add(new Person("杨幂", 30));
first.add(new Person("李冰冰", 33));
first.add(new Person("范冰冰", 20));
ArrayList<Person> second = new ArrayList<>();
second.add(new Person("黄晓明", 31));
second.add(new Person("赵薇", 33));
second.add(new Person("陈坤", 32));
//将班级添加到学科集合中
list.add(first);
list.add(second);
//遍历学科集合
for (ArrayList<Person> a : list) {
for (Person p : a) {
System.out.println(p);
}
}
}
public static class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
}
3. ArrayList 嵌套 HashMap
具体代码如下：
public class Test {
public static void main(String[] args) {
//创建集合
ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>();
HashMap<String, String> sanguoCouples = new HashMap<String, String>();
sanguoCouples.put("周瑜", "小乔");
sanguoCouples.put("吕布", "貂蝉");
HashMap<String, String> xiyoujiCouples = new HashMap<String, String>();
xiyoujiCouples.put("牛魔王", "铁扇公主");
xiyoujiCouples.put("玉帝", "王母");
HashMap<String, String> hongloumengCouples = new HashMap<String, String>();
hongloumengCouples.put("贾琏", "王熙凤");
hongloumengCouples.put("贾宝玉", "薛宝钗");
array.add(sanguoCouples);
array.add(xiyoujiCouples);
array.add(hongloumengCouples);
//遍历集合
//获取ArrayList集合中每个HashMap元素
for (HashMap<String, String> couples : array) {
//先获取所有键
Set<String> husbands = couples.keySet();
for (String husband : husbands) {
//根据键获取值
String wife = couples.get(husband);
System.out.println(husband + "-" + wife);
}
System.out.println("---------------");
}
}
}
4. HashMap 嵌套 ArrayList
具体代码如下：
public class Test {
public static void main(String[] args) {
//创建集合对象
HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
ArrayList<String> array1 = new ArrayList<String>();
array1.add("吕布");
array1.add("周瑜");
hm.put("三国演义", array1);
ArrayList<String> array2 = new ArrayList<String>();
array2.add("令狐冲");
array2.add("林平之");
hm.put("笑傲江湖", array2);
ArrayList<String> array3 = new ArrayList<String>();
array3.add("郭靖");
array3.add("杨过");
hm.put("神雕侠侣", array3);
// 遍历集合
Set<String> set = hm.keySet();
for (String key : set) {
System.out.println(key);
ArrayList<String> array = hm.get(key);
for (String s : array) {
System.out.println("\t" + s);
}
}
}
}
七、相关面试题
1. HashMap和Hashtable的区别
①Hashtable是一个线程安全的Map实现，但HashMap是不安全的实现，所以HashMap比Hashtable性能高。
②Hashtable不予许null作为key或者value，如果试图把null值存入Hashtable中，会报出NullPointException。
2. List，Set，Map等接口是否都继承子Map接口
首先， List 与 Set 具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫 Collection。 Set 里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象，即假设 Set 集合中有了一个 A 对象，现在我要向 Set 集合再存入一个 B 对象，但 B 对象与 A 对象 equals 相等，则 B 对象存储不进去，所以， Set 集合的add 方法有一个 boolean 的返回值，当集合中没有某个元素，此时 add 方法可成功加入该元素时，则返回 true，当集合含有与某个元素 equals 相等的元素时，此时 add 方法无法加入该元素，返回结果为 false。 Set 取元素时，没法说取第几个，只能以 Iterator 接口取得所有的元素，再逐一遍历各个元素。
List 表示有先后顺序的集合，注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用 add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用 add(int index,Obj e)方法， 就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进 List 中，每调用一次 add 方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被 add 多次时，即相当于集合中有多个索引指向了这个对象，如图 x 所示。 List 除了可以以 Iterator 接口取得所有的元素，再逐一遍历各个元素之外，还可以调用 get(index i)来明确说明取第几个。
Map 与 List 和 Set 不同，它是双列的集合，其中有 put 方法，定义如下： put(obj
key,objvalue)，每次存储时，要存储一对 key/value，不能存储重复的 key，这个重复的规则也是按 equals 比较相等。取则可以根据 key 获得相应的 value，即 get(Object key)返回值为 key 所对应的 value。另外，也可以获得所有的 key 的结合，还可以获得所有的 value的结合，还可以获得 key 和 value 组合成的 Map.Entry 对象的集合。
List 以特定次序来持有元素，可有重复元素。 Set 无法拥有重复元素,内部排序。 Map 保存key-value 值， value 可多值。
