Java--Map集合

• Map中的元素是双列的，一列是键，一列是指，键和值是一一对应的。
• Map集合的数据结构只针对键有效，与值无关

Map集合中常用的方法

HashMap

• 演示：

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

public class Test1 {
    public static void main(String[] args) {
        HashMap<Integer, String> hm = new HashMap<>();
        //在集合中添加元素
        hm.put(1,"小黄");
        hm.put(3,"小张");
        hm.put(2,"小红");
        hm.put(6,"小蓝");
        hm.put(5,"小美");
        hm.put(3,"小前");
        /**
         * 遍历集合有两种方式：
         * 1--先找出键，然后通过键找到值
         * 2--直接找出所有键值对
         */
        //根据键找值
        Set<Integer> key = hm.keySet();
        for(Integer in:key){
            String s = hm.get(in);
            System.out.println(in+"--"+s);
        }
        System.out.println("-----------------------");
        //直接找出键值对
        Set<Map.Entry<Integer, String>> entries = hm.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            Integer key1 = entry.getKey();
            String value = entry.getValue();
            System.out.println(key1+"--"+value);
        }
    }
}
程序结果为：
1--小黄
2--小红
3--小前
5--小美
6--小蓝
-----------------------
1--小黄
2--小红
3--小前
5--小美
6--小蓝

HashMap存储自写类时重写hashcode和equals方法才能实现元素唯一，因为HashMap的数据结构只是针对键的

• 演示Student类中未重写hashcode和equals：

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

public class Test2 {
    public static void main(String[] args) {
        HashMap<Integer, Student> hm = new HashMap<>();
        hm.put(4,new Student("小黄",20));
        hm.put(3,new Student("小张",19));
        hm.put(6,new Student("小黄",20));
        hm.put(1,new Student("小红",17));
        hm.put(3,new Student("小蓝",15));
        //找出键，然后找到值
        Set<Integer> key = hm.keySet();
        for (Integer in : key) {
            Student student = hm.get(in);
            System.out.println(in+"--"+student.getName()+student.getAge());
        }
    }
}
运行结果为：
1--小红17
3--小蓝15
4--小黄20
6--小黄20
仍然存在重复元素，重写hashcode和equals方法后即可消除重复元素

• HashMap和HashTable的区别：
  • HashMap: 线程不安全,效率高.允许null值和null键
  • Hashtable: 线程安全 , 效率低.不允许null值和null键

LinkedHashMap

• LinkedHashMap的数据结构是哈希表和链表，因此是有序且唯一
• 演示：

import java.util.LinkedHashMap;
import java.util.Set;

public class Test4 {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        map.put(1,"小黄");
        map.put(3,"小张");
        map.put(2,"小红");
        map.put(6,"小蓝");
        map.put(5,"小美");
        map.put(3,"小前");
        Set<Integer> key = map.keySet();
        for (Integer in : key) {
            String s = map.get(in);
            System.out.println(in+"--"+s);
        }
    }
}
运行结果为：
1--小黄
3--小前
2--小红
6--小蓝
5--小美

TreeMap

• TreeMap的数据结构时哈希表和红黑树，可以实现键唯一和排序
• 演示：

import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

public class Test3 {
    public static void main(String[] args) {
        /**
         * 自写类作为键时必须实现Comparable接口
         */
        TreeMap< Student,Integer> treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num1=o1.getAge()-o2.getAge();
                int num2=num1==0?o1.getName().length()-o2.getName().length():num1;
                int num3=num2==0?o1.getName().compareTo(o2.getName()):num2;
                return num3;
            }
        });
        //在集合中添加元素
       treeMap.put(new Student("小黄",20),4);
       treeMap.put(new Student("小张",19),3);
       treeMap.put(new Student("小黄",20),6);
       treeMap.put(new Student("小红",17),1);
       treeMap.put(new Student("小蓝",15),3);

       //遍历集合
        Set<Student> students = treeMap.keySet();
        for (Student stu : students) {
            Integer integer = treeMap.get(stu);
            System.out.println(integer+"--"+stu.getName()+stu.getAge());
        }

    }
}
程序结果为：
3--小蓝15
1--小红17
3--小张19
6--小黄20

集合的嵌套和输出

• 演示：

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

public class Test5 {
    public static void main(String[] args) {
        /**
         *     基础班
         *             张三 20
         *             李四 22
         *      就业班
         *             王五 21
         *             赵六 23
         */
        /**
         * 把基础班和就业班作为键先放在一个大的集合里面，然后这个大集合
         * 的值存储的是两个个小集合，小集合中人名为键，年龄为值
         */
        //先声明小集合
        HashMap<String, Integer> jc = new HashMap<>();
        jc.put("张三",20);
        jc.put("李四",22);
        HashMap<String, Integer> jy = new HashMap<>();
        jy.put("王五",21);
        jy.put("赵六",23);
        //声明大集合，键位基础班和就业班，值位jc和jy这两个集合
        ***//注意hm中的HashMap必须写明泛型***
        HashMap<String, HashMap<String,Integer>> hm = new HashMap<>();
        hm.put("基础班",jc);
        hm.put("就业班",jy);
        //现在对hm集合进行遍历即可
        Set<String> keySet = hm.keySet();
        for (String s : keySet) {
            System.out.println(s);
            HashMap<String, Integer> map = hm.get(s);
            Set<String> keySet1 = map.keySet();
            for (String s1 : keySet1) {
                Integer integer = map.get(s1);
                System.out.println("\t\t"+s1+"\t\t"+integer);
            }
        }
    }
}

斗地主排序版

import java.util.*;

public class DouDiZhu {
    public static void main(String[] args) {
        String[] colol={"♥","♠","♦","♣"};
        String[]num={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        HashMap<Integer, String> puke = new HashMap<>();
        ArrayList<Integer> indexs = new ArrayList<>();
        int index=0;
        //装派
        for(String s:num){
            for(String c:colol){
                puke.put(index,s.concat(c));
                indexs.add(index);
                index++;
            }
        }
        puke.put(index,"大王");
        indexs.add(index);
        index++;
        puke.put(index,"小王");
        indexs.add(index);
        //洗牌
        Collections.shuffle(indexs);
        Collections.shuffle(indexs);
        //发牌
        TreeSet<Integer> dipai = new TreeSet<>();
        TreeSet<Integer> player1 = new TreeSet<>();
        TreeSet<Integer> player2 = new TreeSet<>();
        TreeSet<Integer> player3 = new TreeSet<>();
        for (int i = 0; i < indexs.size(); i++) {
            if(i>=indexs.size()-3){
                dipai.add(indexs.get(i));
            }else if(i%3==1){
                player1.add(indexs.get(i));
            }else if(i%3==2){
                player2.add(indexs.get(i));
            }else {
                player3.add(indexs.get(i));
            }
        }
        //看牌
        show(player1,puke);
        show(player2,puke);
        show(player3,puke);
        show(dipai,puke);
    }
    public static void show(TreeSet<Integer> ts,HashMap<Integer, String> puke){
       for(Integer in:ts){
           String s = puke.get(in);
           System.out.print("\t"+s);

       }
        System.out.println();
    }
}