JAVA 中的LinkedHashMap 使用场景

package  audaque .  com .  pbting .  collection .  test ;

import  java .  util .  ArrayList ;

import  java .  util .  Iterator ;

import  java .  util .  LinkedHashMap ;

import  java .  util .  List ;

import  java .  util .  Map .  Entry ;

/**

 * 这里稍微理清一下LinkedHashMap 对于访问排序的原理：

 *

 * 当我们指定了按访问的顺序进行排序的时候，那么这个时候LinkedHashMap 会这样来处理，就是

 * 移除当前的这个key，然后将这个key 放到最后，以此来实现访问的顺序。所以说如果最后一次访问的元素

 * 他总是在链表中的末尾。为什么他要基于HashMap 来实现这么一个链表呢？那是因为基于他的查找因素很快，然后直接

 * 移除，并将它添加到末尾。它相比与传统的LinkedList的不同就在于他查找所要移除的元素比较快，而LinkedList

 * 要是移除宇哥元素的话还要一次遍历这个链表然后在做移除的操作。所以如果以后还想要使用ArrayList或者LinkedList

 * 来存储数据的话，不妨做好改用LinkedHashMap，它不仅提供了类似于ArrayList 基于角标查询的速度，又有LinkedList

 * 快速删除的特点。此外他还有一个更强大的功能就是可以基于访问的次序进行排序。即最后一次访问的元素总是放于最后的。对访问的频率

 * 不做影响。

 *

 *

 *

 *  @author  Administrator

 *

 */

public   class   LinkedHashMapTest   {

       /**

      *  @param  args

      */

       public   static   void   main( String  []  args )   {

            //  TODO  Auto-generated method stub

            LinkedHashMap <String,  String>  lm  =

                     new   LinkedHashMap<String,String>(  16 ,  0 .  75f ,true);

          

          lm  .put("key-1",   "val-1");

          lm  .put("key-2",   "val-2");

          lm  .put("key-3",   "val-3");

          lm  .put("key-4",   "val-4");

          

          

            for(  Entry <String,   String>  entry :  lm .entrySet()){

              

                 System .out.println(  entry .getKey()+"--"+  entry .getValue());

            }

          lm  .get("key-3");

          lm  .get("key-3");

          lm  .get("key-2");

            System .out.println("---------------");

            for(  Entry <String,   String>  entry :  lm .entrySet()){

              

                 System .out.println(  entry .getKey()+"--"+  entry .getValue());

            }

          

            Iterator <String>  keyIt  =  lm .keySet().iterator();

          

            List <String>  targetkeys  =  new  ArrayList<String>();

          

            while(  keyIt .hasNext()){

                String  key  =  keyIt .next();

              

                /**

               * 这里会抛出异常，那是因为当你在迭代key 时他要保证key 的同步关系，即key 在集合中的顺序

               * 是不能发生改变的。因此在一开始迭代时，他会给这个路口上一个锁，来标识当前我在迭代key，如果

               * 有其他操作想更改key的顺序，我是不允许的。那么在迭代key 时还有什么意思和相关的应用场景呢？

               * 如果仅仅是想过的我们想要的key,然后再去取值操作，那为什么不直接使用HashMap提供的get(key)

               * 方法来去呢？这个时候我目前想到的一个应用场景就是：

               * 当这个集合中的数据不是有我们所管理的时候，我们仅仅是由读取的权限，那么这个时候我们就可以使用便利

               * key的方法来处理我们想要的操作。比如说底层处理好的操作给我们传一个LinkedHashMap，然后我们就可以对我们

               * 感兴趣的key进行相关的操作。

               */

                if(  key .equals("key-2")   ||  key .equals("key-3"))

               targetkeys .add(  key );

            }

          

            //然后再在这里做相关的处理

            for( String  key  :  targetkeys ){

              

                System .out.println(  lm .get(  key ));

            }

       }

}

运行结果：