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 + "]";
    }

}

秒客网

Map集合及其实现类

相关文章