Map集合

Map集合
HashMap和Hashtable的区别
Collections(集合工具类)
集合练习
模拟斗地主(洗牌,发牌,看牌)

Map集合概述和特点

Map接口概述
	查看API可以知道：
	将键映射到值的对象
	一个映射不能包含重复的键
	每个键最多只能映射到一个值
Map接口和Collection接口的不同
	Map是双列的,Collection是单列的
	Map的键唯一,Collection的子体系Set是唯一的
	Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

Map集合的功能概述

A:Map集合的功能概述
	a:添加功能 
		V put(K key,V value):添加元素。这个其实还有另一个功能?替换
			如果键是第一次存储，就直接存储元素，返回null
			如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
	b:删除功能
		void clear():移除所有的键值对元素
		V remove(Object key)：根据键删除键值对元素，并把值返回
	c:判断功能
		boolean containsKey(Object key)：判断集合是否包含指定的键
		boolean containsValue(Object value):判断集合是否包含指定的值
		boolean isEmpty()：判断集合是否为空
	d:获取功能
		Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
		V get(Object key):根据键获取值
		Set<K> keySet():获取集合中所有键的集合
		Collection<V> values():获取集合中所有值的集合
	e:长度功能
		int size()：返回集合中的键值对的对数

HashMap集合键是Stirng值是String的案例

​

		HashMap	允许插入null键 null值
​	A:案例演示:	HashMap集合键是Stirng值是String的案例
package com.xupt.hh;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class hashmap {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("贾乃亮", "李小璐");
        hashMap.put("文章", "马伊琍");
        hashMap.put("大郎", "金莲");
        hashMap.put("陈思成", "佟丽娅");
        Set<Map.Entry<String, String>> entries = hashMap.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
        Set<String> keySet = hashMap.keySet();
        for (String s : keySet) {
            String s1 = hashMap.get(s);
            System.out.println(s+"  "+s1);

        }

    }
}

LinkedHashMap的概述和使用

A:LinkedHashMap的概述:	Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
B:LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一
			元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
			Map集合的数据结构只和键有关

TreeMap集合键是String值是String的案例

A: TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性  
	    排序分为自然排序和比较器排序 
	    线程是不安全的效率比较高
	    TreeMap 键不允许插入null

4、package com.xupt.hh;

import sun.reflect.generics.tree.Tree;

import java.util.*;

public class hashmap {
public static void main(String[] args) {
TreeMap<String,String> treeMap = new TreeMap<>(new Comparator() {
@Override
public int compare(String o1, String o2) {
int num=o1.length()-o2.length();
int num2=num==0?o1.compareTo(o2):num;
return num2;
}
});

    treeMap.put("贾乃亮", "李小璐");
    treeMap.put("文章", "马伊琍");
    treeMap.put("大郎", "金莲");
    treeMap.put("陈思成", "佟丽娅");
    Set<Map.Entry<String, String>> entries =treeMap.entrySet();
    for (Map.Entry<String, String> entry : entries) {
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key+"="+value);
    }
    Set<String> keySet = treeMap.keySet();
    for (String s : keySet) {
        String s1 = treeMap.get(s);
        System.out.println(s+"="+s1);
    }

}
}

统计字符串中每个字符出现的次数

A:案例演示:	需求：统计字符串中每个字符出现的次数
	package com.xupt.hh;

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class tongji {
public static void main(String[] args) {
//请编写程序，统计一个字符串中每个字符出现的次数
Scanner scanner = new Scanner(System.in);
System.out.println(“请输入一行字符”);
String s = scanner.nextLine();
HashMap<Character, Integer> map = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (!map.containsKey©){
map.put(c,1);
}else{
Integer index=map.get©;
index++;
map.put(c,index);
}
}
StringBuilder sb = new StringBuilder();
Set keySet = map.keySet();
for (Character key : keySet) {
sb.append(key).append("(").append(map.get(key)).append(")");
}
String s1 = sb.toString();
System.out.println(s1);
}
}

集合嵌套

案例演示


package com.xupt.hh;
import com.xupt.hahao.student;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class qiantao {
    public static void main(String[] args) {
        ArrayList<student> jc = new ArrayList<>();
        jc.add(new student("张三", 20));
        jc.add(new student("李四", 22));
        ArrayList<student> jy = new ArrayList<>();
        jy.add(new student("王五", 21));
        jy.add(new student("赵六", 23));
        HashMap<String, ArrayList<student>> min1 = new HashMap<>();
        min1.put("基础班", jc);
        min1.put("就业班", jy);
        HashMap<String, HashMap<String, ArrayList<student>>> min2 = new HashMap<>();
        min2.put("传智播客", min1);
        Set<String> keySet = min2.keySet();
        for (String key : keySet) {
            System.out.println(key);
            HashMap<String, ArrayList<student>> a = min2.get(key);
            Set<String> b = a.keySet();
            for (String s : b) {
                System.out.println("\t"+s);
                ArrayList<student> c = a.get(s);
                for (student student : c) {
                    System.out.println("\t"+"\t"+student.getName()+"  "+student.getAge());
                }
            }
        }

HashMap和Hashtable的区别

	HashMap和Hashtable的区别:	查看API可以知道
	HashMap: 线程不安全,效率高.允许null值和null键
	Hashtable: 线程安全 , 效率低.不允许null值和null键

Collections工具类的概述和常见方法讲解

A:Collections类概述:	针对集合操作 的工具类
B:Collections成员方法
	public static <T> void sort(List<T> list):					排序,默认按照自然顺序
	public static <T> int binarySearch(List<?> list,T key):		二分查找
	public static <T> T max(Collection<?> coll):				获取最大值
	public static void reverse(List<?> list):					反转
	public static void shuffle(List<?> list):						随机置换

18.20_集合框架(模拟斗地主洗牌和发牌)(理解)

	案例演示:	模拟斗地主洗牌和发牌，牌有排序
Public class doudizhu{
public static void main(String[] args) {
        HashMap<Integer, String> pokerBox = new HashMap<>();
        //定义花色
        String[] colors = {"♣", "♠", "♥", "◆"};
        // 定义牌号数组
        String[] nums = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10","J", "Q", "K"};
        //定义一个索引集合
        ArrayList<Integer> indexs = new ArrayList<>();
        int index=0;
        for (String num : nums) {
            for (String color : colors) {
                pokerBox.put(index,num.concat(color));
                indexs.add(index);
                index++;
            }
        }
        //手动添加大小王
        pokerBox.put(index,"?");
        indexs.add(index);
        index++;
        pokerBox.put(index,"☀");
        indexs.add(index);

       // //洗牌，洗索引集合
        Collections.shuffle(indexs);
       // //发牌
        TreeSet<Integer> 韦小宝 = new TreeSet<>();
        TreeSet<Integer> 双儿 = new TreeSet<>();
        TreeSet<Integer> 宁儿 = new TreeSet<>();
        TreeSet<Integer> 底牌 = new TreeSet<>();
        //发牌发的是索引
        for (int i = 0; i < indexs.size(); i++) {
            if (i >= indexs.size() - 3) {
                // 留底牌
                底牌.add(indexs.get(i));
            }else
            if (i % 3 == 0) {
                韦小宝.add(indexs.get(i));
            } else if (i % 3 == 1) {
                双儿.add(indexs.get(i));
            } else if (i % 3 == 2) {
                宁儿.add(indexs.get(i));
            }
        }
        //看牌
        lookPoker("韦小宝",韦小宝,pokerBox);
        lookPoker("双儿", 双儿, pokerBox);
        lookPoker("宁儿", 宁儿, pokerBox);
        lookPoker("底牌", 底牌, pokerBox);
    }
    private static void lookPoker(String name, TreeSet<Integer> set, HashMap<Integer, String> pokerBox) {
        System.out.println(name);
        for (Integer key : set) {
            System.out.print(pokerBox.get(key)+"  ");
        }
        System.out.println();

    }
}