Map-HashMap-LinkedHashMap-Map.Entry-Collections-可变参数

一.Map 接口(java.util)

定义:public interface Map<K,V>

介绍:
     (1)Map是一个接口,含有两个泛型,创建子类对象的时候,需要传递两个泛型的值;
     (2)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。(值可以重复)
     (3)Map集合是双列集合的顶层接口,Map中的方法,所有的子类都可以使用;

特点:
     (1)所有的键(K)必须唯一不能重复;
     (2)操作数据(增删改查)的时候,都是以键值对的形式操作,不能存单个的数据;
     (3)Map集合迭代(遍历)的时候,需要先转换成单列集合,再迭代;(利用ArrayList的构造方法:ArrayList(Collection<? extends E> c))
     (4)Map集合有2个泛型,分别代表key和value的数据类型;Map<K,V>
     (5)Map集合常见的子类有2个:
         HashMap:存与取的顺序不一致;(键的顺序存与取的顺序不一致)
         LinkedHashMap:保证存与取的顺序一致;

Map存自定义类型的key:
     如果map的key是自定义数据类型的时候,要求key必须唯一,不能重复,如果重复了,会覆盖对应的值;因此需要重写hashCode和equals方法!

Map接口中常用方法:
     public void clear():清除集合中的元素
     public boolean containsKey(Object key):判断指定键是否存在
     public boolean containsValue(Object value):判断指定键是否存在
     public Set<Map.Entry<K,V>> entrySet():将Map对象变为Set集合
     public boolean equals(Object o):对象比较
     public V get(Object k):根据Key取得Value,返回value值
     public int hashCode():返回哈希值
     public boolean isEmpty():查看集合是否为空
     public Set<K> keySet():取得所有Key,返回set集合
     public V put(K key, V value):向集合中加入元素,返回value值
     public void putAll(Map<? extends K, ? extends V>,m):将一个map集合加入到另一个map集合
     public V remove(Object K):根据键值删除Value,并返回删除的Value
     public int size():返回集合的长度,即有多少对
     public Collection<V> values():取出全部的Value
     void forEach(BiConsumer<? super K, ? super V> action):遍历key-value对的方法,java8新特性

代码演示:
  

  1   import java.util.HashMap;
  2      import java.util.Map;
  3      import java.util.Map.Entry;
  4      import java.util.Set;
  5      import java.util.Iterator;
  6      import java.util.Collection;
  7      public class MapTest{
  8          public static void main(String[]  args){
  9              //利用多态,创建一个Map对象
 10             Map<Integer,String> map = new HashMap<>();
 11              //向集合中添加键值对
 12             map.put(1,"Jack");
 13              map.put(2,"Rose");
 14              map.put(3,"Tom");
 15              map.put(4,"Green");
 16              //forEach遍历 java8新特性
 17             map.forEach((k,v)->System.out.println("key="+k+"; value="+v));
 18              //containsKey()判断键值是否存在
 19             System.out.println(map.containsKey("5"));//false
 20              //containsValue()判断Value值是否存在
 21             System.out.println(map.containsValue("Tom"));//true
 22              // //entrySet()变为set集合
 23             // Set<Entry<Integer,String>> set = map.entrySet();
 24              // System.out.println(set);
 25              // //遍历转换后的set集合
 26             // Iterator it = set.iterator();
 27              // while(it.hasNext()){
 28              //     System.out.print(it.next()+"\t");
 29              // }
 30              //remove(key)根据key值移除value,返回移除的value
 31              String str = map.remove(4);
 32              System.out.println(str);//Green
 33              //get(key),根据key值返回value值
 34             System.out.println(map.get(1));//Jack
 35              //size():查看集合长度
 36             System.out.println(map.size());//3--移除了一个
 37             //keySet():取出所有的key,返回set集合类型
 38             Set<Integer> setKey = map.keySet();
 39              for(int i : setKey){
 40                  System.out.print(i+"\t");//1 2 3
 41              }
 42              System.out.println("\n=======================");
 43              //values():取出全部的value,返加Collection
 44              Collection<String> c = map.values();
 45              Iterator it = c.iterator();
 46              while(it.hasNext()){
 47                  System.out.print(it.next()+"\t");//Jack    Rose    Tom
 48              }
 49          }
 50      }

二.HashMap 类(java.util)

定义:public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

介绍:基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
     此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

构造方法:
     HashMap()
     HashMap(Map<? extends K,? extends V> m)

常用方法:
     public void clear(){}:清除集合中的元素
     public boolean containsKey(Object key){}:是否包含键
     public boolean containsValue(Object value){}:是否包含值
     public Set<Map.entrySet<K,V>> entrySet(){}:得到全部键值对,并返回一个set集合;新的set集合里的数据是什么类型?
     public V get(Object k){}:通过键返回value;
     public boolean isEmpty(){}:是否为空;
     public Set<K> keySet():取得所有Key,返回一个set集合;
     public void put(Key k, Value v){}:添加元素
     public void putAll(Map<? extends K,? extends V> m):添加一个map集合
     public V remove(Object k){}:通过key删除对应的value,并返回删除的Value
     public int size(){}:查看有多少对键值对
     public Collection<V> values(){}:取出全部的value,返回一个Collection集合

代码演示:
    

  1 import java.util.HashMap;
  2      import java.util.Iterator;
  3      import java.util.Set;
  4      import java.util.Collection;
  5      public class HashMapTest{
  6          public static void main(String[] args){
  7              //构建一个hashMap集合
  8             HashMap<Integer,String> hashMap = new HashMap<>();
  9              HashMap<Integer,String> hashMap1 = new HashMap<>();
 10              //put(k,v)添加元素
 11             hashMap.put(1,"Jack");
 12              hashMap1.put(2,"Rose");
 13              hashMap1.put(3,"Smith");
 14              //putAll(map)添加一个集合
 15             hashMap.putAll(hashMap1);
 16              System.out.println(hashMap);//{1=Jack, 2=Rose, 3=Smith},注意是花括号
 17             //get(key)查看1对应的value
 18              System.out.println(hashMap.get(1));//Jack
 19              //contains(value)查看是否包含smith
 20              System.out.println(hashMap.containsValue("smith"));//false
 21              //keySet()取得所有的key,取得所有的key,并返回一个set集合
 22             Set<Integer> set = hashMap.keySet();
 23              Iterator it = set.iterator();
 24              while(it.hasNext()){
 25                  System.out.print(it.next()+"\t");//1 2 3
 26              }
 27              System.out.print("\n");
 28              //values()取得所有的value,返回一个Collection集合
 29             Collection<String> c = hashMap.values();
 30              for(String s : c){
 31                  System.out.print(s+"\t");//Jack    Rose    Smith
 32              }
 33              System.out.print("\n");
 34              //size()查看长度
 35             System.out.println(hashMap.size());//3
 36              //clear()清空集合
 37             hashMap.clear();
 38              //isEmpty()查看集合是否为空
 39             System.out.println(hashMap.isEmpty());//true
 40          }
 41      }

三.Map.Entry 接口(java.util)

定义:public static interface Map.Entry<K,V>
     在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，
     这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

常用方法:
     public K getKey():返回键值对对象的key
     public V getValue():返回键值对对象的value
     public v setValue(V value):设置value的值

Map集合的迭代方式1--键找值:
     思路:Map集合迭代的时候,只能先转换成单列集合,再通过迭代单列集合的方式,获取map中的键和值;
     步骤:1:获取一个装满key的set集合
         2:遍历set集合的时候,面向map集合,调用get方法,传递key,获取value;
     代码实现:
        

  1 import java.util.Map;
  2          import java.util.HashMap;
  3          import java.util.Set;
  4          import java.util.Iterator;
  5          import java.util.NoSuchElementException;
  6          public class MapTest01{
  7              public static void main(String[] args){
  8                  //构建map集合,多态
  9                 Map<Integer,String> map = new HashMap<>();
 10                  //put()添加键值对
 11                 map.put(1,"Jack");
 12                  map.put(2,"Rose");
 13                  map.put(3,"Tom");
 14                  //获取所有的key  keySet() 返回Set集合
 15                 Set<Integer> set = map.keySet();
 16                  //利用迭代器取出key对应的value
 17                  Iterator<Integer> it = set.iterator();
 18                  try{
 19                      while(it.hasNext()){
 20                          int i = it.next();
 21                          System.out.print(i+"<===>"+map.get(i)+"\t");//1<===>Jack    2<===>Rose    3<===>Tom
 22                      }
 23                  }catch(NoSuchElementException e){
 24                      System.out.println("查无此元素!");
 25                      e.printStackTrace();
 26                  }
 27
 28              }
 29          }

Map集合的迭代方式2--键值对对象:
     思路:Map集合迭代的时候,只能先转换成单列集合(获取键值对对象),再通过迭代单列集合的方式,获取map中的键和值;
     步骤:1:面向map集合对象,获取一个装满了键值对对象的set集合;
         2:面向set集合,迭代set集合,可以获取每一个键值对对象;
         3:面向每一个键值对对象,获取key和value;
     代码实现:
       

  1  import java.util.Map;
  2          import java.util.HashMap;
  3          import java.util.Map.Entry;
  4          import java.util.Set;
  5          public class MapTest02{
  6              public static void main(String[] args){
  7                  //构建map集合,多态
  8                 Map<Integer,String> map = new HashMap<>();
  9                  //put()添加键值对
 10                 map.put(1,"Jack");
 11                  map.put(2,"Rose");
 12                  map.put(3,"Tom");
 13                  //获取所有的键值对对象 entrySet() 返回Set<Entry<>>
 14                  Set<Entry<Integer,String>> set = map.entrySet();
 15                  //foreach
 16                  for(Entry en : set){
 17                      System.out.print(en.getKey()+"<===>"+en.getValue()+"\t");//1<===>Jack    2<===>Rose    3<===>Tom
 18                  }
 19              }
 20          }

四.Collections 类(java.util)

定义:public class Collections extends Object

介绍:此类完全由在Collection 上进行操作或返回;由Collection的静态方法组成。就是一个操作collection 的工具类;

常用方法:

public static<T> boolean addAll(Collections<? super T> c, T... a){}:为集合添加内容

public static<T> boolean replaceAll(List<T> list, T oldVal, T newVal):用新内容替换指定内容

public static void reverse(List<?> list){}:集合反转

public static shuffle(List<?> list){}:乱序

public static <T extends Comparable<? super T>> void sort(List<T> list){}:根据元素的自然顺序 对指定列表按升序进行排序。
                                                                             要求1:参数必须是list集合
                                                                             要求2:list集合中存放的元素必须是可以排序的数据类型;

public static <T> List<T> unmodifiableList(List<? extends T> list){}:返回指定列表的不可修改视图。(返回的集合,不能进行增删改的操作,只能进行查询的操作)

五.可变参数
     介绍:所谓的可变参数,实质上就是一个数组!当方法的参数是同一个数据类型且个数不确定的时候,可以使用可变参数表示;
             可变参数是JDK1.5之后出现的新特性;
     好处:
         1:可以接受的数据的个数是0-n个
         2:可变参数的代码形式比数组简单;
         3:如果参数类型是可变参数类型,传递的时候,可以传递数组,也可以传递零散的数据;
     可变参数的格式:
         方法修饰符   方法返回值类型   方法名 (数据类型...  参数名){
             方法体
         }
     注意事项:
         可变参数必须写在参数列表的最后面;

六.引用的四种类型:由高到低:强引用/软引用/弱引用/虚引用
     从JDK1.2开始,java把对象的引用分为4种级别,从而使程序可以更加灵活的控制对象的生命周期.
         强引用:当内存不足时,JVM宁可出现OutOfMemeryError错误而使程序停止,也不会回收此对象来释放空间;
         软引用:当内存不足时,会回收这些对象的内存,来实现内存敏感的调整缓存;
         弱引用:无论内存是否紧张,被垃圾回收器发现立即回收;
         虚引用:和没有任何引用一样;

七.LinkedHashMap 类(java.util)

定义:public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

简介:LinkedHashMap是链表和哈希表组合的一个数据存储结构,在HashMap的基础上保证了存取顺序一致

构造方法:
     LinkedHashMap(Map<? extends K,? extends V> m)

常用方法:
     public void clear(){}:清除元素;
     public boolean containsValue(Object value){}:查询是否包含某value值
     public Set<Map.Entry<K,V>> entrySet(){}:返回键值对对象的Set集合
     public void forEach(BiConsumer<? super K,? super V> action){}:????????????????????????????????
     public V get(Object key){}:通过key获取对应的value值
     public Set<K> keySet(){}:返回包含所有key值的Set集合
     public Collection<V> values(){}:返回包含所有values的Collection集合

代码演示：
    

  1 import java.util.LinkedHashMap;
  2      import java.util.Map.Entry;
  3      import java.util.Set;
  4      import java.util.List;
  5      import java.util.ArrayList;
  6     import java.util.ListIterator;
  7      import java.util.Collection;
  8      import java.util.Iterator;
  9      public class LinkedHashMapTest{
 10          public static void main(String[] args){
 11              //构建LinkedHashMap集合
 12             LinkedHashMap<Integer,String> lhm = new LinkedHashMap<>();
 13              //添加3个元素
 14             lhm.put(1,"Jack");
 15              lhm.put(2,"Rose");
 16              lhm.put(3,"Green");
 17              //得到以键值对为对象的Set集合
 18             Set<Entry<Integer,String>> entrySet = lhm.entrySet();
 19              //遍历取出,看是否与存入顺序一致
 20             for(Entry en : entrySet){
 21                  System.out.print(en+"\t");//1=Jack    2=Rose    3=Green与存入顺序一致
 22             }
 23              //得到以key值为对象的Set集合
 24             Set<Integer> keySet = lhm.keySet();
 25              //转成List,使用ListIterator迭代
 26             List<Integer> keyList = new ArrayList<>(keySet);
 27              ListIterator<Integer> lit = keyList.listIterator();
 28              //System.out.println(keyList);
 29              while(lit.hasNext()){
 30                  System.out.print(lit.next()+"\t");//1    2    3
 31              }
 32              //得到所有value值
 33             Collection<String> c = lhm.values();
 34              Iterator<String> lit1 = c.iterator();
 35              while(lit1.hasNext()){
 36                  System.out.print(lit1.next()+"\t");//Jack    Rose    Green
 37              }
 38              System.out.println(c);//[Jack, Rose, Green]
 39          }
 40      }