java基础35 双例集合Map及其常用方法

单例集合体系：

---------| collection  单例集合的根接口
--------------| List  如果实现了list接口的集合类，具备的特点：有序，可重复       注：集合中的有序不是指自然顺序，而是指添加进去的顺序与出来的顺序是一致的
------------------| ArrayList  ArrayList底层维护了一个object数组的实现的。(线程不安全)，特点：查询速度快，增删速度慢。（有序，可重复）
------------------| LinkedList  LinkedList底层是使用链表结构实现的，线程不安全，特点：查询速度慢，增删速度快。（有序，可重复）
------------------| Vector(了解即可)  底层也是维护一个Object数组的实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低
--------------| Set  如果实现了set接口的集合类，具备的特点：无序，不可重复     注：集合中的无序不是指自然顺序，而是指添加元素进去的顺序与元素出来的顺序是不一致的
------------------| HashSet  底层是用于一个哈希表支持的，线程不安全，特点：存储速度块
------------------| TreeSet  底层是使用红黑树(二叉树)数据结构实现的，线程不同步(即线程不安全)，不能在多线程中共享，但可以使用synchroinzedMap()方法来实现同步。特点：会对元素进行排序存储（按自然顺序）

双例集合体系：

----------| Map  双例集合的根接口。如果是实现了Map接口的集合类，具备的特点：存储的数据都是以键值对形式存在的，键不可重复，值可以重复
--------------| HashMap  底层是基于哈希表实现的，HashMap允许键和值为null，线程不安全，特点：存储速度块
--------------| TreeMap  基于红黑数(二叉树)数据结构实现的，线程不同步(即线程不安全)，特点：会对元素经行排序存储
--------------| HashTable(了解即可)  线程安全

---

1、Map集合

在java中的map集合使用键(key)值(value)对 来保存数据，其中值(value)可以重复，但键(key)必须是唯一，也可以为空，但最多只能有一个key为空。

2、Map集合与collection集合的区别

1、Map一次存一对元素，一个是键，一个是值，键与值之间有对应(映射)关系；而Collection一次存一个元素。
    2、Map是双列集合，且是双例集合的跟接口；Collection是单列集合，且是单例集合的跟接口。

3、Map集合(接口)的一些方法

添加
   put(K key, V value)：将指定的值与该映射中的指定键相关联，并添加到集合中
   putAll(Map<? extends K,? extends V> m)：把指定集合中所有元素添加到指定的集合中(将指定集合的所有映射复制到此映射中)
删除
   remove(Object key)：根据指定的键，删除对应的值
   clear()：删除该集合中的所有元素
获取
   get(Object key)：根据指定的键，获取对应的值
   size()：返回该集合中键(元素)的个数
判断
   containsKey(Object key)：判断该集合中是否包含指定的键
   containsValue(Object value)：判断该集合中是否包含指定的值
   isEmpty()：判断该集合是否为空
迭代
   keySet()：
   values()：
   entrySet()：

4、实例

添加、删除、获取、判断的实例

 package com.dhb.collection;

 import java.util.HashMap;
 import java.util.Map;

 /**
  * @author DSHORE / 2018-5-29
  *
  */
 /* Map接口的一些方法
  *
  * 添加
  * put(K key, V value)：将指定的值与该映射中的指定键相关联，并添加到集合中
  * putAll(Map<? extends K,? extends V> m)：把指定集合中所有元素添加到指定的集合中(将指定集合的所有映射复制到此映射中)
  * 删除
  * remove(Object key)：根据指定的键，删除对应的值
  * clear():删除该集合中的所有元素
  * 获取
  * get(Object key)：根据指定的键，获取对应的值
  * size()：返回该集合中键(元素)的个数
  * 判断
  * containsKey(Object key)：判断该集合中是否包含指定的键
  * containsValue(Object value)：判断该集合中是否包含指定的值
  * isEmpty()：判断该集合是否为空
  * */
 public class Demo20 {
     public static void main(String[] args) {
         Map<String,String> map = new HashMap<String, String>();
         //添加
         map.put("成龙","林凤娇");
         map.put("文章","马伊琍");
         map.put("汪峰","章子怡");
         System.out.println(map);//返回值：{成龙=林凤娇, 文章=马伊琍, 汪峰=章子怡}
         System.out.println("返回值："+map.put("文章","王菲"));//返回值：马伊琍    解析：如果之前没有存在该键,那么返回的是null,如果之前就已经存在该键,那么返回值是该键之前的对应值
         Map<String,String> map2 = new HashMap<String, String>();
         map2.put("谢霆锋","张柏芝");
         map2.put("杨振宇","翁帆");
         map.putAll(map2);//把map2集合中的元素添加到map集合中
         System.out.println(map);//返回值：{成龙=林凤娇, 文章=王菲, 汪峰=章子怡, 谢霆锋=张柏芝, 杨振宇=翁帆}

         //删除
         System.out.println("根据指定的键，删除对应的值："+map.remove("文章"));//返回值：王菲   解析：被第二条输出语句给替换了值
         System.out.println(map);//返回值：{成龙=林凤娇, 汪峰=章子怡, 谢霆锋=张柏芝, 杨振宇=翁帆}
         /*map.clear();//删除集合中的所有元素
         System.out.println(map);//返回值：{}  已经删除成功，集合中没有元素了  */        

         //获取
         System.out.println("根据指定的键,获取对应的值："+map.get("汪峰"));//返回值：章子怡
         System.out.println(map);//返回值：{成龙=林凤娇, 汪峰=章子怡, 谢霆锋=张柏芝, 杨振宇=翁帆}
         System.out.println("获取map集合中键的个数："+map.size());//返回值：4

         //判断
         System.out.println("判断map集合中是否包含指定的键："+map.containsKey("文章"));//返回值：false
         System.out.println("判断map集合中是否包含指定的值："+map.containsValue("章子怡"));//返回值：true
         System.out.println("判断map集合是否为空元素："+map.isEmpty());//返回值：false
         map.clear();//删除集合中的所有元素
         System.out.println("判断map集合是否为空元素："+map.isEmpty());//返回值：true
     }
 }

迭代的实例（三种遍历方式）

 package com.dhb.collection;

 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;

 /**
  * @author DSHORE / 2018-5-29
  *
  */
 /*
  * 迭代:
  *  keySet()
  *  values()
  *  entrySet()
  * */
 public class Demo21 {
     public static void main(String[] args) {
         Map<String,String> map=new HashMap<String, String>();
         //添加方法
         map.put("汪峰","章子怡");
         map.put("文章","马伊俐");
         map.put("谢霆锋","张柏芝");
         map.put("成龙","林凤娇");
         System.out.println(map);//返回值：{成龙=林凤娇, 文章=马伊俐, 汪峰=章子怡, 谢霆锋=张柏芝}

         //map集合遍历方式一：使用keySet()方法进行遍历， 缺点：keySet值返回所有的键，没有值。
         Set<String> keys=map.keySet();    //keySet把Map集合中的所有键都存储到了set集合中的对象返回
         Iterator<String> it=keys.iterator();
         while(it.hasNext()){
             String key=it.next();
             System.out.println("键："+key+"，值："+map.get(key));
             /* 返回值：
              * 键：成龙，值：林凤娇
              * 键：文章，值：马伊俐
              * 键：汪峰，值：章子怡
              * 键：谢霆锋，值：张柏芝
              * */
         }

         //map集合遍历方式二：使用values()方法进行遍历。  使用values方法遍历，缺点：values方法只能返回值，没有键
          Collection<String> c=map.values();
         Iterator<String> it2=c.iterator();
         while(it2.hasNext()){
             System.out.println("值："+it2.next());
             /* 返回值：
              * 值：林凤娇
              * 值：马伊俐
              * 值：章子怡
              * 值：张柏芝
              * */
         }
         //map集合遍历方式三：使用entrySet()方法来遍历
         Set<Map.Entry<String,String>> entrys=map.entrySet();
         Iterator<Map.Entry<String,String>> it3=entrys.iterator();
         while(it3.hasNext()){
             Map.Entry<String, String> entry=it3.next();
             System.out.println("键："+entry.getKey()+"，值："+entry.getValue());
             /* 返回值：
              * 键：成龙，值：林凤娇
              * 键：文章，值：马伊俐
              * 键：汪峰，值：章子怡
              * 键：谢霆锋，值：张柏芝
              * */
         }
     }
 }

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/9104169.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）