集合03

Map

Map集合提供了集合之间一种映射关系，让集合和集合之间产生关系。

Map集合的特点

1.能够存储唯一的列的数据(唯一，不可重复) Set

2.能够存储可以重复的数据(可重复) List

3.值的顺序取决于键的顺序

4.键和值都是可以存储null元素的

5.一个映射不能包含重复的键。

6.每个键最多只能映射到一个值

Map成员方法

V get(Object key) 返回key对应的value值，如不存在返回null

Set keySet() 返回所有的key值

Collection values() 返回所有的value值

Set<Map.Entry<K,V>> entrySet() 返回所有Entry(包含key|value)值

lV put(K key,V value) 将key|value存入Map,如果已包含key则替换

lV remove(Object key) 移除某个key及对应的value

lboolean isEmpty() 返回集合是否为空

lvoid clear() 清空集合中的数据

lboolean containsKey(Object key) 查看是否包含某个key值

lboolean containsValue(Object value) 查看是否包含某个value值

lint size(） 查看长度

两种常用遍历方式

方式1：根据Key查找Value Set set = map.keySet()

​ 获取所有Key的集合

​ 遍历Key的集合，获取到每一个Key

​ 根据Key查找Value

方式2：根据键值对对象找键和值

​ Set<Map.Entry<Key, Value>> set = map.entrySet();

​ 获取所有键值对对象的集合

​ 遍历键值对对象的集合，获取到每一个键值对对象

​ 根据键值对对象找键和值

HashMap

基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashMap特点

1.键无序，唯一，类似于Set集合

2.值有序，可重复，类似于List,可以理解为Collection

3.底层数据结构是哈希表，保证键唯一

4.允许键为null，值为null(但是不建议)。

    public class HashMapDemo01 {
	public static void main(String[] args) {
		HashMap<String, Integer> hm = new HashMap<String, Integer>();
		hm.put("张三", 800);  //定义每个人的姓名和工资
		hm.put("李四", 1500);
		hm.put("王五", 3000);
		
		System.out.println(hm);
		// 将张三的工资更改为2600元
		hm.put("张三", 2600);
		System.out.println(hm);
		
		// 为所有员工工资加薪100元；
		Set<String> keys = hm.keySet();
		for (String key : keys) {
			Integer value = hm.get(key);
			value += 100;
			hm.put(key, value);
		}
		System.out.println(hm);
		
		// 遍历集合中所有的员工
		Set<String> kys = hm.keySet();
		for (String key : kys) {
			System.out.println(key);
		}
		Set<Entry<String, Integer>> keyValues = hm.entrySet();
		for (Entry<String, Integer> keyValue : keyValues) {
			String key = keyValue.getKey();
			Integer value = keyValue.getValue();
			System.out.println(key + "|" + value);
		}
		
		//遍历集合中所有的工资
		Collection<Integer> values = hm.values();
		for (Integer integer : values) {
			System.out.println(integer);
		}
	}
}

LinkedHashMap

Map接口的哈希表和链接列表实现，具有可预知的迭代顺序

LinkedHashMap特点

1.键有序，唯一，

2.值有序，可重复，类似于List

3.底层数据结构是哈希表和链表，哈希表保证键唯一，链表保证键有序

    public class LinkedHashMapDemo01 {
        public static void main(String[] args) {
            LinkedHashMap<Integer, String> lhm = new LinkedHashMap<Integer, String>();
            lhm.put(1, "张三");
            lhm.put(2, "张三");
            lhm.put(3, "张三");
            lhm.put(4, "张三");
            lhm.put(5, "张三");

            Set<Integer> keys = lhm.keySet();
            for (Integer key : keys) {
                System.out.println(key + "---" + lhm.get(key));
            }
        }
    }

TreeMap

**基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法 **

TreeMap特点

1.键可排序，唯一

2.值有序，可重复，类似于List

3.底层数据结构是自平衡的二叉树，可排序

4.排序方式类似于TreeSet，分为自然排序和比较器排序，具体取决于使用的构造方法

    public class TreeMapDemo01 {
        public static void main(String[] args) {
    //		TreeMap<Student, String> tm = new TreeMap<Student, String>();

            TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>() {

                @Override
                public int compare(Student s1, Student s2) {
                    // 先按照年龄排序
                    int num = s1.getAge() - s2.getAge();
                    // 年龄相同按照姓名排序
                    int num2 = (num == 0) ? s1.getName().compareTo(s2.getName()) : num;
                    return num2;
                }
            });
            tm.put(new Student("zhangsan",18 ), "2017");
            tm.put(new Student("ahangsan",18 ), "2018");
            tm.put(new Student("bhangsan",18 ), "2019");
            tm.put(new Student("changsan",18 ), "2020");
            tm.put(new Student("zhangsan",19 ), "2021");
            tm.put(new Student("zhangsan",18 ), "2022");

            Set<Student> keys = tm.keySet();
            for (Student s : keys) {
                String value = tm.get(s);
                System.out.println(s.getName() + "|" + s.getAge() + "=" + value);
            }
        }
    }

    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 compareTo(Student s) {
            // 先按照年龄排序
            int num = this.getAge() - s.getAge();
            // 年龄相同按照姓名排序
            int num2 = (num == 0) ? this.getName().compareTo(s.getName()) : num;
            return num2;
        }*/

    }

Hashtable

此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值

Hashtable特点

1.不允许null键和null值

2.线程安全，效率低

HashMap和Hashtable的区别

1.HashMap是不安全的不同步的效率高的 允许null键和null值
2.Hashtable是安全的同步的效率低的 不允许null键和null值
3.底层都是哈希表结构

WeakHashMap

以弱键实现的基于哈希表的 Map。

在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为可终止的，被终止，然后被回收。丢弃某个键时，其条目从映射中有效地移除，因此，该类的行为与其他的 Map 实现有所不同。

    public class WeakHashMapDemo01 {
        public static void main(String[] args) {
            WeakHashMap<String, String> whm = new WeakHashMap<>();
            whm.put(new String("abc"), "123");
            whm.put(new String("abc"), "123");
            whm.put(new String("efg"), "46548");
            whm.put("hij", "4234");
            System.out.println(whm);
            System.out.println("*************************");
            System.gc();
            System.runFinalization();	
            System.out.println(whm);
        }
    }

运行结果