java中的集合之Map接口(四)

清疚 2022-08-18 11:39 280阅读 0赞

**Map接口**

1.将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

2.此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。

3.表示集合，与Collection体系无关，Map存放的是key-value的键值对。

4.在Map中，key不能重复，所以key的集合为Set；value的值可以重复，所以value的集合可以看做Collection。

**Map内部结构示意图**

![SouthEast][]

**Map接口实现类**

1.HashMap(JDK1.2)  
2.Hashtable(JDK1.0)  
2.1Properties  
3.TreeMap  
• 实现类用法及注意点：  
– HashMap与Hashtable用法基本一致。Hashtable已经被HashMap取代。  
– HashMap与Hashtable  
• HashMap底层是哈希表，key和value可以为null；不同步，线程不安全，效率较高。如果想实现HashMap的同步，则使用Collections.synchronizedMap方法。  
• Hashtable底层是哈希表，key和value不能为null；同步，线程安全，效率较低。  
• 注意： HashSet底层其实就是使用HashMap  
– Properties用法  
• 虽然Hashtable已经被HashMap取代，但Hashtable的子类Properties依然常用。  
• Properties属性列表中每个键及其对应值都是一个字符串  
Properties pros = System.getProperties();得到JVM系统的属性。  
– TreeMap(了解即可)  
• 底层是二叉树，对于放入该对象的键，默认按照自然顺序排列。TreeSet是由TreeMap实现的。

HashMap中的方法示例

package com.jcxy;
    
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    
    public class demo16
    {
        public static void main(String[] args)
        {
            HashMap map = new HashMap();
            
            Student s1 = new Student(1,"jack");
            Student s2 = new Student(2,"rose");
            Student s3 = new Student(5,"andy");
            Student s4 = new Student(3,"damno");
            Student s5 = new Student(8,"luse");
            Student s6 = new Student(1,"klaus");
            
            //将指定的值与此映射中的指定键关联
            map.put(6, s1);
            map.put(2, s2);
            map.put(3, s3);
            map.put(4, s4);
            map.put(5, s5);
            map.put(6, s2);
            
            //返回此映射中的键-值映射关系数。
            System.out.println(map.size());//6
            
            //如果此映射未包含键-值映射关系，则返回 true。
            System.out.println(map.isEmpty());//false
            
            //如果此映射包含指定键的映射关系，则返回 true。
            System.out.println(map.containsKey(9));//false
            
            //如果此映射将一个或多个键映射到指定值，则返回 true。
            System.out.println(map.containsValue(s5));//true
            
            //返回此映射中包含的值的 Collection 视图，值可以重复，用collection
            Collection col1 = map.values();
            for(Object o : col1)
            {
                System.out.println(o);
            }
            // 返回此映射中包含的键的 Set 视图。因为key不能重复，所以用set存储
            Set set = map.keySet();
            for (Object o : set)
            {
                System.out.println(o);
            }
            
            返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
            Object obj = map.get(3);
            System.out.println(obj);//Student [age=5, name=andy]
            
            //如果存在一个键的映射关系，则将其从此映射中移除,如果没有怎返回null   
            Object obj1 = map.remove(2);
            System.out.println(obj1);//Student [age=2, name=rose]
            
            //返回此映射中包含的映射关系的 Set 视图。
            Set set1 = map.entrySet();
            
            for(Object o : set1)
            {
                //将Set对象强转为Map.Entry对象才可以使用Map.Entry的获取键值的方法
               Map.Entry me = (Entry)o;
               System.out.println("键 = " + me.getKey() + " 值 = " + me.getValue());
            }      
        }
    }

Properties的方法

package com.jcxy;
    
    import java.util.Enumeration;
    import java.util.Properties;
    
    public class Test1
    {
        public static void main(String[] args)
        {
            Properties pro = new Properties();
            
            // 调用 Hashtable 的方法 put。强制要求为属性的键和值使用字符串
            pro.put("username", "jack");
            pro.put("password", "root");
            
            // 得到系统的属性。JVM
            Properties pros = System.getProperties();
            
            Enumeration en = pros.keys();
            while (en.hasMoreElements())
            {
                String key = (String)en.nextElement();
                String value = pros.getProperty(key);
                System.out.println(key + " = " + value);
            }
            System.out.println(System.getProperty("user.language"));
        }
    }

TreeMap中默认按照自然顺序排列

Student类

package com.jcxy;
    
    public class Student implements Comparable
    {
        private int age;
        private String name;
        public Student(int age, String name)
        {
            super();
            this.age = age;
            this.name = name;
        }
        public Student()
        {
            super();
            // TODO Auto-generated constructor stub
        }
        public int getAge()
        {
            return age;
        }
        public void setAge(int age)
        {
            this.age = age;
        }
        public String getName()
        {
            return name;
        }
        public void setName(String name)
        {
            this.name = name;
        }
        @Override
        public int hashCode()
        {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Student other = (Student)obj;
            if (age != other.age)
                return false;
            if (name == null)
            {
                if (other.name != null)
                    return false;
            }
            else if (!name.equals(other.name))
                return false;
            return true;
        }
        @Override
        public String toString()
        {
            return "Student [age=" + age + ", name=" + name + "]";
        }
        @Override
        public int compareTo(Object o)
        {
            if(o == null)
            {
                return 0;
            }
            if(!(o instanceof Student))
            {
                return 0;
            }
            Student s = (Student)o;
            int result = this.age - s.age;
            if(result != 0)
            {
                return result;
            }
            return this.name.compareTo(s.name);
        }
        
    }

Test类

package com.jcxy;
    
    import java.util.Set;
    import java.util.TreeMap;
    
    /*  TreeMap   对于放入该对象的键，默认按照自然顺序排列。
     * 
     */
    public class Test2
    {
        public static void main(String[] args)
        {      
            Student s1 = new Student(24, "xyz");
            Student s2 = new Student(22, "a");
            Student s3 = new Student(20, "ab");
            TreeMap tm = new TreeMap();
            tm.put(s1, "abc");
            tm.put(s2, "efg");
            tm.put(s3, "xyz");
            
            Set keys = tm.keySet();
            
            for(Object obj : keys)
            {
                System.out.println(obj + "=" + tm.get(obj));
            }
            
        }
    }

打印结果：

Student \[age=20, name=ab\]=xyz  
Student \[age=22, name=a\]=efg  
Student \[age=24, name=xyz\]=abc

• 注意：

– Map在真实使用中，key很少使用自定义的类型，如果为自定义的类型，则该类必须重写hashCode和equals方法。一般key都是使用八种基本数据类型对应的包装类或String类型。

– 对于Map来说，key和value是一一对应的。如果出现一个key对应多个value的情况。比如巴塞罗那足球队有多个球员。将所有的球员添加到一个集合中，球队为key，集合为value。

**集合总结：**

**Collection体系**

**![SouthEast 1][]**

Map体系

![SouthEast 2][]

**讲完集合之后来看看集合工具类**

**Collections类**

– 是一个工具类，类中所有的方法都是static。这些方法都是操作Collection体系的。

– Collections类中，主要对集合进行排序，查找，替换，填充等功能。

注意：

• Collections与Collection区别？

– Collection是集合中的顶层接口，其有两个子接口List,Set.

– Collections是工具类，里面提供了操作(Collection)集合对象的各种静态方法。

**集合和数组之间互相转换**

– 数组\->集合

• 通过Arrays.asList(T… obj)方法将数组转换成List对象。但是转换后，不可以使用集合对象中的增删方法(使用的话，会报UnsupportedOperationException)。因为数组长度是固定的。但可以使用查询，判断等不修改数组长度的方法。

– 集合\->数组

• 使用集合对象中的toArray()(该方法只能返回Object\[\])，toArray(T\[\] t)可以指定具体数组元素的类型。

• 例：String\[\] obj = list.toArray(new String\[10\]);此时，String\[\]的数组的长度如果小于等于集合中元素的个数，JVM会自动以集合中的元素个数为数组分配内存。如果超过集合对象中元素的个数，剩余部分以数组元素类型默认值填充。

[SouthEast]: /images/20220731/9f497c2961254a9ebe1a31aa1def503a.png
[SouthEast 1]: /images/20220731/868e5cd5b729422e93f58cc8a28a2b79.png
[SouthEast 2]: /images/20220731/71bdcc59902443d7b3691de85dae4e2c.png