笨鸟先飞——Java基础Map集合学习

package study;

import java.util.*;
import java.util.Set;

/**
 * Created by dell on 2017/1/23.
 */
public class Map {
    private static boolean a = false;//全局变量


    public static void main(String[] args){
        method_put();
        method_putAll();
        common();
    }

    public static void method_put(){
        java.util.Map<String,String> map = new HashMap<String, String>();
        map.put("1","1");
        map.put("2","2");
        map.put("3","3");
        map.put("4","4");
        map.put("5","5");
        map.put("5","5");
        map.put("6",null);
        map.put(null,null);

        System.out.println(map);//打印结果：{null=null, 3=3, 2=2, 1=1, 6=null, 5=5, 4=4}。

        /**
         * 说明map的键的唯一性，无序性，键值可为空
         */
    }

    public static void method_putAll(){
        java.util.Map<String,String> map = new HashMap<String, String>();
        map.put("a","1");
        map.put("b","2");
        map.put("c","3");
        map.put("d","4");

        java.util.Map<String,String> map1 = new HashMap<String, String>();
        map1.put("c","5");
        map1.put("e","6");

        map.putAll(map1);
        System.out.println(map);//打印结果：{d=4, e=6, b=2, c=5, a=1}

        /**
         * 说明map的键唯一性，相同键添加，值以最后为主。
         */
    }

    /**
     * 对于集合存在很多相通的地方，size(),remove()，clean()……
     */

    public static void common(){
        java.util.Map<String,String> map = new HashMap<String, String>();
        map.put("a","1");
        map.put("b","2");
        map.put("c","3");
        map.put("d","4");

        if (map.containsKey("c")){
            a = true;
            System.out.println("判断map中的键是否包含【c】---" + a );
        }else {
            System.out.println("判断map中的键是否包含【c】---" + a );
        }

        if (map.containsValue("6")){
            System.out.println("判断map中的值包含【6】");
        }else {
            System.out.println("判断map中的值不包含【6】" );
        }

        /**
         * 误区：map中的get和list中的get方法不同
         * map中的get ：get("key")参数为map中的键，返回的是此键对应的值
         * list中的get: get(index) 参数为list元素下标，返回的是在此下标下的元素
         */
        /*for (int i=0; i<map.size();i++){
            System.out.println("循环遍历map中的元素====第【"+i+"】个为===="+map.get(i));
        }*/
        //所以以上的for循环是错误的！

        //正确使用例：
        System.out.println(map.get("a")); //打印结果：1

        /**
         *  我们要想全部获取或者任意获取map中的key和value,我们该怎么做：
         *  遍历获取map中的key-value有四种方法
         */

        /*
         * NO.1.利用entrySet()返回此映射中包含的映射关系的 Set 视图。 Map.Entry表示映射关系。
         * entrySet()：迭代后可以e.getKey()，e.getValue()取key和value。返回的是Entry
         * I like
         * 推荐: 尤其是容量大时
         */

        java.util.Set<java.util.Map.Entry<String,String>> entries = map.entrySet();
        for (java.util.Map.Entry<String,String> entry : entries){
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("利用映射关系的 Set 视图获取的键值对=="+"键["+key+"]——值"+value);
            /**
             * 打印结果：
             * 利用映射关系的 Set 视图获取的键值对==键[d]——值4
             * 利用映射关系的 Set 视图获取的键值对==键[b]——值2
             * 利用映射关系的 Set 视图获取的键值对==键[c]——值3
             * 利用映射关系的 Set 视图获取的键值对==键[a]——值1
             */
        }

        /**
         * NO.2. 通过Map.keySet遍历key和value
         */
        Set<String> keySet = map.keySet();
        for (String s : keySet){
            //map.keySet()返回的是所有key的值
            String value = map.get(s);//得到每个key多对用value的值
            System.out.println("通过Map.keySet遍历key和value=="+"键["+s+"]——值"+value);
        }

        /**
         * 打印结果：
         * 通过Map.keySet遍历key和value==键[d]——值4
         * 通过Map.keySet遍历key和value==键[b]——值2
         * 通过Map.keySet遍历key和value==键[c]——值3
         * 通过Map.keySet遍历key和value==键[a]——值1
         */


        /**
         * NO.3.通过Map.entrySet使用iterator遍历
         */
        Iterator<java.util.Map.Entry<String,String>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            java.util.Map.Entry<String, String> entry = it.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("通过Map.entrySet使用iterator遍历=====键["+key+"]——值"+value);
        }

        /**
         * 打印结果：
         * 通过Map.entrySet使用iterator遍历=====键[d]——值4
         * 通过Map.entrySet使用iterator遍历=====键[b]——值2
         * 通过Map.entrySet使用iterator遍历=====键[c]——值3
         * 通过Map.entrySet使用iterator遍历=====键[a]——值1
         */

        /**
         * NO.4.只能获取values
         */

        for (String s : map.values()){
            System.out.println("直接遍历获取所以得value--"+s);
        }

        /**
         * 打印结果：
         * 直接遍历获取所以得value--4
         * 直接遍历获取所以得value--2
         * 直接遍历获取所以得value--3
         * 直接遍历获取所以得value--1
         */
    }
}