面向对象.Day04map

map定义和与collection的区别

map继承关系图

collection中的集合,元索是孤立存在的(理解为单身) ,向集合中存储元素采用一个个元素的方式存储。
Map中的集合, 元素是成对存在的(理解为夫妻)。每个元索由键与值两部分组成，通过键可以找对所对应的
值。
Collection中的集合称为单列集合，Map 中的集合称为双列集合。
需要注意的是，Map 中的集合不能包含重复的键，值可以重复;每个键只能对应一个值。

map常用方法和子集合

Map<K,V>集合:
特点:
1)双列集合，一个元素包含两个值(key, value)
2)key ivalue的数据类型可以相同，也可以不同
3)Key不允许重复value是可以重复的
4) key和value是一一对应的
添加值:

删除值:

获取值:

判断key存不存在:

public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("诸葛亮","火烧赤壁");
        map.put("黄盖","苦肉计");
        map.put("关羽","败走麦城");
        System.out.println(  map.get("黄盖"));
        System.out.println(map);
        System.out.println(map.containsKey("赵云"));
        map.remove("关羽");
        System.out.println(map);
    }
    

Map集合的第一-种遍历方式: 通过键找值的方式方法:
Set keySet() 返回此地图中包含的键的Set视图。
实现步骤: .
1.使用keySet()，把Map集合中的所有的key取出来，存入到一个Set 集合中
2.逾/iset集合，获取到Map集合中的每一个key
3.通iMap集合中的V get(Object key), 获取到所有的Value值。输出

Set<String> name = map.keySet();
        for (String s : name) {
            String thing = map.get(s);
            System.out.println(s+"="+thing);
        }

Map集合的第一.种遍历方式: 使用Entry 对象遍历
Entry:键值对(key-value)
方法:
Map按口:
Set<Map. Entry<K, V>> entrySet() 返回此地图中包含的映射的Set视图。
java.util Interface Map. Entry<K, V>:
K getKey()返回与此条目相对应的键。
V getValue()返回与此条目相对应的值。
实现步骤:
1)使Map集合中的entrySet()方法，把集合中多个Entry对象取出来，存储到一↑Set 集合中
2)遍历Set集合，获取到每一个Entry
3)调Entry中的getKey() 和getValue()方法获取键和值

 Set<Map.Entry<String, String>> set = map.entrySet();
        for (Map.Entry<String, String> stringStringEntry : set) {
            String a = stringStringEntry.getKey();
            String b = stringStringEntry.getValue();
            System.out.println(a + "=" + b);
        }

hashmap

HashMap<K,V>.集合:
特点:
1)底层是哈希表数据结构:查询速度特别快
2). 无序的集合，存储和取出元素的顺序可能不一样

底层是哈希表数据结构，是非线程安全，
在JDK8之后，如果我们哈希表的单向链表中
的元素超过了8个:单向链表
这种结构就会变成一-种红黑树的数据结构，
当红黑树上的节点少于6时，会重新把红黑树变成
单向链表数据结构。
这种方式也是为了提高检索效率，二叉树的检索会
再次缩小范围。提高效率。
初始化容量: 16, 默认加载因子: 0.75
扩容:扩容后的容量必须是原容量的2倍
HashMap集合元素的key和value值允许为空null

面试题: HashMap是线程安全的吗?
开发中多线程安全用哪个Map集合啊?
答:不是，用concurrentHashMap

LinkedHashmap

Hashtable

注意: Java 1.2之后，如果不需要线程安全的实现，建i议使用HashMap代Hashtable。
如果需要线程安全的并发实现，那么建i使ConcurrentHashMap代Hashtable。
HashTable开发中不使用，但是它的子类Properties属性集类还在使用，
此类是唯一一 个 和IO相结合的集合类。

TreeSet和TreeMap

TreeSet/TreeMap:

1. TreeSet集合底层实际上就是一个TreeMap
2. TreeMap集合底层数据结构是:自平衡二叉树
   3.网TreeSet集合中放入元素，等同于放入 了TreeMap集合的key部分了
3. TreeSet集合中的元素是无序不可重复的。但是它可以按照元素大小顺序自动排序，
   所以，它是一个可排序集合

JDK9对集合添加的优化

通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 add方法调用，使得代码重复。

public class Demo01 {
public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("abc");
list.add("def");
list.add("ghi"); System.out.println(list);
}
}

Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。
例子：

public class HelloJDK9 {
public static void main(String[] args) { Set<String> str1=Set.of("a","b","c");
//str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合
System.out.println(str1);  Map<String,Integer> str2=Map.of("a",1,"b",2); System.out.println(str2);
List<String> str3=List.of("a","b"); System.out.println(str3);
}

需要注意以下两点：
1:of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如HashSet，ArrayList等待；
2:返回的集合是不可变的；

Debug调试程序

可以直接让代码逐行执行,查看到代码执行的过程,调试程序中出现的bug。
使用方式：在行号的右边，用鼠标左键点击，添加断点（每个方法的第一行，哪里有bug点哪里）右键，选择Debug执行程序,程序会停留在添加的第一个断点处。
执行程序快捷键：Fn+F8:逐行执行程序;Fn+F7:进入方法中;shift+F8:跳出方法;Fn+F9:跳到下一个断点,如果没有下一个断点,会结束程序;Ctrl+F2:退出Debug模式;如果以上快捷键不行,可以直接点以下的按键.。

模拟斗地主洗牌发牌(有序)

1.准备牌：
完成数字与纸牌的映射关系：
使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
2.洗牌：
通过数字完成洗牌发牌
3.发牌：
将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。存放的过程中要求数字大小与斗地主规则的大小对应。
将代表不同纸牌的数字分配给不同的玩家与底牌。
4.看牌：
通过Map集合找到对应字符展示。
通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。

具体实现:

public class DouDiZhu {
    public static void main(String[] args) {
        //1.准备牌
        //创建Map集合，存储牌的索引和组装好的牌
        HashMap<Integer,String> poker = new HashMap<>();
        //创建List集合存储牌的索引
        ArrayList<Integer> pokerIndex = new ArrayList<>();
        //定义两个集合，存储花色和牌的序号
        ArrayList<String> colors= new ArrayList<>();
        ArrayList<String> numbers = new ArrayList<>();
        Collections.addAll(colors,"♠","♥","♣","♦");
        Collections.addAll(numbers,"2","A","K","Q","J","10","9","8","7","6","5","4","3");
        //把大王和小王存储到集合中
        //定义一个牌的索引
        int index = 0;
        poker.put(index,"大王");
        pokerIndex.add(index);
        index++;
        poker.put(index,"小王");
        pokerIndex.add(index);
        index++;
        //循环嵌套两个集合，组装52张牌
        for (String number : numbers) {
            for (String color : colors) {
                poker.put(index,color+number);
                pokerIndex.add(index);
                index++;
            }
        }
        //2.洗牌
        Collections.shuffle(pokerIndex);
        //3.发牌
        //1.定义四个集合存储牌
        ArrayList<Integer> player01 = new ArrayList<>();
        ArrayList<Integer> player02 = new ArrayList<>();
        ArrayList<Integer> player03 = new ArrayList<>();
        ArrayList<Integer> dipai = new ArrayList<>();
        //遍历
        for (int i = 0; i < pokerIndex.size(); i++) {
            Integer in = pokerIndex.get(i);
            if(i>=51){
                dipai.add(in);
            }else if(i%3==0){
                player01.add(in);
            }else if(i%3==1){
                player02.add(in);
            }else if(i%3==2){
                player03.add(in);
            }

        }
        //4.排序
        Collections.sort(player01);
        Collections.sort(player02);
        Collections.sort(player03);
        Collections.sort(dipai);
        //5.看牌
        //lookPoker(name,poker,list);
        lookPoker("刘德华",poker,player01);
        lookPoker("周润发",poker,player02);
        lookPoker("周星驰",poker,player03);
        lookPoker("底牌",poker,dipai);
    }
    public static void lookPoker(String name,HashMap<Integer,String > poker,ArrayList<Integer> list){
        //输出玩家姓名，不换行
        System.out.print(name+":");
        //遍历玩家或者底牌的集合，获取牌的索引
        for(Integer key:list){
            //使用牌的索引，去Map中找对应的牌
            String value = poker.get(key);
            System.out.print(value+" ");
        }
        System.out.println();//打印完每个玩家的牌。换一行
    }

}