JAVA　集合三

Map集合

java.util 下的接口Map<K,V>，将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值

Map接口和Collection接口的不同：

• Map是双列的,Collection是单列的
• Map的键唯一,Collection的子体系Set是唯一的
• Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

HashSet底层依赖于Map,HashSet只是隐藏了Map的值部分，只显示键部分

public boolean add(E e) {
    return map.put(e, PRESENT)==null; // HashSet的add方法使用了Map
}

Map集合的部分方法：

public static void main(String[] args){
       Map<String,Integer> map = new HashMap<>();
       // 添加功能
       Integer i = map.put("张三", 23);
       Integer i1 = map.put("张三", 12);
       Integer i2 = map.put("李四", 12);
       System.out.println(i);  // null
       System.out.println(i1); // 23  ,现在张三的值为12
       System.out.println(map);// {李四=12, 张三=12}
       
       // 删除功能
       // map.clear(); // 删除所有集合
       // Integer i3 = map.remove("张三");
       // System.out.println(i3); // 12  根据key删除，返回key对应的值
       
       // 判断功能
       boolean b1 = map.containsKey("张三"); //判断集合是否包含key
       boolean b2 = map.containsValue(12); // 判断集合是否包含value
       boolean b3 = map.isEmpty(); // 判断集合是否为空
       
       // 获取功能
       Collection<Integer> c = map.values(); // 获取Map集合所有value,返回一个Collection集合 
       System.out.println(c);//[12, 12]
       Integer i5 = map.get("张三"); // 12 根据健获取值
       
       // 获取长度
       System.out.println(map.size()); // 2 
}

Map集合的遍历：

public class names {
    public static void main(String[] args){
        Map<String,Integer> hm = new HashMap<>();
        hm.put("zhangsan", 12);
        hm.put("lisi", 14);
        hm.put("zhangsan", 18);
        hm.put("wangwu", 14);
        System.out.println(hm); // {lisi=14, zhangsan=18, wangwu=14}
        
//      第一种遍历方式：通过ｋｅｙ获取值
        Set<String> sh = hm.keySet();
        Iterator<String> is = sh.iterator();
        while(is.hasNext()){
            String key = is.next();
            Integer value = hm.get(key);
            System.out.println(value); // 14 18 14
        }
//      第二种增强ｆｏｒ循环（常用）
        for (String key : sh) {
            System.out.println("key="+ key + " value="+hm.get(key));
        }
        
//      第三种迭代，返回一个对象，通过对象获取键和值
//      Map.Entry说明Entry是Map的内部接口，将键和值封装成了Entry对象并存储在Set集合中
        Set<Map.Entry<String, Integer>> entrySet = hm.entrySet();
        // 获取每一个对象
        Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
        while(it.hasNext()){
            //　获取每一个Entry 对象
            Map.Entry<String, Integer> en = it.next();
            System.out.println(en.getKey()+en.getValue());
        }
        
//      第三种迭代的增强ｆｏｒ循环迭代方式
        for (Entry<String, Integer> entry : entrySet) {
            System.out.println(entry.getKey()+entry.getValue());
        }
    }
}

LinkedHashMap

底层是链表实现的可以保证怎么存就怎么取

LinkedHashMap<String,Integer> lhm = new LinkedHashMap<>();
lhm.put("zhangsan", 12);
lhm.put("lis", 12);
lhm.put("wangwu", 12);
System.out.println(lhm);

TreeMap

public static void main(String[] args){
        TreeMap<Animal,Integer> tm = new TreeMap<>();
        tm.put(new Animal(11,"张三"), 11);
        tm.put(new Animal(14,"赵六"), 14);
        tm.put(new Animal(15,"王五"), 15);
        tm.put(new Animal(10,"李四"), 10);
        System.out.println(tm);  // 按照１０　１１　１４　１５的排序 传比较器比较常见
    　　
}
class Animal implements Comparable<Animal>{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Animal(){}
    public Animal(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    @Override
    public int compareTo(Animal o) {
        int num  =this.age - o.age;  // 以年龄排序第一位
        return num == 0? this.name.compareTo(o.name): num; //  以姓名排序第二
    }
    @Override
    public String toString() {
        return "Animal [age=" + age + ", name=" + name + "]";
    }   
}

试题：统计一串字符串字符出现的次数：

public static void main(String[] args){
        String str = "abcdddcsdfsdfdfeweewrwedddddd";
        Map<Character,Integer> map = new HashMap<>();
        // 将字符串变为字符数组
        char[] charArr = str.toCharArray();
        for (char c : charArr) {
            map.put(c, map.containsKey(c)?map.get(c)+1:1);
        }
        
        // Set<Character> totle = map.keySet(); 两个步骤合二为一
        for (Character c : map.keySet()) {
            System.out.println(c +":"+map.get(c));
        }
}

HashMap和Hashtable的区别

HashMap和Hashtable的区别

• Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高
• Hashtable不可以存储null键和null值,HashMap可以存储null键和null值

HashMap<String, Integer> hm = new HashMap<>();
hm.put(null, 12);
hm.put("zhangsan", null);
System.out.println(hm);

Hashtable<String,Integer> ht = new Hashtable<>();
ht.put(null, 12);  //报错 java.lang.NullPointerException
ht.put("zhangsan", null); // java.lang.NullPointerException
System.out.println(ht);

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)

斗地主发牌：

    public static void main(String[] args){
//                  //买一副牌
        String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] color = {"方片","梅花","红桃","黑桃"};
        HashMap<Integer, String> hm = new HashMap<>();          //存储索引和扑克牌
        ArrayList<Integer> list = new ArrayList<>();            //存储索引
        int index = 0;                                          //索引的开始值
        for(String s1 : num) {
            for(String s2 : color) {
                hm.put(index, s2.concat(s1));                   //将索引和扑克牌添加到HashMap中
                list.add(index);                                //将索引添加到ArrayList集合中
                index++;
            }
        }
        hm.put(index, "小王");
        list.add(index);
        index++;
        hm.put(index, "大王");
        list.add(index);
        //洗牌
        Collections.shuffle(list);
        //发牌
        TreeSet<Integer> gaojin = new TreeSet<>();
        TreeSet<Integer> longwu = new TreeSet<>();
        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));                         //将list集合中的索引添加到TreeSet集合中会自动排序
            }else if(i % 3 == 0) {
                gaojin.add(list.get(i));
            }else if(i % 3 == 1) {
                longwu.add(list.get(i));
            }else {
                me.add(list.get(i));
            }
        }
        
        //看牌
        lookPoker("高进", gaojin, hm);
        lookPoker("龙五", longwu, hm);
        lookPoker("冯佳", me, hm);
        lookPoker("底牌", dipai, hm);
        
    }
    public static void lookPoker(String name,TreeSet<Integer> ts,HashMap<Integer, String> hm) {
        System.out.print(name + "的牌是:");
        for (Integer index : ts) {
            System.out.print(hm.get(index) + " ");
        }
        
        System.out.println();
    }