Map集合下的方法讲解

1.Map集合

Map集合也是存数据的
双边队列
数据形式是键值对
键是唯一

1.1Map集合下的方法

增：
	V put(K key, V vlaue);添加键值对的数据到map集合中
	void putAll(Map<? extends K> k, Map<? extends V> v);将一个map集合存放到另外一个map集合中
	
删:
	V remove (K key);通过键删除键值对的数据，返回值是值
改：
	V  put(K key V value);当键值存在的时候，会将value值覆盖掉的
查:
	int size(); 查看集合中元素的个数
	boolean isEmpty();判断是否为空，如果不为空返回的是false
	boolean containsKey();是否包含这个键
	boolean containsValue();是否包含这个值
	重要的方法:
	V get(K key);通过键获取值
	Set<K>  keySet();获取map集合中的键，然后存到set集合中
	Collection<V> values(); 获取map集合中值，存到了Collection集合中
	Set<Map.Entry<K,V>> entrySet()；将map集合的键值对，存到了set集合
		Map.Entry这个接口的方法
			getKey:返回键值对的键
			getValue:返回键值对的值

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

public class Demo06 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        //V put(K key, V vlaue);添加键值对的数据到map集合中
        map.put(1,"kq");
        System.out.println(map);//{1=kq}
//        void putAll(Map<? extends K> k, Map<? extends V> v);
//        将一个map集合存放到另外一个map集合中
        Map<Integer,String> map1 = new HashMap<>();
        map1.put(2,"hu");
        map1.put(3,"djj");
        map1.put(1,"huiui");
        map.putAll(map1);
        System.out.println(map);//{1=huiui, 2=hu, 3=djj}
        //V remove (K key);通过键删除键值对的数据，返回值是值
        map.remove(1);
        System.out.println(map);//{2=hu, 3=djj}
        //int size(); 查看集合中元素的个数
        System.out.println(map.size());//2
        //boolean isEmpty();判断是否为空，如果不为空返回的是false
        System.out.println(map.isEmpty());//false
        //boolean containsKey();是否包含这个键
        System.out.println(map.containsKey(1));//false
        //boolean containsValue();是否包含这个值
        System.out.println(map.containsValue("huhd"));//false
        System.out.println("=======================================");
        System.out.println("重要的方法");
        //map = {2=hu, 3=djj}
        //V get(K key);通过键获取值
        System.out.println(map.get(2));//hu
        //Set<K>  keySet();获取map集合中的键，然后存到set集合中
        Set<Integer> set = map.keySet();
        System.out.println(set);//[2, 3]
        //Collection<V> values();
        // 获取map集合中值，存到了Collection集合中
        Collection<String> list = map.values();
        System.out.println(list);//[hu, djj]
        //Set<Map.Entry<K,V>> entrySet()；
        // 将map集合的键值对，存到了set集合
        Set<Map.Entry<Integer,String>> set1 = map.entrySet();
        System.out.println(set1);//[2=hu, 3=djj]
        System.out.println("=======================================");
        for (Map.Entry<Integer, String> integerStringEntry : set1) {
            System.out.println(integerStringEntry);
            System.out.println(integerStringEntry.getKey());
            System.out.println(integerStringEntry.getValue());
            System.out.println("=======================================");
        }
    }

1.2Map集合中的value 存的是对象

import java.util.*;

class Person3{
    String name;
    int age;

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

    @Override
    public String toString() {
        return "Person3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Demo08 {
    public static void main(String[] args) {
        List<Person3> list = new ArrayList<>();
        list.add(new Person3("dg",56));
        list.add(new Person3("fg",34));
        list.add(new Person3("as",86));
        List<Person3> list1 = new ArrayList<>();
        list1.add(new Person3("jhg",12));
        list1.add(new Person3("ff",948));
        list1.add(new Person3("jf",31));
        Map<Integer,List<Person3>> map = new HashMap<>();
        map.put(1,list);
        map.put(2,list1);
        Collection<List<Person3>> list3 = map.values();
        for (List<Person3> person3s : list3) {
            for (Person3 person3 : person3s) {
                System.out.println(person3.name+" "+person3.age);
            }
        }
    }
}