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));

           }

      }

}

运行结果：