java map和python字典的区别 java map dictionary

day16

• Map:

• Map:
• Map中的常用方法
• Map集合遍历思路
• HashMap
• LinkedHashMap
• HashMap和Hashtable的关系

• Collections工具类:

• 斗地主：

Map:

Map:

1、Map：双列集合的顶层接口
2、Map：单词含义，地图，地图上的每个点，都表示了生活中的一个具体位置。地图的点和生活中的位置，有一个一一对应的关系，这种关系是通过穷举的方式来描述的。
3、Map：描述的就是一个数据（key）到另一个数据（value）的映射关系（对应关系）
一个数据（key）：就是有规律的，容易记忆的，简单的一个数据
另一个数据（value）：没有规律的，不容易记忆的，复杂的一个数据
大多数都是根据key来寻找value
4、映射：对应关系
{key1=value1,key2=value2,key3=value3,key4=value4…}
穷举罗列：{1=1, 2=4, 3=9, 4=16, 5=25}
5、java中Map就是使用的穷举罗列的方式来描述映射关系
6、Map的特点：
Key（键）是唯一的，value（值）不是唯一的
每个键都只能对应确定唯一的值
7、Map和Collection的区别：
Map是双列集合，Collection是单列集合
Map的键是唯一的，Collection中的Set子接口中的元素是唯一的
Map的所有操作和算法都是针对键有效，Collection中的set子接口中的操作和算法针对元素有效

Map中的常用方法

1、增加键值对：put(K key, V value)

2、删除方法：

根据给定的键，删除对应的键值对：remove(K key)

清空集合：clear()

3、获取方法：

获取集合的大小：size()，获取键值对对数

根据给定的键，获取对应的值：V get(K key)

4、判断方法：

判断集合中是否存在某个键：containsKey(Object obj)

判断集合中是否存在某个值：containsValue(Object obj)

5、修改方法：

根据给定的键，修改对应的值：put(K key, V value)

如果在集合中已经存在key这个键，那么使用put方法，就是修改其对应的值；如果集合中不存在key这个键，那么使用put方法，就是在集合中增加了一个键值对

Map集合遍历思路

需求：键盘录入一个字符串，统计每个字符出现的次数

例如，录入aaaabbccddd!@#@#KaTeX parse error: Expected 'EOF', got '#' at position 2: @#̲%cc66ff

打印出来：a有4个，b有2个，c有4个，d有3个，!有1个，@有3个，$有2个，%有1个，6有2个，f有2个

HashMap

LinkedHashMap

1、是HashMap的一个子类，数组加上双重链表进行存储，有序
2、和HashMap的不同之处在于，具有可预知的迭代顺序，存储键值对的顺序和遍历集合时取出键值对的顺序一致。

HashMap和Hashtable的关系

1、HashMap和Hashtable都是用于存储键和值的对应关系，都是Map的实现类，都是使用哈希表的方式存储。
2、不同点：
1、版本不同，Hashtable是jdk1.0版本出现的，HashMap是jdk1.2版本出现的
2、线程安全性不同，Hashtable是线程安全的，HashMap是线程不安全的
3、Hashtable不能存储null键null值，HashMap可以存储null键null值
4、命名规则：Hashtable时期没有形成完全严格的命名要求

Collections工具类:

斗地主：

public class Test1 {
 /**
 * 斗地主：1.有牌 （54） 四种花色（红桃，方块，黑桃，梅花）（A—K）大小王
 * //生成54 张牌
 *  * 2.洗牌
 * 3.发牌 3 * 17 + 底牌 3 = 54
 * 4.看牌
 */
 public static void main(String[] args) {
 //写一个集合保存生成的扑克牌
 ArrayList picket = new ArrayList<>();//定义两个数组，一个数组表示花色
    String[] huase = {"方块", "梅花", "红桃", "黑桃"};
    //定义一个数组表示
    String[] nums = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    for (int i = 0; i < huase.length; i++) {
        //循环数字
        for (int j = 0; j < nums.length; j++) {
            picket.add(huase[i] + nums[j]);
        }
    }
    picket.add("小王");
    picket.add("大王");// System.out.println(list);
 //洗牌
 Collections.shuffle(picket);
 // System.out.println(list);//选手1
    ArrayList<String> gaojin = new ArrayList<>();
    //选手2
    ArrayList<String> liudehua = new ArrayList<>();
    //选手3
    ArrayList<String> me = new ArrayList<>();
    //底牌的集合
    ArrayList<String> dipai = new ArrayList<>();

    //发牌
    for (int i = 0; i <picket.size() ; i++) {
        //把底牌拿出来
        if(i>=picket.size()-3){
            dipai.add(picket.get(i));
        }else if(i % 3==0){
            liudehua.add(picket.get(i));
        }else if(i % 3==1){
            gaojin.add(picket.get(i));
        }else if(i % 3==2){
            me.add(picket.get(i));
        }
    }

    System.out.println("gaojin:\t"+gaojin);
    System.out.println("liudehua:\t"+liudehua);
    System.out.println("me:\t"+me);
    System.out.println("dipai:\t"+dipai);
}}
public class Test2 {
 /**
 * 斗地主：1.有牌 （54） 四种花色（红桃，方块，黑桃，梅花）（A—K）大小王
 * //生成54 张牌
 *  * 2.洗牌
 * 3.发牌 3 * 17 + 底牌 3 = 54
 * 4.看牌
 */public static void main(String[] args) {
    //把索引放入一个集合，只能洗集合
    ArrayList<Integer> list = new ArrayList<>();

    HashMap<Integer,String> map = new HashMap<>();

    //定义两个数组，一个数组表示花色
    String[] huase = {"方块", "梅花", "红桃", "黑桃"};
    //定义一个数组表示
    String[] nums = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    int index = 0;
    for (int i = 0; i <nums.length ; i++) {
        for (int j = 0; j <huase.length ; j++) {
            map.put(index,huase[j]+ nums[j]);
            list.add(index);
            index++;
        }
    }
    System.out.println(index);
    list.add(index);
    map.put(index,"小王");
    index++;
    map.put(index,"大王");
    list.add(index);
    System.out.println(list);

    //洗牌    TreeSet(自动排序的功能)
    Collections.shuffle(list);// System.out.println(list);
//选手1
    TreeSet<Integer> gaojin = new TreeSet<>();
    //选手2
    TreeSet<Integer> liudehua = new TreeSet<>();
    //选手3
    TreeSet<Integer> me = new TreeSet<>();
    //底牌的集合
    TreeSet<Integer> dipai = new TreeSet<>();

    //发牌
    for (int i = 0; i <list.size() ; i++) {
        //把底牌拿出来
        if(i>=list.size()-3){
            dipai.add(list.get(i));
        }else if(i % 3==0){
            liudehua.add(list.get(i));
        }else if(i % 3==1){
            gaojin.add(list.get(i));
        }else if(i % 3==2){
            me.add(list.get(i));
        }
    }/* System.out.println(“gaojin:\t”+gaojin);
 System.out.println(“liudehua:\t”+liudehua);
 System.out.println(“me:\t”+me);
 System.out.println(“dipai:\t”+dipai);*///看牌
    lookPicket("高进",gaojin,map);
    lookPicket("刘德华",liudehua,map);
    lookPicket("我",me,map);
    lookPicket("底牌",dipai,map);
}


//看牌：名字   选手当前牌的索引   map

public static void lookPicket(String name,TreeSet<Integer> treeSet,
                              HashMap<Integer,String> map){
    System.out.println(name+":");
        Iterator<Integer> iter = treeSet.iterator();
        while(iter.hasNext()){
            System.out.print(map.get(iter.next())+" ");
    }
    System.out.println("");   //选手换行
}}