java集合之Map

1.   Map集合之基础增删查等功能

public class Demo1_Map {

    /*
     * Map集合是以键值对的形式存在，底层依赖的是set集合
     * 
     * a. 添加功能
     *         V put(K key, V value)
     *             如果键是第一次存入，则就直接存储元素，返回null  (其实本质是和键存在是一样的，只是覆盖的null)
     *             如果键不是第一次存入，就用值把以前的替换掉，返回以前的值
     * b.  删除功能
     *         void clear()   移除所有的键值信息
     *      V remove(Object key)   删除指定键对应的元素值，并把值返回,当所传的键值不存在时就返回null
     * c.  判断功能
     *         boolean containsKey(Object key)  判断集合中是否包含此键
     *         boolean containsValue(Object value)  判断集合是否包含指定的值
     *         boolean isEmpty()     判断集是否为空
     * d.  获取功能
     *         Set<Map.Entry<K,V>> entrySet()
     *         V get(Object key)  根据键获取值
     *         Set<K> keySet()    获取集合中所有键的集合
     *         Collection<V> values()    获取集合中所有值的集合,返回一个Conllection
     * e.  长度功能
     *         int size()   返回集合中所有键值对的个数   
     * 
     */
    public static void main(String[] args) {

        //demo1();
        //demo2();
        //demo3();
        Map<String, Integer> map = new HashMap<>();
        Integer i1 = map.put("张三", 23);
        Integer i2 = map.put("李四", 24);
        Integer i3 = map.put("王五", 25);
        Integer i4 = map.put("赵六", 26);
        Integer i5 = map.put("张三", 26);
        Set<Entry<String, Integer>> set = map.entrySet();
        System.out.println(set);               //[李四=24, 张三=26, 王五=25, 赵六=26]
        System.out.println(map.values());      //[24, 26, 25, 26]
        
     }

    /**
     * 判断功能
     */
    public static void demo3() {
        Map<String, Integer> map = new HashMap<>();
        map.put("lisi", 24);
        boolean b1 = map.containsKey("lisi");   
        System.out.println(b1);                 //true
        boolean b2 = map.containsValue(24) ;  
        System.out.println(b2);                 //true
    }

    /**
     * 删除功能
     */
    public static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("李四", 24);
        Integer i = map.remove("张三");    
        System.out.println(i);        //null
        Integer i1 = map.remove("李四");
        System.out.println(i1);       //24
    }

    /**
     * 添加功能
     */
    public static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        Integer i1 = map.put("张三", 23);
        Integer i2 = map.put("李四", 24);
        Integer i3 = map.put("王五", 25);
        Integer i4 = map.put("赵六", 26);
        Integer i5 = map.put("张三", 26);
        System.out.println(map);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
    }

}

2.  遍历Map集合

public class Demo2_Map {

    /**
     * @param args
     * 遍历map集合
     * 
     */
    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);
        
        /*
          使用迭代器进行遍历Map集合
        Set<String> set = map.keySet();
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            System.out.println(key + "=" + map.get(key));
        }*/
        
        
        //使用增强for循环进行遍历Map集合
        for (String string : map.keySet()) {
            System.out.println(string + "=" + map.get(string));
        }
    }

}

 3. 通过Entry对Map集合进行遍历

public class Demo3_MapEntry {

    /*
     * 通过Entry对Map集合进行遍历
     * Entry中后获取键的方法getKey() 和   获取值的方法 getValue()
     */
    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);
        
        /*
         *使用迭代器遍历集合 
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> it = entry.iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> en = it.next();
            String key = en.getKey();
            Integer value = en.getValue();
            System.out.println(key + "=" + value);
        }*/
    
        
        //通过增强for循环遍历集合
        for (Map.Entry<String, Integer> en : map.entrySet()) {
            System.out.println(en.getKey() + "=" + en.getValue());
        }
    }

}

4. HashMap

public class Demo4_HashMap {

    /*
     * 向Map集合中存入自定义对象，将自定义对象作为集合的key
     * 
     */
    public static void main(String[] args) {
        Map<Student, String> map = new HashMap<>();
        map.put(new Student("张三",23), "北京");
        map.put(new Student("张三",23), "上海");
        map.put(new Student("李四",24), "广州");
        //重写hashCode() 和  equals() 方法前  {Student [name=张三, age=23]=北京, Student [name=李四, age=24]=广州, Student [name=张三, age=23]=上海}
        //System.out.println(map); 
        //重写hashCode() 和  equals() 方法后 {Student [name=张三, age=23]=上海, Student [name=李四, age=24]=广州}
        System.out.println(map);   
        
    }

}

5. LinkedHashMap   怎么存就怎么取

public class Demo5_LinkedHashMap {

    /*
     * LinkedHashMap  怎么存就怎么取
     */
    public static void main(String[] args) {

        LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
        lhm.put("张三", 23);
        lhm.put("赵六", 26);
        lhm.put("王五", 25);
        lhm.put("李四", 24);
        System.out.println(lhm);  //{张三=23, 赵六=26, 王五=25, 李四=24}
    }

}

6. TreeMap

public class Demo6_TreeMap {

    /*
     * 通TreeSet一样，也是有两种排序方式：
     *   1. 使用对象自己进行排序
     *   2. 使用比较器进行排序
     */
    public static void main(String[] args) {
        //demo2();
        //demo1();
        
        /*
         * TreeMap传入Comparator对象，重写compare方法，先比较姓名，再比较年龄
         */
        TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {

            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getName().compareTo(s2.getName());
                return num == 0 ? s1.getAge() - s2.getAge() : num;
            }
        });
        tm.put(new Student("张三",23), "北京");
        tm.put(new Student("李四", 24),"上海");
        tm.put(new Student("赵六", 26),"广州");
        tm.put(new Student("王五", 25),"深圳");
        System.out.println(tm); 
        //{Student [name=张三, age=23]=北京, Student [name=李四, age=24]=上海, Student [name=王五, age=25]=深圳, Student [name=赵六, age=26]=广州}

    }

    /**
     * 普通的引用数据类型
     */
    public static void demo2() {
        TreeMap<String, Integer> ts = new TreeMap<>();
         ts.put("张三", 23);
         ts.put("王五", 25);
         ts.put("李四", 24);
         ts.put("赵六", 26);
         System.out.println(ts); //{张三=23, 李四=24, 王五=25, 赵六=26}
    }

    /**
     * 自定义类实现Comparator接口，重写compareTo()方法，先比较年龄，后比较姓名
     */
    public static void demo1() {
        TreeMap<Student, String> tm = new TreeMap<>();
         tm.put(new Student("张三",23), "北京");
         tm.put(new Student("李四", 24),"上海");
         tm.put(new Student("赵六", 26),"广州");
         tm.put(new Student("王五", 25),"深圳");
         System.out.println(tm); 
         //当自定义类没有实现comparable时直接添加会报java.lang.ClassCastException: com.map.Student cannot be cast to java.lang.Comparable
        //{Student [name=张三, age=23]=北京, Student [name=李四, age=24]=上海, Student [name=王五, age=25]=深圳, Student [name=赵六, age=26]=广州}
    } 

}

6.1  Student 自定义类

public class Student implements Comparable<Student> {

    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public int compareTo(Student o) {
        int num = this.age - o.age;               //优先比对年龄
        return num == 0 ? this.name.compareTo(o.name) : num;
    }

}

7. HashMap和Hashtable的区别
     * 共同点：
     *      底层都是哈希算法，都是双列集合
     * 区别：
     *      1. HashMap是线程不安全的，效率高，JDK 1.2 版本
     *      Hashtable 是线程安全的，效率低，JDK 1.0版本
     *      2. HashMap可以存储null键和null值
     *         Hashtable不可以

8.  集合练习之实现斗地主的获得牌、洗牌、发牌

 * 需求：实现斗地主的洗牌、发牌、看牌（按所拿的牌排序显示）
 * 分析：
 *   1  获得一副牌
 *   2  将牌存入HashMap集合中，将每张牌对应的索引存入list集合中
 *   3  根据list集合中存的索引对牌进行洗牌
 *   4  根据洗完牌的索引进行发牌
 *   5  对每个人发的牌及底牌进行查看

public class Demo9_Doudizhu {

    public static void main(String[] args) {

        //获得一副牌并将牌存入HashMap集合，将索引存入list集合
        String[] digit = {"2", "4", "5","6", "7","8","9","10","A","J","Q","k","3"};
        String[] color = {"红桃","方片","梅花","黑桃"};
        
        HashMap<Integer, String> hm = new HashMap<>();
        List<Integer> list = new ArrayList<>();
        int index = 0;
        for(String s1 : digit) {
            for(String s2 : color) {
                hm.put(index, s2.concat(s1));
                list.add(index);
                index++;
            }
        }
        hm.put(index, "小王");
        list.add(index);
        index++;
        hm.put(index,"大王");
        list.add(index);
        
        //洗牌
        Collections.shuffle(list);
        
        //发牌，创建相应的TreeSet集合用于存储发个每个人的牌和底牌
        TreeSet<Integer> gaojin = new TreeSet<>();
        TreeSet<Integer> longwu = new TreeSet<>();
        TreeSet<Integer> me = new TreeSet<>();
        TreeSet<Integer> dipai = new TreeSet<>();
        for (Integer i : list) {
            if(i >= list.size() - 3) {
                dipai.add(list.get(i));
            }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(hm, gaojin, "高进");
        lookPoker(hm, longwu, "龙武");
        lookPoker(hm, me, "我");
        lookPoker(hm, dipai, "底牌");
        
    }
    
    /**
     * @param hm
     * @param ts
     * @param name
     * 看牌函数
     */
    public static void lookPoker(HashMap<Integer, String> hm, TreeSet<Integer> ts, String name) {
        System.out.print(name + "的牌是：");
        for (Integer i : ts) {
            System.out.print(hm.get(i) + " ");
        }
        System.out.println();
    }

}

9.  集合相关总结

     * Collectiion
     *         List(存取有序，有索引，可以重复)
     *             ArrayList
     *                 底层是数组实现的，线程不安全，查找和修改快，增加和删除慢
     *             LinkedList
     *                 底层是链表实现的，线程不安全，增和删快，查和修改慢
     *             Vector
     *                 底层是数组实现的，线程是安全的，无论增删改查都满
     *             如果查找和修改多，用ArrayList
     *             如果增和删多，用LinkedList
     *             如果都多，用ArrayList
     *         Set(存储无序，无索引，不可重复)
     *             HashSet
     *                 底层是哈希算法实现的
     *                 LinkedHashSet
     *                     底层是链表实现的，但是也是可以保证元素唯一，和HashSet原理一样
     *             TreeSet
     *                 底层是二叉树算法实现的
     *             一般在开发的时候不需要对存储的元素排序，所以在开发的一般用HashSet，HashSet的效率比较高
     *             TreeSet在面试的时候比较多，问你有几种排序方式，和几种排序方式的区别
     * Map
     *         HashMap
     *             底层是哈希算法，针对键
     *             LinkedHashMap
     *                 底层是链表，针对键
     *         TreeMap
     *             底层是二叉树算法，针对键
     *         开发中用HashMap比较多