Map集合

深藏阁楼爱情的钟 2021-11-29 12:04 421阅读 0赞

# Map集合 #

# （一）Map集合 #

#### 1.Map集合的特点； ####

可以储存键映射到值得对象，且一个映射不能包含重复的键，每个键最多只能映射到一个值 只和键有关和值没有关系

#### 2.Map接口和Collection接口的不同 ####

Map是双列的,Collection是单列的  
 Map的键唯一,Collection的子体系Set是唯一的  
 Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

#### 3.Map集合的功能 ####

1:添加功能  
V put(K key,V value):添加元素。这个其实还有另一个功能?替换  
如果键是第一次存储，就直接存储元素，返回null  
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值  
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(): 返回一个键值对的Set集合  
V get(Object key):根据键获取值  
Set keySet():获取集合中所有键的集合  
Collection values():获取集合中所有值的集合  
5:长度功能  
int size()：返回集合中的键值对的对数

Map键相同，值覆盖

v put(K key,V value)//键相同 值覆盖  
    	V remove(Object key)
    	void clear()
    	boolean containsKey(Object key)
    	boolean containsValue(Object value)
    	boolean isEmpty()
    	int size()

#### 4.Map集合的遍历方式 ####

1.获取所有键的集合，遍历键的集合，获取到每一个键，然后根据键找值

public class Text {
        public static void main(String[] args) {
    
            HashMap<String, String> hashMap = new HashMap<>();
            hashMap.put("文学家","莫言");
            hashMap.put("音乐家","贝多芬");
            hashMap.put("天文学家","伽利略");
            hashMap.put("数学家","华罗庚");
            Set<String> set = hashMap.keySet();
            for (String s : set) {
                System.out.println(s+"-----------"+hashMap.get(s));
    
            }
        }
    }

2.获取所有键值对对象的集合，遍历键值对对象集合，获取到每一个键值对对象

然后根据每个键值对象找键和值

public class Text {
        public static void main(String[] args) {
            HashMap<String, String> hashMap = new HashMap<>();
            hashMap.put("文学家","莫言");
            hashMap.put("音乐家","贝多芬");
            hashMap.put("天文学家","伽利略");
            hashMap.put("数学家","华罗庚");
            Set<Map.Entry<String, String>> entries = hashMap.entrySet();
            for (Map.Entry<String, String> entry : entries) {
                System.out.println(entry.getKey()+"-----"+entry.getValue());
            }
        }
        }

# （二）Map的实现类 #

#### 1.HashMap ####

特点：允许插入null值和null键，

保证元素的唯一性，也要重写HashCode（）和equals（）方法

#### 2.LinkedMap ####

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

LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一  
元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证  
Map集合的数据结构只和键有关

#### 3.TreeMap ####

特点 TreeMap 键不允许插入null

TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性  
排序分为自然排序和比较器排序  
线程是不安全的效率比较高

##### A:案例演示: 需求：统计字符串中每个字符出现的次数 #####

“aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

public class Demo2 {
    
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                System.out.println("请随便输入一行字符");
                String line = scanner.nextLine();
                HashMap<Character, Integer> hashMap = new HashMap();
                for(int i = 0; i < line.length(); ++i) {
                    char ch = line.charAt(i);
                    if (!hashMap.containsKey(ch)) {
                        hashMap.put(ch, 1);
                    } else {
                        Integer integer = (Integer)hashMap.get(ch);
                        integer = integer + 1;
                        hashMap.put(ch, integer);
                    }
                }
                StringBuilder sb = new StringBuilder();
                Set<Character> keySet = hashMap.keySet();
                Iterator var11 = keySet.iterator();
    
                while(var11.hasNext()) {
                    Character key = (Character)var11.next();
                    sb.append(key).append("(").append(hashMap.get(key)).append(")");
                }
    
                String s = sb.toString();
                System.out.println(s);
            }
        }

# （三）集合嵌套 #

#### 1.集合嵌套之Hash Map嵌套Hash Map ####

public class Demo12 {
        public static void main(String[] args) {
    //        基础班
    //       		20
    //        李四		22
    //       就业班
    //        王五		21
    //        赵六		23
            HashMap<String, Integer> Baseclass = new HashMap<>();
              Baseclass.put("李四",22);
              Baseclass.put("张三",20);
            HashMap<String, Integer>  Employmentclass= new HashMap<>();
            Employmentclass.put("王五", 21);
            Employmentclass.put("赵六",23);
            HashMap<String, HashMap<String, Integer>> gradeclas = new HashMap<>();
            gradeclas.put("基础班",Baseclass);
            gradeclas.put("就业班",Employmentclass);
            Set<Map.Entry<String, HashMap<String, Integer>>> Maxmap = gradeclas.entrySet();
            for (Map.Entry<String, HashMap<String, Integer>> M : Maxmap) {
                String key = M.getKey();
                System.out.println(key);
                HashMap<String, Integer> Minmap = M.getValue();
                Set<Map.Entry<String, Integer>> m= Minmap.entrySet();
                for (Map.Entry<String, Integer> Min : m) {
                    String key1 = Min.getKey();
                    Integer value = Min.getValue();
                    System.out.println(key1+"\t"+value);
                }
            }
        }
    }

#### 2.集合嵌套之HashMap嵌套ArrayList ####

public class Demo12 {
        public static void main(String[] args) {
    //        集合嵌套之HashMap嵌套ArrayList
    //
    //        假设HashMap集合的元素是ArrayList。有3个。
    //        每一个ArrayList集合的值是字符串。
    //
    //        三国演义
    //                吕布
    //                 周瑜
    //         笑傲江湖
    //                 令狐冲
    //                林平之
    //        神雕侠侣
    //                郭靖
    //
    //
    //              杨过
            ArrayList<String>   SG=new  ArrayList<>();
            ArrayList<String>   XA=new  ArrayList<>();
            ArrayList<String>   SD=new  ArrayList<>();
             SG.add("吕布");
             SG.add("周瑜");
             XA.add("令狐冲");
             XA.add("林平之");
             SD.add("郭靖");
             SD.add("杨过");
            HashMap<String, ArrayList<String>> Maxmap = new HashMap<>();
            Maxmap.put("三国演义",SG);
            Maxmap.put("笑傲江湖",XA);
            Maxmap.put("神雕侠侣",SD);
            Set<Map.Entry<String, ArrayList<String>>> M = Maxmap.entrySet();
            for (Map.Entry<String, ArrayList<String>> entry : M) {
                System.out.println(entry.getKey());
                ArrayList<String> value = entry.getValue();
                for (String s : value) {
                    System.out.println("\t"+s);
                }
            }
        }
    
    }

#### 3.集合嵌套之ArrayList嵌套HashMap ####

public class Demo9 {
    //    集合嵌套之ArrayList嵌套HashMap
    //
    //    假设ArrayList集合的元素是HashMap。有3个。
    //    每一个HashMap集合的键和值都是字符串。
    //
    //    周瑜---小乔
    //    吕布---貂蝉
    //
    //    郭靖---黄蓉
    //    杨过---小龙女
    //
    //    令狐冲---任盈盈
    //    林平之---岳灵珊
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        HashMap<String, String> map1 = new HashMap<>();
        HashMap<String, String> map2 = new HashMap<>();
        map.put("周瑜","小乔");
        map.put("吕布","貂蝉");
        map1.put("郭靖","黄蓉");
        map1.put("杨过","小龙女");
    
        map2.put("令狐冲","任盈盈");
        map2.put("林平之","岳灵珊");
        ArrayList<HashMap<String, String>> Maps = new ArrayList<>();
        Maps.add(map);
        Maps.add(map1);
        Maps.add(map2);
        for (HashMap<String, String> hashMap : Maps) {
            Set<Map.Entry<String, String>> set = hashMap.entrySet();
            for (Map.Entry<String, String> entry : set) {
                System.out.println(entry.getKey()+"----"+entry.getValue());
    
            }
            System.out.println();
        }
    
    
    }
    }

# (四)HashMap和Hashtable的区别 #

HashMap: 线程不安全,效率高.允许null值和null键  
 Hashtable: 线程安全 , 效率低.不允许null值和null键

# （五）Collections工具类的概述和常见方法讲解 #

A:Collections类概述: 针对集合操作 的工具类  
B:Collections成员方法  
public static void sort(List list): 排序,默认按照自然顺序  
public static int binarySearch(List<?> list,T key): 二分查找  
public static T max(Collection<?> coll): 获取最大值  
public static void reverse(List<?> list): 反转  
public static void shuffle(List<?> list): 随机置换