黑马程序员----集合框架（二）

------- android培训、java培训、期待与您交流！ ----------

一、Map

Map集合独立于Collection，不继承Collection接口。Map集合一次存储键值对，也就是两个对象，键保证了唯一性，值可以重复。集合中每个键只能对应一个值。Map<k,v> 中 K作为键的对象的泛型 Key。V作为值的对象的泛型 Value。

1、Map接口中的方法

V put(K,V) 将键值对存储到集合，当存储了重复的键的时候，方法返回被覆盖之前的值，除了这个情况外，方法返回null

V get(K,V) 获取，根据键获取值。返回映射的值，集合中没有这个键返回null。

boolean containsKey(k  key) 判断集合中有没有这个键，有返回true。

boolean containsValue(V  value) 判断集合中有没有这个值，有返回true。

boolean isEmpty()  判断集合有没有键值对，没有键值对返回true。

V remove(K,Key)  根据键，删除这组键值对，返回删除前的值。

2、Map集合的迭代方法

1）keySet方法。实现步骤：Map中的所有键，存储到Set集合，迭代Set集合获取到的元素为Map中的键，调用Map集合中的get方法获取键对应的值。

Map<String,Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

//调用Map集合方法keySet获取一个Set集合，Set中存储的是Map中的键
Set<String> set = map.keySet();
//迭代Set集合
Iterator<String> it = set.iterator();
while(it.hasNext()){
//it.next获取到的是Set元素，正好是Map中的键
String key = it.next();
//调用Map集合方法 get 获取值
Integer value = map.get(key);

System.out.println(key+"..."+value);

2）entrySet方法。实现步骤：entrySet（）方法获取键值对关系对象，存储到Set集合，迭代Set集合使用返回的Map.Entry对象方法 getKey。

Map<String,Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

//1. 集合方法entrySet()获取Map.Entry对象，存储到Set集合
Set<Map.Entry<String, Integer>> set =   map.entrySet();
//2.迭代Set集合
Iterator<Map.Entry<String, Integer>> it = set.iterator();
while(it.hasNext()){
//3. it.next()是Map.Entry接口的实现类对象
Map.Entry<String, Integer> entry = it.next();
//4 .通过内部接口Entry方法 getKey  getValue
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"..."+value);

3、增强for循环。增强for循环不能直接遍历Map集合，但是可以间接遍历。

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

Set<Map.Entry<String, Integer>> set = map.entrySet();
for(Map.Entry<String, Integer> entry : map.entrySet()){
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"..."+value);
}

二、HashMap

HashMap子类自身特性：底层数据结构就是哈希表，允许存储null值，null键，是线程不安全的结合，运行速度快。存储到HashMap集合中，用于建的对象，必须实现hashCode和equals方法，保证唯一性。迭代方法也依靠KeySet或entrySet。

//创建HashMap集合，键存储Student对象，值存储String
HashMap<Student,String> hm = new HashMap<Student, String>();

hm.put(new Student("a",19), "华北地区");
hm.put(new Student("b",22), "华南地区");
hm.put(new Student("c",21), "西南地区");
hm.put(new Student("d",18), "东北地区");
hm.put(new Student("a",19), "西北地区");
keySet(hm);
entrySet(hm);

public static void entrySet(HashMap<Student,String> hm){
//entrySet方法，获取Map.Entry对象，存储到Set集合
Set<Map.Entry<Student, String>> set = hm.entrySet();
//迭代Set集合
Iterator<Map.Entry<Student, String>> it = set.iterator();
while(it.hasNext()){
//next方法获取出的是 Map.Entry对象
Map.Entry<Student, String> entry = it.next();
//Map.Entry接口方法 getKet  getValue
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"..."+value);
}
}

public static void keySet(HashMap<Student,String> hm){
//keySet方法，获取所有键，存储到Set集合
Set<Student> set = hm.keySet();
//迭代Set集合
Iterator<Student> it = set.iterator();
while(it.hasNext()){
//next方法获取出来的是Set中的元素，Map中的键 Student对象
Student key = it.next();
//Map集合方法get获取值
String value = hm.get(key);

System.out.println(key+".."+value);
}
}

三、TreeMap

TreeMap自身特点：对存储到集合中的键进行排序，不理会值。要求是存储的键对象必须拥有自然顺序，或者指定的计较器。线程不安全，运行速度快。

TreeMap<Student,String> tree = new TreeMap<Student, String>(new StudentAgeComprator());
tree.put(new Student("pakuiao",30), "菲律宾");
tree.put(new Student("meiweise",32), "美国");
tree.put(new Student("jackson",58),"美国");
tree.put(new Student("bushi",60), "美国");
for(Student key : tree.keySet()){
String value = tree.get(key);
System.out.println(key+"..."+value);
}

四、Map集合与Collection集合的区别

1、Map中一次存储的是键值对。

      Collection中一次存储的是单个元素。

2、Map的存储使用的是put方法。

      Collection存储使用的是add方法。

3、Map的取出时将Map转成Set，再使用迭代器取出。

      Collection取出，直接使用迭代器。

4、如果对象很多，必须使用容器存储。

     如果元素存在着映射关系，可以优先考虑使用Map存储。

     如果没有映射关系，可以使用Collection存储。

五、集合练习之斗地主发牌，并排序。

import java.util.*;
public class DouDiZhuSort {
public static void main(String[] args) {
//创建Map集合，HashMap，键是牌序号，值是点数+花色
//序号利用变量 从0开始 51
//创建List，ArrayList存储编号
HashMap<Integer,String> map = new HashMap<Integer, String>();
ArrayList<Integer> array = new ArrayList<Integer>();
int index = 0;
//定义数组，2个，保存花色和点数
String[] colors = {"♦","♣","♥","♠"};
String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
for(String number:numbers){
 for(String color : colors){
//map 存储序号+点数花色
map.put(index, color+number);
array.add(index);
index++;
}
}

//将王存储到集合
map.put(index, "小王");
array.add(index);
index++;
map.put(index, "大王");
array.add(index);
//System.out.println(map);//存储的键是序号，值是点数+花色
//System.out.println(array);//存储是序号

//洗牌
Collections.shuffle(array);
//System.out.println(array);查看随机排列效果。

//创建4个集合接收发牌
//接收到的是牌的序号，对序号进行排序 TreeSet
TreeSet<Integer> player1 = new TreeSet<Integer>();
TreeSet<Integer> player2 = new TreeSet<Integer>();
TreeSet<Integer> player3 = new TreeSet<Integer>();
TreeSet<Integer> dipai = new TreeSet<Integer>();

for(int x = 0 ; x < array.size() ;x++){
if(x>=array.size()-3){
dipai.add(array.get(x));
}else if(x%3==0){
player1.add(array.get(x));
}else if(x%3==1){
player2.add(array.get(x));
}else if(x%3==2){
player3.add(array.get(x));
}
}
lookPoker("player1", player1, map);
lookPoker("player2", player2, map);
lookPoker("player3", player3, map);
lookPoker("底牌", dipai, map);
}
//调用看牌的方法，手上的牌是个序号，使用需要到Map中查点数花色
public static void lookPoker(String name,TreeSet<Integer> tree,HashMap<Integer,String> map){
System.out.print(name+" ");
//遍历集合是TreeSet，获取到的牌的序号
for(Integer key : tree){
//根据序号，当作键，到Map中找值
String value = map.get(key);
System.out.print(value+"  ");
}
System.out.println();
}
}