集合进阶-----Map双列：Map

Map集合的概述和使用：

package 集合进阶.Map双列;
/*
        Map集合概述
            Interface Map<K,V>  K:键的类型;  V:值的类型
            将键映射到值的对象，不能包含重复的键，每个键可以映射到最多一个值

        创建Map集合的对象
            多态的方式
            具体的实现类HashMap
 */

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

public class Map集合的概述和使用 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //映射
        map.put("1","赵");
        map.put("2","钱");
        map.put("3","孙");

        map.put("3","李");//将上一个替换掉

        //输出集合
        System.out.println(map);

    }
}

Map集合的基本功能：

package 集合进阶.Map双列;
/*
            V put（K key，V value）    添加元素
            V remove（Object key）    根据键删除键值对元素
            void clear（）            移除所以的键值对元素
            boolean containKey（Object key）  判断集合是否包含指定的键
            boolean containValue（Object value）  判断集合是否包含指定的值
            boolean isEmpty（）          判断集合是否为空
            int size（）                  集合长度，键值对个数

 */

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

public class Map集合的基本功能 {
    public static void main(String[] args) {
        //创建对象
        Map<String, String> map = new HashMap<String, String>();

        map.put("1","赵");
        map.put("2","钱");
        map.put("3","孙");

        map.remove("1");

        map.clear();

        System.out.println(map.containsKey("2"));
        System.out.println(map.containsValue("孙"));
        System.out.println(map.isEmpty());
        System.out.println(map.size());

        System.out.println(map);

    }
}

 

Map集合的获取功能

package 集合进阶.Map双列;
/*
          V get（Object key）     根据键获取值
          Set<K>keySet()          获取所有键的集合
          Collection<V>values()    获取所有值的集合
          Set<Map.Entry<K,V>>entrySet()     获取所有键值对对象的集合

 */

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

public class Map集合的获取功能 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //映射
        map.put("1","赵");
        map.put("2","钱");
        map.put("3","孙");

        //V get（Object key）     根据键获取值
        System.out.println(map.get("1"));

        //Set<K>keySet()          获取所有键的集合
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key);
        }

        //Collection<V>values()    获取所有值的集合
        Collection<String> values =map.values();
        for (String value : values) {
            System.out.println(value);
        }

        //Set<Map.Entry<K,V>>entrySet()     获取所有键值对对象的集合
        Set<Map.Entry<String, String>> en = map.entrySet();
        for (Map.Entry<String, String> entry :en){
            System.out.println(entry);
        }



        System.out.println(map);
    }
}

 

Map集合遍历方式1

package 集合进阶.Map双列;
/*
        根据键去找值
              获取所有键的集合，用KeySet()方法
              遍历键的集合，获取到每一个键，用增强for
              根据键找值，用get(Object key)方法

 */

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

public class Map集合遍历方式1 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //映射
        map.put("1","赵");
        map.put("2","钱");
        map.put("3","孙");

        //获取所有键的集合，用KeySet()方法
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键，用增强for
        for (String key : keySet) {
            //根据键找值，用get(Object key)方法
            String value = map.get(key);
            System.out.println(key+","+value);
        }



    }
}

 

Map集合遍历方式2

package 集合进阶.Map双列;
/*
          根据键值对找键和值
                1.获取所有键值对对象的集合
                    Set<Map.Entry<K,V>>entrySet()
                2.遍历键值对对象的集合
                    增强for
                3.根据键值对对象获取键和值
                    用getKey()获取键
                    用getValues()获取值

 */

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

public class Map集合遍历方式2 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //映射
        map.put("1","赵");
        map.put("2","钱");
        map.put("3","孙");

        //获取所有键值对对象的集合
        Set<Map.Entry<String,String>> entrySet=map.entrySet();
        //遍历键值对对象的集合
        for(Map.Entry<String,String> entry : entrySet){
            //根据键值对对象获取键和值
            String key = entry.getKey();
            String value = entry.getValue();

            System.out.println(key + "=" + value);
        }


    }
}