guava之map

  先来看下传统方法建立map,list:

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

Map<String, Integer> map = new HashMap<String, Integer>(); 

  有了guava，则可以简单了：

List<String> list = Lists.newArrayList(); 
Map<String, Integer> list = Maps.newHashMap(); 

  用到的是lists,maps的工具类
  可以这样：
List<Integer> list = Lists.newArrayList(1, 2, 3); 

1） 不可变list和map
   
不可变集合，顾名思义就是说集合是不可被修改的。集合的数据项是在创建的时候提供，并且在整个生命周期中都不可改变。

　　为什么要用immutable对象？immutable对象有以下的优点：
　　　　1.对不可靠的客户代码库来说，它使用安全，可以在未受信任的类库中安全的使用这些对象
　　　　2.线程安全的：immutable对象在多线程下安全，没有竞态条件
　　　　3.不需要支持可变性, 可以尽量节省空间和时间的开销. 所有的不可变集合实现都比可变集合更加有效的利用内存 (analysis)
　　　　4.可以被使用为一个常量，并且期望在未来也是保持不变的

　　immutable对象可以很自然地用作常量，因为它们天生就是不可变的对于immutable对象的运用来说，它是一个很好的防御编程（defensive programming）的技术实践。


   创建的方法简单：


ImmutableList<Integer> list = ImmutableList.of(1, 2, 3); 




Immutable集合使用方法：
　　一个immutable集合可以有以下几种方式来创建：
　　1.用copyOf方法, 譬如, ImmutableSet.copyOf(set)
　　2.使用of方法，譬如，ImmutableSet.of("a", "b", "c")或者ImmutableMap.of("a", 1, "b", 2)
　　3.使用Builder类

　　实例：


@Test
    public void testGuavaImmutable(){
       
        List<String> list=new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println("list："+list);
       
        ImmutableList<String> imlist=ImmutableList.copyOf(list);
        System.out.println("imlist："+imlist);
       
        ImmutableList<String> imOflist=ImmutableList.of("peida","jerry","harry");
        System.out.println("imOflist："+imOflist);
       
        ImmutableSortedSet<String> imSortList=ImmutableSortedSet.of("a", "b", "c", "a", "d", "b");
        System.out.println("imSortList："+imSortList);
       
         list.add("baby");
         System.out.println("list add a item after list:"+list);
         System.out.println("list add a item after imlist:"+imlist);
            
         ImmutableSet<Color> imColorSet =
               ImmutableSet.<Color>builder()
                   .add(new Color(0, 255, 255))
                   .add(new Color(0, 191, 255))
                   .build();
        
         System.out.println("imColorSet:"+imColorSet);      
    }

　　输出：


list：[a, b, c]
imlist：[a, b, c]
imOflist：[peida, jerry, harry]
imSortList：[a, b, c, d]
list add a item after list:[a, b, c, baby]
list add a item after imlist:[a, b, c]
imColorSet:[java.awt.Color[r=0,g=255,b=255], java.awt.Color[r=0,g=191,b=255]]

2  SortedMap

@Test
public void whenUsingSortedMap_thenKeysAreSorted() {
    ImmutableSortedMap<String, Integer> salary = new ImmutableSortedMap
      .Builder<String, Integer>(Ordering.natural())
      .put("John", 1000)
      .put("Jane", 1500)
      .put("Adam", 2000)
      .put("Tom", 2000)
      .build();
 
    assertEquals("Adam", salary.firstKey());
    assertEquals(2000, salary.lastEntry().getValue().intValue());
}

3 BiMap
   就是MAP翻转了
   

@Test
public void whenCreateBiMap_thenCreated() {
    BiMap<String, Integer> words = HashBiMap.create();
    words.put("First", 1);
    words.put("Second", 2);
    words.put("Third", 3);
 
    assertEquals(2, words.get("Second").intValue());
    assertEquals("Third", words.inverse().get(3));
}

  

4 Multimap
   就是一个键多个值
  

@Test
public void whenCreateMultimap_thenCreated() {
    Multimap<String, String> multimap = ArrayListMultimap.create();
    multimap.put("fruit", "apple");
    multimap.put("fruit", "banana");
    multimap.put("pet", "cat");
    multimap.put("pet", "dog");
 
    assertThat(multimap.get("fruit"), containsInAnyOrder("apple", "banana"));
    assertThat(multimap.get("pet"), containsInAnyOrder("cat", "dog"));
}

5 TABLE
  
   当我们需要多个索引的数据结构的时候，通常情况下，我们只能用这种丑陋的Map<FirstName,  Map<LastName, Person>>来实现。为此Guava提供了一个新的集合类型－Table集合类型，来支持这种数据结构的使用场景。Table支持“row”和“column”，而且提供多种视图。
   

@Test
public void whenCreatingTable_thenCorrect() {
    Table<String,String,Integer> distance = HashBasedTable.create();
    distance.put("London", "Paris", 340);
    distance.put("New York", "Los Angeles", 3940);
    distance.put("London", "New York", 5576);
 
    assertEquals(3940, distance.get("New York", "Los Angeles").intValue());
    assertThat(distance.columnKeySet(), 
      containsInAnyOrder("Paris", "New York", "Los Angeles"));
    assertThat(distance.rowKeySet(), containsInAnyOrder("London", "New York"));
}

   说的简单点，table其实就是：
有行（Row）和列（Column），数据在一个格子（Cell）中。

Table可以是稀疏的。



  　Table视图：
　　rowMap()返回一个Map<R, Map<C, V>>的视图。rowKeySet()类似地返回一个Set<R>。
　　row(r)返回一个非null的Map<C, V>。修改这个视图Map也会导致原表格的修改。
　　和列相关的方法有columnMap(), columnKeySet()和column(c)。（基于列的操作会比基于行的操作效率差些）
　　cellSet()返回的是以Table.Cell<R, C, V>为元素的Set。这里的Cell就类似Map.Entry，但是它是通过行和列来区分的。

　　Table有以下实现：
　　HashBasedTable：基于HashMap<R, HashMap<C, V>>的实现。
　　TreeBasedTable：基于TreeMap<R, TreeMap<C, V>>的实现。
　　ImmutableTable：基于ImmutableMap<R, ImmutableMap<C, V>>的实现。（注意，ImmutableTable已对稀疏和密集集合做了优化）
　　ArrayTable：ArrayTable是一个需要在构建的时候就需要定下行列的表格。这种表格由二维数组实现，这样可以在密集数据的表格的场合，提高时间和空间的效率。



    其中对table很好的介绍见
http://davyjones2010.iteye.com/blog/2094017 一文