1:map集合(掌握)
(1)Map集合存储的是键值对元素。键是唯一的,值可以重复。
(2)Map和Collection的区别?
A:Map是双列集合，存储的元素键值对，键唯一，值可以重复。
B:Collection是单列集合，存储的元素是单一的，List集合可以重复，Set集合元素唯一。
(3)Map集合的功能
A:添加功能
V put(K key,V value)
B:删除功能
remove(K key)
C:判断功能
containsKey(K key)
containsValue(V value)
D:获取功能
V get(K key)
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet() 返回所有键值对对应关系
Map.Entry是Map内的一个内部接，包含的主要方法
K getKey()
V getValue()
V setValue(V value) 设置值
E:长度功能
int size()
(4)Map集合的数据结构问题：
Map集合的数据结构对键有效，跟值无关。
它的底层数据结构和Set中讲解的一致。
如果是哈希表结构，就需要重写hashCode()和equals()，保证存储元素的唯一性。
如果是二叉树结构，就有两种方式：Comparable,Comparator，保证存储的元素的有序性。 例子程序如下：
mport java.util.Comparator; import java.util.TreeMap; /* * 使用TreeMap存储<Person,String> */ public class Demo7 { public static void main(String[] args) { //第一种方式：使键的类型实现Comparable接口，完成比较大小的逻辑 TreeMap<Person, String> map = new TreeMap<>(); Person p = new Person("唐嫣", 28); String s = "貂蝉"; Person p2 = new Person("卢俊义",42); String s2 = "玉麒麟"; Person p3 = new Person("2张顺",32); String s3 = "浪里白条"; Person p4 = new Person("1花荣",32); String s4 = "小李广"; map.put(p, s); map.put(p2, s2); map.put(p3, s3); map.put(p4, s4); System.out.println(map); //第二种方式：创建集合对象时给予对应的比较器Comparator TreeMap<Person, String> map2 = new TreeMap<>(new Comparator<Person>(){ @Override public int compare(Person o1, Person o2) { int result = o1.getName().compareTo(o2.getName()); if(result==0) { result = o1.getAge()-o2.getAge(); } return result; }}); map2.put(p, s); map2.put(p2, s2); map2.put(p3, s3); map2.put(p4, s4); System.out.println(map2); } }
public class Person implements Comparable<Person>{ private String name; private int age; public Person() { super(); // TODO Auto-generated constructor stub } public Person(String name, int age) { super(); this.name = name; this.age = age; } //先比较年龄,后比较姓名 @Override public int compareTo(Person o) { //this：新传进来的对象 o：旧的对象 int result = this.age-o.age; if(result==0) { result = this.name.compareTo(o.name); } return result; } @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; Person other = (Person) 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; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
(5)Map的遍历方式
假设有一个HashMap集合，存储的键和值都是String类型。名称叫hm。
A:根据键找值(掌握)
a:获取所有键的集合
b:遍历键的集合，获取到每一个键
c:根据键找值
代码体现：
Set<String> set = hm.keySet();
for(String key : set) {
String value = hm.get(key);
System.out.println(key+"---"+value);
}
B:根据键值对对象找键和值(理解)
a:获取所有键值对对象的集合
b:遍历键值对对象的集合，获取到每一个键值对对象
c:根据键值对对象获取键和值
代码体现：
Set<Map.Entry<String,String>> set = hm.entrySet();
for(Map.Entry<String,String> me : set) {
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"---"+value);
}
(6)案例：
A:统计一个字符串中每个字符出现的次数
import java.util.Set; import java.util.TreeMap; /** * “aabcbdeeeeedbddcc”,获取字符串中每一个字母出现的次数。要求结果:a(2)b(3)c(3)d(4)e(5) * 思路：字符串中的字符和数字存到treemap集合里，然后遍历输出 */ public class MapTest1 { public static void main(String[] args) { // 定义一个字符串(可以改进为键盘录入) String content ="aababcabcdabcde"; // 定义一个TreeMap集合 TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>(); //把字符串转换为字符数组 char[] chs = content.toCharArray(); //遍历字符数组，得到每一个字符 for(char ch : chs){ //拿刚才得到的字符作为键到集合中去找值，看返回值 Integer i = tm.get(ch); //是null:说明该键不存在，就把该字符作为键，1作为值存储 if(i == null){ tm.put(ch, 1); }else { //不是null:说明该键存在，就把值加1，然后重写存储该键和值 i++; tm.put(ch,i); } } //定义字符串缓冲区变量 StringBuilder sb= new StringBuilder(); //遍历集合，得到键和值，进行按照要求拼接 Set<Character> set = tm.keySet(); for(Character key : set){ Integer value = tm.get(key); sb.append(key).append("(").append(value).append(")"); } //把字符串缓冲区转换为字符串输出 String result = sb.toString(); System.out.println("result:"+result); } }
B:Map集合的嵌套存储和遍历
import java.util.ArrayList; import java.util.HashMap; import java.util.Set; /* * List集合内元素为Map集合 */ public class Test { public static void main(String[] args) { //List嵌套List //创建集合对象 ArrayList<ArrayList<String>> arrayList = new ArrayList<ArrayList<String>>(); //创建元素对象 ArrayList<String> list = new ArrayList<String>(); list.add("吕布"); list.add("赵云"); list.add("典韦"); list.add("关羽"); list.add("马超"); ArrayList<String> list2 = new ArrayList<String>(); list2.add("高俅"); list2.add("高衙内"); list2.add("蔡京"); list2.add("西门大官人"); //将集合元素放入集合对象 arrayList.add(list); arrayList.add(list2); System.out.println(arrayList); //List嵌套Map //创建集合对象 ArrayList<HashMap<String, Person>> arrayList2 = new ArrayList<HashMap<String, Person>>(); //创建元素对象 HashMap<String, Person> hashMap = new HashMap<String, Person>(); hashMap.put("五虎上将之一", new Person("关羽",38)); hashMap.put("五虎上将之二", new Person("张飞",34)); hashMap.put("五虎上将之三", new Person("赵云",32)); hashMap.put("五虎上将之四", new Person("马超",30)); hashMap.put("五虎上将之五", new Person("黄忠",60)); HashMap<String, Person> hashMap2 = new HashMap<String, Person>(); hashMap2.put("行者", new Person("武松",28)); hashMap2.put("神行太保", new Person("戴宗",34)); hashMap2.put("入云龙", new Person("公孙胜",32)); hashMap2.put("九纹龙", new Person("史进",30)); hashMap2.put("拼命三郎", new Person("石秀",29)); //将集合元素添加到集合中 arrayList2.add(hashMap); arrayList2.add(hashMap2); //迭代外层的ArrayList，里边的每个元素均为Map对象 for (HashMap<String, Person> myMap : arrayList2) { //HashMap<String, Person> myMap //返回该map的所有key的Set集合 Set<String> keySet = myMap.keySet(); for (String key : keySet) {//迭代key的集合，获取每一个key Person value = myMap.get(key); //通过键获取值 //拼写字符串，完成对每个map中元素的打印 System.out.println(key+":"+value.getName()+" "+value.getAge()); } } } }
import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; /* * 使用Map嵌套List */ public class Test2 { public static void main(String[] args) { //创建map集合 Map<String, ArrayList<Person>> map = new HashMap<String, ArrayList<Person>>(); //创建集合元素 String class1 = "0315基础班"; ArrayList<Person> arrayList = new ArrayList<Person>(); arrayList.add(new Person("唐嫣",28)); arrayList.add(new Person("龙哥",23)); arrayList.add(new Person("小龙女",16)); arrayList.add(new Person("涛哥",31)); String class2 = "0426就业班"; ArrayList<Person> arrayList2 = new ArrayList<Person>(); arrayList2.add(new Person("唐嫣",28)); arrayList2.add(new Person("高圆圆",32)); arrayList2.add(new Person("baby",26)); arrayList2.add(new Person("熊黛林",32)); //将集合元素添加到集合中 map.put(class1, arrayList); map.put(class2, arrayList2); //遍历map集合 Set<Entry<String,ArrayList<Person>>> entrySet = map.entrySet(); Iterator<Entry<String, ArrayList<Person>>> iterator = entrySet.iterator(); while (iterator.hasNext()) { Map.Entry<java.lang.String, java.util.ArrayList<cn.itcast2.Person>> entry = (Map.Entry<java.lang.String, java.util.ArrayList<cn.itcast2.Person>>) iterator .next(); String key = entry.getKey(); ArrayList<Person> listValue = entry.getValue(); System.out.println(key); Iterator<Person> iterator2 = listValue.iterator(); while (iterator2.hasNext()) { Person person = (Person) iterator2.next(); System.out.println(person); } } } }
import java.util.HashMap; import java.util.Map; import java.util.Set; /* * Map嵌套Map */ public class Test3 { public static void main(String[] args) { Map<String, Map<String, Person>> map = new HashMap<String, Map<String,Person>>(); Map<String, Person> innerMap = new HashMap<String, Person>(); innerMap.put("师傅", new Person("唐三藏",34)); innerMap.put("大师兄", new Person("孙悟空",500)); innerMap.put("二师兄", new Person("朱悟能",800)); innerMap.put("三师弟", new Person("沙悟净",600)); Map<String, Person> innerMap2 = new HashMap<String, Person>(); innerMap2.put("顽石", new Person("贾宝玉",14)); innerMap2.put("十二金钗之一", new Person("薛宝钗",19)); innerMap2.put("十二金钗之二", new Person("王熙凤",28)); map.put("西游记", innerMap); map.put("红楼梦", innerMap2); Set<String> keySet = map.keySet(); for (String key : keySet) { Map<String, Person> value = map.get(key); System.out.println(key); Set<String> keySet2 = value.keySet(); for (String innerKey : keySet2) { Person innerValuePerson = value.get(innerKey); System.out.println(innerKey+":"+innerValuePerson); } } } }
(7)Map集合的体系
Map
|--HashMap
|--LinkedHashMap
|--Hashtable
|--TreeMap
A:HashMap和Hashtable的区别?
HashMap键无序，不可重复，不安全，速度快，键和值都可以存放空值。
Hashtable键无序，不可重复，安全，速度慢，键和值都不可以存放空值。
B:LinkedHashMap的键的特点?
键有序，不可重复。
2:集合总结(什么时候使用谁?)
是否键值对：
是：Map
是否排序：
是：TreeMap
否：HashMap
不知道，HashMap
否：Collection
是否唯一：
是：Set
是否排序：
是：TreeSet
否：HashSet
不知道，HashSet
否：List
增删多：LinkedList
查询多：ArrayList
不知道，ArrayList
不知道，用ArrayList
3:集合体系总结
集合：
|--Collection
|--List
|--ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
|--Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
|--LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
|--Set
|--HashSet
底层数据结构是哈希表。
如何保证唯一性?
依赖hashCode()和equals()
顺序：
先判断hashCode()值是否相同：
是：继续走equals()，看返回值
true:元素重复。不添加
false:元素不重复。添加
否：直接添加
|--LinkedHashSet
底层数据结构是链表和哈希表。
由链表保证有序(存储和取出一致)。
由哈希表保证元素唯一。
|--TreeSet
底层数据结构是二叉树。
如果保证唯一性?
根据返回值是否是0。
如何排序：
自然排序：Comparable
比较器排序：Comparator
|--Map
|--HashMap
|--LinkedHashMap
|--Hashtable
|--TreeMap
附:例子
1、Map嵌套Map的例子
import java.util.HashMap; import java.util.Set; /** * 使用集合进行以下分类： 北京总部 -JAVAEE班：5个 -JAVASE班：8个 上海分校 -JAVAEE：4个 -JAVASE：7个 */ public class Map3 { public static void main(String[] args) { //创建HashMap集合 HashMap<String,HashMap<String,String>> hashMap=new HashMap<String,HashMap<String,String>>(); //创建元素 HashMap<String,String> innerHashMap1=new HashMap<String,String>(); innerHashMap1.put("JavaEE班","5个"); innerHashMap1.put("JavaSE班","8个"); HashMap<String,String> innerHashMap2=new HashMap<String,String>(); innerHashMap2.put("JavaEE班","4个"); innerHashMap2.put("JavaSE班","7个"); //添加元素 hashMap.put("北京总部",innerHashMap1); hashMap.put("上海分校",innerHashMap2); //遍历输出 Set<String> keySet=hashMap.keySet(); //外层key集合 for(String key:keySet){ System.out.println(key); //输出外层key HashMap<String,String> innerHashMap= hashMap.get(key);//获取外层key对应的Value值 Set<String> inKeySet=innerHashMap.keySet();//内层key集合 for(String innerkey:inKeySet){ String innerValue=innerHashMap.get(innerkey); System.out.println(" "+innerkey+":"+innerValue);//输出内层key与内层Vakue } } } }
2、模拟地主洗牌发牌
方法一：
import java.util.ArrayList; import java.util.Collections; /* * 模拟斗地主洗牌发牌版本1 */ public class Test5 { public static void main(String[] args) { /*准备： * 花色：♠♥♦♣ ArrayList * 数字：3,4,5,6,7,8,9,10,J,Q,K,A,2 ArrayList * 大小王：☺☻ * 得有一副54张的牌 ArrayList * 洗牌： * 打乱这副牌的顺序 * 发牌： * 将54张牌分发到4个list手中，前三个17张，最后一个3张 * player ArrayList * player2 ArrayList * player3 ArrayList * dipai ArrayList */ //准备花色 ArrayList<String> color = new ArrayList<String>(); color.add("♠"); color.add("♥"); color.add("♦"); color.add("♣"); //准备数字 ArrayList<String> number = new ArrayList<String>(); Collections.addAll(number, "3","4","5","6","7","8","9","10","J","Q","K","A","2"); //准备一副新牌 ArrayList<String> cards = new ArrayList<String>(); for (String thisColor : color) { for (String thisNumber : number) { cards.add(thisColor+thisNumber); } } //加入大小王 cards.add("大☻"); cards.add("小☺"); System.out.println(cards); //洗牌 Collections.shuffle(cards); System.out.println(cards); //发牌 //准备四个list作为3个玩家和底牌 ArrayList<String> player = new ArrayList<String>(); ArrayList<String> player2 = new ArrayList<String>(); ArrayList<String> player3 = new ArrayList<String>(); ArrayList<String> dipai = new ArrayList<String>(); //遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和dipai手中 for (int i = 0; i < cards.size(); i++) { if(i>=51) {//分配底牌 dipai.add(cards.get(i)); } else { if(i%3==0) { player.add(cards.get(i)); }else if(i%3==1) { player2.add(cards.get(i)); }else { player3.add(cards.get(i)); } } } //看牌 System.out.println(player); System.out.println(player2); System.out.println(player3); System.out.println(dipai); } }
方法二：
import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.TreeSet; /* * 斗地主洗牌发牌版本2：每个人手中的元素是有顺序的。 */ public class Test5 { /*准备： * 花色：♠♥♦♣ ArrayList * 数字：3,4,5,6,7,8,9,10,J,Q,K,A,2 ArrayList * 大小王：☺☻ * ！！！！！！！！定义一个map集合：用来将数字与每一张牌进行对应 * 得有一副54张的牌 ArrayList里边为1-54的数 * 洗牌： * 打乱这副牌的顺序 * 发牌： * 将54张牌分发到4个TreeSet手中，前三个17张，最后一个3张 * player TreeSet * player2 TreeSet * player3 TreeSet * dipai TreeSet */ public static void main(String[] args) { //准备花色 ArrayList<String> color = new ArrayList<String>(); color.add("♠"); color.add("♥"); color.add("♦"); color.add("♣"); //准备数字 ArrayList<String> number = new ArrayList<String>(); Collections.addAll(number, "3","4","5","6","7","8","9","10","J","Q","K","A","2"); //定义一个map集合：用来将数字与每一张牌进行对应 HashMap<Integer, String> hashMap = new HashMap<Integer, String>(); int index = 1; for (String thisNumber : number) { for (String thisColor : color) { hashMap.put(index++, thisNumber+thisColor); } } //加入大小王 hashMap.put(index++, "小☺"); hashMap.put(index++, "大☻"); System.out.println(hashMap); //得有一副54张的牌 ArrayList里边为1-54的数的新牌 ArrayList<Integer> cards = new ArrayList<Integer>(); for (int i = 1; i <= 54; i++) { cards.add(i); } //洗牌 Collections.shuffle(cards); System.out.println(cards); //创建三个玩家和底牌 TreeSet<Integer> player = new TreeSet<Integer>(); TreeSet<Integer> player2 = new TreeSet<Integer>(); TreeSet<Integer> player3 = new TreeSet<Integer>(); TreeSet<Integer> dipai = new TreeSet<Integer>(); //遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和dipai手中 for (int i = 0; i < cards.size(); i++) { if(i>=51) { dipai.add(cards.get(i)); } else { if(i%3==0) { player.add(cards.get(i)); }else if(i%3==1) { player2.add(cards.get(i)); }else { player3.add(cards.get(i)); } } } //看牌 for (Integer key : dipai) { System.out.print(hashMap.get(key)+", "); } System.out.println(); for (Integer key : player) { System.out.print(hashMap.get(key)+", "); } System.out.println(); for (Integer key : player2) { System.out.print(hashMap.get(key)+", "); } System.out.println(); for (Integer key : player3) { System.out.print(hashMap.get(key)+", "); } } }