Java基础进阶集合-map集合

秒速五厘米 2023-10-08 16:51 55阅读 0赞

1、Map和Collection没有继承关系。  
2、Map集合以key和value的方式存储数据：键值对

*  key和value都是引用数据类型。
 *  key和value都是存储对象的内存地址。
 *  key起到主导的地位，value是key的一个附属品。

3、Map接口中常用方法：

*  V put(K key, V value) 向Map集合中添加键值对
 *  V get(Object key) 通过key获取value
 *  void clear() 清空Map集合
 *  boolean containsKey(Object key) 判断Map中是否包含某个key
 *  boolean containsValue(Object value) 判断Map中是否包含某个value
 *  boolean isEmpty() 判断Map集合中元素个数是否为0
 *  V remove(Object key) 通过key删除键值对
 *  int size() 获取Map集合中键值对的个数。
 *  Collection values() 获取Map集合中所有的value，返回一个Collection
 *  Set keySet() 获取Map集合所有的key（所有的键是一个set集合）
 *  Set<Map.Entry<K,V>> entrySet()
    
     *  将Map集合转换成Set集合
     *  设现在有一个Map集合，如下所示：

map1集合对象

<table> 
 <thead> 
  <tr> 
   <th align="center">Key</th> 
   <th align="center">value</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">1</td> 
   <td align="center">zhangsan</td> 
  </tr> 
  <tr> 
   <td align="center">2</td> 
   <td align="center">lisi</td> 
  </tr> 
  <tr> 
   <td align="center">3</td> 
   <td align="center">wangwu</td> 
  </tr> 
  <tr> 
   <td align="center">4</td> 
   <td align="center">zhaoliu</td> 
  </tr> 
 </tbody> 
</table>

*  Set set = map1.entrySet();  
    set集合对象  
    1=zhangsan 【注意：Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是 Map.Entry<K,V>】  
    2=lisi 【Map.Entry和String一样，都是一种类型的名字，只不过：Map.Entry是静态内部类，是Map中的静态内部类】  
    3=wangwu  
    4=zhaoliu —> 这个东西是个什么？Map.Entry

#### 示例代码01： ####

public class MapTest01 {
        
        public static void main(String[] args) {
        
    
            //创建Map集合对象
            Map<Integer,String> map = new HashMap<>();
    
            //往Map集合中添加键值对
            map.put(1,"张三");
            map.put(2,"李四");
            map.put(3,"王五");
            map.put(4,"赵六");
    
            //通过key获取value
            System.out.println(map.get(2));
    
            //获取键值对的数量
            System.out.println("键值对的数量：" + map.size());
    
            //通过key删除键值对
            map.remove(2);
            System.out.println("键值对的数量：" + map.size());
    
            //判断map中是否包含key
            // 判断是否包含某个key
            // contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法。
            System.out.println(map.containsKey(1));//true
    
            //判断map中是否包含value
            System.out.println(map.containsValue("王五"));//true
    
            //foreach遍历map集合的value
            Collection<String> values = map.values();
            for(String s : values){
        
                System.out.println(s);
            }
    
            //清空map集合
            map.clear();
            System.out.println("键值对的数量：" + map.size());
    
            //判断map集合是否为空
            System.out.println(map.isEmpty());
    
        }
    }

#### 运行结果： ####

![在这里插入图片描述][d77c1863f4eb4e6eb24bdf26fd06a778.png]

### map集合的遍历 ###

1、通过itrator迭代器进行遍历

2、通过foreach循环遍历

3、通过map集合中的entrySet()方法进行遍历，调用此方法返回的是一个Set集合

#### 示例代码02： ####

public class MapTest02 {
        
        public static void main(String[] args) {
        
            //创建map集合对象
            Map<Integer,String> map = new HashMap<>();
    
            //往集合中添加键值对
            map.put(1,"张三");
            map.put(2,"李四");
            map.put(3,"王五");
            map.put(4,"赵六");
    
            //获取集合的所有key
            // 遍历Map集合
            // 获取所有的key，所有的key是一个Set集合
            Set<Integer> keys = map.keySet();
    
            //第一种遍历集合方式
            /*Iterator<Integer> it = set.iterator();
            while(it.hasNext()){
                // 取出其中一个key
                Integer key = it.next();
                // 通过key获取value
                String value = map.get(key);
                System.out.println(key + "=" + value);
            }*/
    
            //第二种遍历集合方式
            for(Integer key : keys){
        
                System.out.println(key + "=" + map.get(key));
            }
    
            System.out.println("==================================");
            //第三种遍历方式
            Set<Map.Entry<Integer, String>> set = map.entrySet();
            Iterator<Map.Entry<Integer, String>> it = set.iterator();
            while(it.hasNext()){
        
                Map.Entry<Integer, String> node = it.next();
                Integer key = node.getKey();
                String value = node.getValue();
                System.out.println(key + "=" + value);
            }
    
            //第四种遍历方式
            // foreach
            // 这种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。
            // 这种方式比较适合于大数据量。
            for(Map.Entry node : set){
        
                System.out.println(node.getKey() + "---->" + node.getValue());
            }
        }
    }

#### 运行结果： ####

![在这里插入图片描述][862e4d39782d46d1913156dd672dd4bc.png]

#### 示例代码03： ####

//集合中的自定义泛型
    public class MyClass {
        
    
        // 声明一个静态内部类
        public static class InnerClass{
        
    
            //静态方法
            public static void doSume(){
        
                System.out.println("静态内部类输出....");
            }
    
            //实例方法
            public void m(){
        
                System.out.println("静态内部类静态方法输出...");
            }
    
            public static void main(String[] args) {
        
    
                MyClass.InnerClass.doSume();
    
                //创建静态内部类对象
                MyClass.InnerClass i = new MyClass.InnerClass();
                i.m();
    
                // 给一个Set集合
                // 该Set集合中存储的对象是：MyClass.InnerClass类型
                Set<MyClass.InnerClass> s = new HashSet<>();
    
                // 这个Set集合中存储的是字符串对象。
                Set<String> s1 = new HashSet();
    
                Set<MyMap.Entry<Integer,String>> s2 = new HashSet();
    
    
            }
        }
    }
    
    class MyMap{
        
        public static class Entry<K,V>{
        
    
        }
    }

[d77c1863f4eb4e6eb24bdf26fd06a778.png]: https://img-blog.csdnimg.cn/d77c1863f4eb4e6eb24bdf26fd06a778.png
[862e4d39782d46d1913156dd672dd4bc.png]: https://img-blog.csdnimg.cn/862e4d39782d46d1913156dd672dd4bc.png