集合(三)------双列集合

所谓双列集合就是存在映射关系并且是成对存在的。

双列集合体系：

-------------| Map  如果是实现了Map接口的集合类，具备的特点： 存储的数据都是以键值对的形式存在的，键不可重复，值可以重复。
----------------| HashMap  底层也是基于哈希表实现 的。
----------------| TreeMap   TreeMap也是基于红黑树（二叉树）数据结构实现 的， 特点：会对元素的键进行排序存储。
----------------| Hashtable 和hashMap实现原理一样，但是是线程安全的，执行效率低。出现于JDK1.0。

Map接口常用方法：

增加：

V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。

void putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。

删除：

V remove(Object key)  如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

void clear()  从此映射中移除所有映射关系（可选操作）。

查看：

int size() 返回此映射中的键-值映射关系数。

V get(Object key)  返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

判断：

boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true。

boolen containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。

boolen  containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。

迭代

Set<K>keySet()  返回此映射中包含的键的 Set 视图。

Collection<V> values()  返回此映射中包含的值的 Collection 视图。

Set<Map.Entry<K,V>> entrySet()  返回此映射中包含的映射关系的 Set 视图。

Map.entr<K,V>中的方法

K getKey() 返回与此项对应的键。

V getValue() 返回与此项对应的值。

V setValue(V value) 用指定的值替换与此项对应的值（可选操作）。返回与此项对应的旧值

代码示例：

public class DemoMap {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String, String>();
        //添加
        map.put("a", "张三");
        map.put("b", "李四");
        map.put("c", "王五");
        System.out.println(map);
        map.put("a", "赵六");
        System.out.println(map);
        
        Map<String, String> map2 = new HashMap<String,String>();
        map2.put("d", "李磊");
        map2.put("e", "韩梅梅");
        map.putAll(map2);
        System.out.println(map);
        
        //查看
        System.out.println("size:" + map.size());
        System.out.println("value:" + map.get("a"));
        //迭代
        Set<String> set = map.keySet();
        System.out.println("map中的key："+set);
        Collection<String> collection = map.values();
        System.out.println("map中的value："+collection);
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Map.Entry<String, String> entry = iterator.next();
//            entry.setValue("哈哈哈");
            System.out.println("key:"+entry.getKey() + " value:"+entry.getValue());
        }
        
        //判断
        System.out.println("是否为空："+map.isEmpty());
        System.out.println("key是否a："+map.containsKey("a"));
        System.out.println("value是否为空："+map.containsValue("李磊"));
        //删除
        map.remove("e");
        System.out.println(map);
        map.clear();
        System.out.println(map);
    }
}

HashMap

HashMap的存储原理：
    往HashMap添加元素的时候，首先会调用键的hashCode方法得到元素 的哈希码值，然后经过运算就可以算出该元素在哈希表中的存储位置。
    情况1： 如果算出的位置目前没有任何元素存储，那么该元素可以直接添加到哈希表中。
    情况2：如果算出 的位置目前已经存在其他的元素，那么还会调用该元素的equals方法与这个位置上的元素进行比较，如果equals方法返回的是false，那么该元素允许被存储，如果equals方法返回的是true，那么该元素被视为重复元素，替换掉原来的旧值。

代码示例：

class Person{
    int id;
    String name;
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        Person person = (Person)obj;
        return this.id == person.id;
    }
    @Override
    public String toString() {
        return "{id :"+ this.id + "  名字:"+ this.name+"}";
    }
}

public class DemoMap {
    public static void main(String[] args) {
        HashMap<Person, String> map = new HashMap<Person,String>();
        map.put(new Person(110, "张三"), "110");
        map.put(new Person(210, "李四"), "210");
        map.put(new Person(310, "王五"), "310");
        System.out.println(map);
        map.put(new Person(310, "赵六"), "410");
        System.out.println(map);
    }
}

TreeMap

TreeMap 要注意的事项：

　 1.  往TreeMap添加元素的时候，如果元素的键具备自然顺序，那么就会按照键的自然顺序特性进行排序存储。
    2.  往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性， 那么键所属的类必须要实现Comparable接口，把键的比较规则定义在CompareTo方法上。
    3. 往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性，而且键所属的类也没有实现Comparable接口，那么就必须在创建TreeMap对象的时候传入比较器。

代码示例：

实现Comparable接口

class Person implements Comparable<Person>{
    int id;
    String name;
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        Person person = (Person)obj;
        return this.id == person.id;
    }
    @Override
    public String toString() {
        return "{id :"+ this.id + "  名字:"+ this.name+"}";
    }
    
    @Override
    public int compareTo(Person o) {
        return this.id-o.id;
    }
}

public class DemoMap {
    public static void main(String[] args) {
        TreeMap<Person, String> treeMap = new TreeMap<Person, String>();
        treeMap.put(new Person(110, "张三"), "110");
        treeMap.put(new Person(310, "王五"), "310");
        treeMap.put(new Person(210, "李四"), "210");
        System.out.println(treeMap);
    }
}

自定义比较器

import java.util.Comparator;
import java.util.TreeMap;


class Person{
    int id;
    String name;
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        Person person = (Person)obj;
        return this.id == person.id;
    }
    @Override
    public String toString() {
        return "{id :"+ this.id + "  名字:"+ this.name+"}";
    }

}

class MapComparator implements Comparator<Person>{
    
    @Override
    public int compare(Person o1, Person o2) {
        return o1.id - o2.id;
    }
}

public class DemoMap {
    public static void main(String[] args) {
        TreeMap<Person, String> treeMap = new TreeMap<Person, String>(new MapComparator());
        treeMap.put(new Person(110, "张三"), "110");
        treeMap.put(new Person(310, "王五"), "310");
        treeMap.put(new Person(210, "李四"), "210");
        System.out.println(treeMap);
    }
}

HashTable

和hashMap实现原理一样，但是是线程安全的，执行效率低。出现于JDK1.0。