Map集合及其实现类

Map 接口

    ----|HashMap           -------------implements  Map

        ----|LinkedHashMap -------------extends HashMap

    ----|Hashtable         -------------implements  Map



    ----|treeMap           -------------implements Map



Map 接口
    ----|HashMap 线程不安全，效率高。
        允许null键和null值,是基于哈希表的Map接口实现。
        哈希表的作用是用来保证键的唯一性的

        ----|LinkedHashMap:是基于Map接口的哈希表和链接列表实现，
                由哈希表保证键的唯一性
                由链表保证键盘的有序(存储和取出的顺序一致)

    ----|Hashtable:线程安全，效率低。不允许null键和null值

    ----|treeMap    是基于红黑树的Map接口的实现。

一.Map集合
定义：将键映射到值的对象。key是唯一不重复，每一个key只能对应一个value

常用方法：
1:添加或者修改功能

• V put(K key,V value):添加元素 /修改元素，并返回修改前元素的值

2:删除功能

• void clear():移除所有的键值对元素
• V remove(Object key)：删除键对应的元素，并把值返回

3:判断功能

• boolean containsKey(Object key)：判断集合是否包含指定的键
• boolean containsValue(Object value):判断集合是否包含指定的值
• boolean isEmpty()：判断集合是否为空

4:获取功能

• Set< Map.Entry< K,V>> entrySet():遍历
• V get(Object key):根据键获取值
• Set< K> keySet():获取集合中所有键的集合
• Collection< V> values():获取集合中所有值的集合

5：长度功能

• int size()：返回集合中的键值对的对数

public static void main(String[] args) {

        Map<String, String> map=new HashMap<String,String>();

        // 添加元素
        System.out.println("-----------put-----------------");
        System.out.println(map.put("1", "11"));
        System.out.println(map.put("1", "111"));
        map.put("2", "2");
        map.put("3", "4");
        map.put("4", "4");
        map.put("5", "5");
        System.out.println(map);


        System.out.println("-----------containsKey判断集合是否包含指定的键-----------------");
        System.out.println(map.containsKey("1"));

        System.out.println("-----------containsValue判断集合是否包含指定的键-----------------");
        System.out.println(map.containsValue("111"));

        System.out.println("-----------isEmpty()判断集合是否为空-----------------");
        System.out.println(map.isEmpty());


        System.out.println("-----------size()：返回集合中的键值对的对数-----------------");
        System.out.println("size:"+map.size());



        System.out.println("-----------keySet：获取key的集合Set<T>-----------------");
        Set<String> set=map.keySet();
        for (String s : set) {
            System.out.print(s+":"+map.get(s)+"  ");
        }

        System.out.println();
        System.out.println("-----------values：获取value的Collection<T>-----------------");
        Collection<String>  value=map.values();
        for (String s : set) {
            System.out.print(s+":"+"  ");
        }
        System.out.println();

        System.out.println("-----------Set<Entry<String, String>>-----------------");
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.print(entry.getKey()+":"+    entry.getValue()+" ");
        }

        System.out.println();
        System.out.println("-----------remove根据键删除键值对元素，并把值返回-----------------");
        System.out.println("romove:"+map.remove("1"));
        System.out.println(map);


        System.out.println("-----------clear移除所有的键值对元素-----------------");
        map.clear();
        System.out.println(map);
    }

输出：
-----------put-----------------
null
11
{3=4, 2=2, 1=111, 5=5, 4=4}
-----------containsKey判断集合是否包含指定的键-----------------
true
-----------containsValue判断集合是否包含指定的键-----------------
true
-----------isEmpty()判断集合是否为空-----------------
false
-----------size()：返回集合中的键值对的对数-----------------
size:5
-----------keySet：获取key的集合Set<T>-----------------
3:4  2:2  1:111  5:5  4:4  
-----------values：获取value的Collection<T>-----------------
3:  2:  1:  5:  4:  
-----------Set<Entry<String, String>>-----------------
3:4 2:2 1:111 5:5 4:4 
-----------remove根据键删除键值对元素，并把值返回-----------------
romove:111
{3=4, 2=2, 5=5, 4=4}
-----------clear移除所有的键值对元素-----------------
{}

二.Map实现类

HashMap：

• 线程不安全，效率高。允许null键和null值
• 是基于哈希表的Map接口实现。哈希表的作用是用来保证键的唯一性的。
• 常用实例化方法：
         new HashMap< Object, Object>();

Hashtable:

• 线程安全，效率低。不允许null键和null值

LinkedHashMap:

• 是基于Map接口的哈希表和链接列表实现,有序
• 由哈希表保证键的唯一性
• 由链表保证键盘的有序(存储和取出的顺序一致)
• 常用实例化方法：
         new LinkedHashMap< Object, Object>();

        System.out.println("-----------LinkedHashMap唯一性 有序----------------");
    //LinkedHashMap测试  由哈希表保证键的唯一性 由链表保证键盘的有序(存储和取出的顺序一致)
    LinkedHashMap<String, String> lMap=new LinkedHashMap<String, String>();
    // 创建并添加元素
    lMap.put("11", "11");
    lMap.put("22", "22");
    lMap.put("33", "33");
    lMap.put("44", "44");
    lMap.put("55", "55");

    // 遍历
    Set<String> set2 = lMap.keySet();
    for (String key : set2) {
        String value2 = lMap.get(key);
        System.out.println(key + "---" + value2);
    }
输出：
-----------LinkedHashMap唯一性 有序----------------
11---11
22---22
33---33
44---44
55---55

treeMap：

• TreeMap:是基于红黑树的Map接口的实现。
• 构造方法：
         TreeMap() 使用键的自然顺序构造一个新的、空的树映射。
         TreeMap(Comparator< ? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序

自然顺序:
如果key是自定义的类，该类需要实现Comparator接口,基本类型都有实现该接口；

        //构造方法摘要
        //TreeMap()  使用键的自然顺序构造一个新的、空的树映射。
        //TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序

        System.out.println("--------------基本类型key自然排序----------------");        
        TreeMap<String, String> tm=new TreeMap<String, String>();
        tm.put("1", "1");
        tm.put("2", "2");
        tm.put("5", "5");
        tm.put("4", "4");
        tm.put("3", "3");
        Set<String> set=tm.keySet();
        for (String key : set) {
            String value=tm.get(key);
            System.out.println(key+"----"+value);
        }


        System.out.println("--------------自定义的类key自然排序----------------");       
        TreeMap<Student, String> tm2=new TreeMap<Student, String>();
        Student s1 = new Student("abc", 27);
        Student s2 = new Student("abc", 29);
        Student s3 = new Student("bcd", 23);
        Student s4 = new Student("efd", 27);
        Student s5 = new Student("cfd", 22);
        Student s6 = new Student("cdf", 40);
        Student s7 = new Student("bed", 22);
        tm2.put(s1, "1");
        tm2.put(s2, "2");
        tm2.put(s3, "3");
        tm2.put(s4, "4");
        tm2.put(s5, "5");
        tm2.put(s6, "6");
        tm2.put(s7, "7");

        Set<Student> set2=tm2.keySet();
        for (Student key : set2) {
            String value=tm2.get(key);
            System.out.println(key+"----"+value);
        }
输出：
--------------基本类型key自然排序----------------
1----1
2----2
3----3
4----4
5----5
--------------基本类型key自然排序----------------
Student [name=bed, age=22]----7
Student [name=cfd, age=22]----5
Student [name=bcd, age=23]----3
Student [name=abc, age=27]----1
Student [name=efd, age=27]----4
Student [name=abc, age=29]----2
Student [name=cdf, age=40]----6

比较排序：

        System.out.println("--------------比较器排序----------------");
        //TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序
        TreeMap<Student, String> tm3=new TreeMap<Student, String>(new Comparator<Student>() {
            public int compare(Student s1, Student  s2) {
                //先按名字比较
                int num1=s1.getName().compareTo(s2.getName());
                //年龄比较
                int num2=num1==0?s1.getAge()-s2.getAge():num1;
                return num2;
            };
        });
        tm3.put(s1, "1");
        tm3.put(s2, "2");
        tm3.put(s3, "3");
        tm3.put(s4, "4");
        tm3.put(s5, "5");
        tm3.put(s6, "6");
        tm3.put(s7, "7");
        Set<Student> set3=tm3.keySet();
        for (Student key : set3) {
            String value=tm3.get(key);
            System.out.println(key+"----"+value);
        }
输出：
--------------比较器排序----------------
Student [name=abc, age=27]----1
Student [name=abc, age=29]----2
Student [name=bcd, age=23]----3
Student [name=bed, age=22]----7
Student [name=cdf, age=40]----6
Student [name=cfd, age=22]----5
Student [name=efd, age=27]----4

Student 类

/*
 * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
 */
public 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 int compareTo(Student s) {
        //按照年龄排序
        int num1= this.getAge()-s.getAge();
        ////如果年龄相同，按名字排序
        int num2=num1==0?(this.getName().compareTo(s.getName())):num1;
        return num2;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}