集合框架（下）

集合框架（下） Map接口

|----Map:双列数据，存储key-value对的数据   ----类似于高中的函数：y=f(x)
          |----HashMap:作为Map的主要实现类;线程不安全的，效率高；存储null的key和value
                 |----linkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
                  原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素
对于频繁的遍历 *** 作，此类执行效率高于HashMap。
          |----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排                                            序或定制排序。底层使用红黑树
          |----Hashtable:作为古老的实现类;线程安全的，效率低；不能存储null的key和value
                 |Properties:常用来处理配置文件。key和value都是String类型

   HashMap的底层：数组+链表（jdk7及之前）
                 数组+链表+红黑树 （jdk 8）

Map结构的理解

Map中的key：无序的、不可重复的，使用Set存储所有的key  ---->key所在的类要重写equals()和hashCode()  (以HashMap为例)
Map中的value:无序的、可重复的，使用Collection存储所有的value   ---->value所在的类要重写equals()
一个键值对：key-value构成了一个Entry对象
Map中的entry：无序的、不可重复的，使用Set存储所有的entry

 Map常用方法

添加：put(Object key,Object value)
删除：remove(Object key)
修改：put(Object key,Object value)
查询：get(Object key)
长度：size()
遍历：keySet() / values() / entrySet()

Map中定义的方法

添加、删除、修改 *** 作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
元素查询的 *** 作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
元视图 *** 作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

public class MapTest {

    
    @Test
    public void test5(){
          Map map=new HashMap();
          map.put("AA",123);
          map.put(45,123);
          map.put("BB",56);

          //遍历所有的key集：keySet()
          Set set =map.keySet();
          Iterator iterator = set.iterator();
          while (iterator.hasNext()){
              System.out.println(iterator.next());
          }
          System.out.println("********************");
          //遍历所有的value类：values()
          Collection values = map.values();
          for(Object obj:values){
              System.out.println(obj);
          }

          //遍历所有的key-value
        //方式一：entrySet():
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
        System.out.println("**********************");

        //方式二：
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key + "=====" + value);
        }


    }

    
      @Test
      public void test4(){
          Map map=new HashMap();
          map.put("AA",123);
          map.put(45,123);
          map.put("BB",56);
          //Object get(Object key)
          System.out.println(map.get(45));
          //containsKey(Object key)
          boolean isExist=map.containsKey("BB");
          System.out.println(isExist);
          //containsValue(Object value)
          isExist=map.containsValue(123);
          System.out.println(isExist);
          //isEmpty()
          map.clear();
          System.out.println(map.isEmpty());

      }

    
    @Test
    public void test3(){
        Map map=new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //修改
        map.put("AA",87);
        System.out.println(map);
        Map map1=new HashMap();
        map1.put("cc",123);
        map1.put("dd",123);
        map.putAll(map1);
        System.out.println(map);
        //remove(Object key)
        Object value = map.remove("cc");
        System.out.println(value);
        System.out.println(map);
        //clear()
        map.clear();//与map=null不同
        System.out.println(map.size());


    }

HashMap在jdk7中实现原理

ashMap map=new HashMap();
在实例化以后，底层创建了长度是16的一维数组Entry[] table.
...可能已经执行过多次put....
map.put(hey1,value1):
首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置
如果此位置上的数据为空，此时的key1-value添加成功。  ----情况1
如果此位置的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
        如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。  ----情况2
        如果key1的哈希值和已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals()方法，比较：
                    如果equals()返回false:此时key1-value1添加成功。   ----情况3
                    如果equals()返回true：使用value1替换value2。

   补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

   不断的添加过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来

HashMap在jdk8 中相较于jdk7在底层实现方面的不同：

1.new HashMap():底层没有创建一个长度为16的数组
2.jdk 8底层的数组是：Node[],而非Entry[]
3.首次调用put()方法时，底层创建长度为16的数组
4.jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。
    4.1形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
    4.2当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

TreeMap

向TreeMap中添加key-value，要求key必须是由同一个类创建的对象

因为要照key进行排序：自然排序、定制排序（参考TreeSet）

Properties

常用来处理配置文件。key和value都是String类型

public class PropertiesTest {
    //Properties:常用来处理配置文件。key和value都是String类型
    public static void main(String[] args){
        FileInputStream fis = null;
        try {
            Properties pros = new Properties();
            fis = new FileInputStream("jdbc.properties");
            pros.load(fis); //加载流对应文件

            String name = pros.getProperty("name");
            String password = pros.getProperty("password");

            System.out.println("name = " + name + ",password = " + password);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Collections工具类

*** 作Collection、Map的工具类

常用方法

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

说明：ArrayList和HashMap都是线程不安全的，如果程序要求线程安全，我们可以将ArrayList、HashMap转换为线程安全的。使用synchronizedList（List list）和synchronizedMap（Map map）