guava学习--集合1

Lists:

其内部使用了静态工厂方法代替构造器，提供了许多用于List子类构造和操作的静态方法，我们简单的依次进行说明，如下：

newArrayList()：构造一个可变的、空的ArrayList实例。

newArrayList(E... elements)：构造一个可变的包含传入元素elements的ArrayList实例。

newArrayList(Iterable<? extends E> elements)：构造一个可变的包含传入元素elements的ArrayList实例。

newArrayListWithCapacity( int initialArraySize)：构造一个分配 指定空间大小的ArrayList实例。

newArrayListWithExpectedSize( int estimatedSize)：构造一个期望长度为estimatedSize的ArrayList实例。

newLinkedList()：构造一个空的LinkedList实例。

newLinkedList( Iterable<? extends E> elements)：构造一个包含传入元素elements的LinkedList实例。

newCopyOnWriteArrayList()：构造一个空的CopyOnWriteArrayList实例。

newCopyOnWriteArrayList( Iterable<? extends E> elements)：构造一个包含传入元素elements的CopyOnWriteArrayList实例。

asList(@Nullable E first, E[] rest)：返回一个不可变的List，其中包含指定的第一个元素和附加的元素数组组成，修改这个数组将反映到返回的List上。

asList( @Nullable E first, @Nullable E second, E[] rest)： 返回一个不可变的List，其中包含指定的第一个元素、第二个元素和附加的元素数组组成，修改这个数组将反映到返回的List上。

transform( List fromList, Function<? super F, ? extends T> function)：根据传进来的function对fromList进行相应的处理，并将处理得到的结果存入到新的list对象中返回。

partition(List list, int size)：根据size传入的List进行切割，切割成符合要求的小的List，并将这些小的List存入一个新的List对象中返回。

charactersOf(String string)、charactersOf(CharSequence sequence)：将传进来的String或者CharSequence分割为单个的字符，并存入到一个ImmutableList对象中返回。 （ImmutableList：一个高性能、不可变的、随机访问列表的实现 ）

reverse(List list)：返回一个传入List内元素倒序后的List。

接下来，我们通过下面的示例代码，来继续加深对Lists的理解，代码如下：

/**
 * Lists：处理List实例的实用类
 * User: Realfighter
 * Date: 2014/8/31
 * Time: 22:45
 */
public class ListsTest {

    @Test
    public void testLists() {
        /**
         * 一些构造List实例的方法很简单
         * 如：newArrayList(),newLinkedList()等
         * 这里不再赘述
         */
        String str = "i love u";//测试用
        String[] strs = {"i like u", "i miss u"};//测试用
        /**
         * asList：返回一个不可变的List
         * 其中包含指定的第一个元素和附加的元素数组组成
         * 修改这个数组将反映到返回的List上
         */
        List<String> list = Lists.asList(str, strs);
        System.out.println(list); //[i love u, i like u, i miss u]
        strs[1] = "i hate u";//对strs数组的修改会反映到List中
        System.out.println(list);//[i love u, i like u, i hate u]
        /**
         * transform：根据传进来的function对fromList进行相应的处理
         * 并将处理得到的结果存入到新的list对象中返回
         */
        List<String> newList = Lists.transform(list, new Function<String, String>() {
            @Override
            public String apply(String input) {
                //这里简单的对集合中的元素转换为大写
                return input.toUpperCase();
            }
        });
        System.out.println(newList);//[I LOVE U, I LIKE U, I HATE U]
        /**
         * partition：根据size传入的List进行切割，切割成符合要求的小的List
         * 并将这些小的List存入一个新的List对象中返回
         */
        List<List<String>> lists = Lists.partition(list, 2);
        System.out.println(lists);//[[i love u, i like u], [i hate u]]
        /**
         * charactersOf：将传进来的String或者CharSequence分割为单个的字符
         * 并存入到一个ImmutableList对象中返回
         * ImmutableList：一个高性能、不可变的、随机访问列表的实现
         */
        ImmutableList<Character> characters = Lists.charactersOf("realfighter");
        System.out.println(characters);//[r, e, a, l, f, i, g, h, t, e, r]
        /**
         * reverse：返回一个传入List内元素倒序后的List
         */
        List<String> reverse = Lists.reverse(list);
        System.out.println(reverse);//[i hate u, i like u, i love u]
    }

}

Sets：

Sets内部使用了静态工厂方法代替构造器，提供了许多用于Set子类构造和操作的静态方法，我们简单的依次进行说明，如下：

immutableEnumSet( E anElement, E... otherElements)：返回一个包含给定枚举元素的不可变的Set实例。

immutableEnumSet( Iterable<E> elements)：返回一个包含给定枚举元素的不可变的Set实例。

newEnumSet(Iterable<E> iterable,Class<E> elementType)：返回一个包含给定元素的EnumSet实例，与EnumSet#copyOf(Collection)方法不同，当给定集合为 空的时候，不会产生异常，它可以转换任何实现了Iterable接口的类，不仅仅是Collection。它会先根据传入的元素类型创建一个空的 EnumSet，再把给定的元素添加到EnumSet返回。

newHashSet()：返回一个可变的空的HashSet实例。

newHashSet(E... elements)：返回一个可变买的HashSet包含给定的元素。

newHashSetWithExpectedSize(int expectedSize)：构造一个期望长度为expectedSize的HashSet实例。

newHashSet(Iterable<? extends E> elements)：返回一个可变的HashSet包含给定的元素，给定元素实现Iterable接口。

newHashSet(Iterator<? extends E> elements)：返回一个可变的HashSet包含给定的元素，给定元素实现Iterator接口。

newConcurrentHashSet()：创建一个线程安全的Set，由ConcurrentHashMap的实例支持，因此进行了相同的并发性担保，与HashSet不同的是，这个Set不允许null元素，该Set是可序列化的。

newConcurrentHashSet( Iterable<? extends E> elements)：创建一个线程安全的Set，包含给定的元素，由ConcurrentHashMap的实例支持，因此进行了相同的并发性担保，与 HashSet不同的是，这个Set不允许null元素，该Set是可序列化的。

newLinkedHashSet()：创建一个可变的、空的LinkedHashSet实例。

newLinkedHashSetWithExpectedSize( int expectedSize)：构造一个期望长度为expectedSize的LinkedHashSet实例。

newLinkedHashSet( Iterable<? extends E> elements)：构造一个包含给定元素的LinkedHashSet实例。

newTreeSet()：返回一个可变的空的TreeSet实例。

newTreeSet( Iterable<? extends E> elements)：返回一个可变的包含给定元素的TreeSet实例。

newTreeSet(Comparator<? super E> comparator)：创建一个具有给定的比较器可变TreeSet的实例。

newIdentityHashSet()：创建一个空的Set，使用特性来确定是否相等。

newCopyOnWriteArraySet()：创建一个空的CopyOnWriteArraySet实例。

newCopyOnWriteArraySet( Iterable<? extends E> elements)：创建一个包含给定元素的CopyOnWriteArraySet实例。

complementOf(Collection<E> collection)：创建一个EnumSet包括不属于指定集合中的所有枚举值。

complementOf( Collection<E> collection, Class<E> type)：创建一个EnumSet包括不属于指定集合中的所有枚举值。

newSetFromMap(Map<E, Boolean> map)：返回一个由给定map支持的Set。

union( final Set<? extends E> set1, final Set<? extends E> set2)：返回两个set集合的并集的不可修改SetView。（若A和B是集合，则A和B并集是有所有A的元素和所有B的元素，而没有其他元素的集 合）

intersection( final Set<E> set1, final Set<?> set2)：返回两个set集合的交集的不可修改SetView。（两个集合A 和 集合B 的交集是指含有所有既属于 A 又属于 B 的元素，而没有其他元素的集合）

difference( final Set<E> set1, final Set<?> set2)：返回两个set集合的差的不可修改SetView。（A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做A与B的差集）

symmetricDifference( Set<? extends E> set1, Set<? extends E> set2)：返回两个set集合的对称差的不可修改SetView。（对称差，即两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的 集合）

filter(Set<E> unfiltered, Predicate<? super E> predicate)：返回传入Set集合unfiltered中满足给定Predicate的元素集合Set。

filter( SortedSet<E> unfiltered, Predicate<? super E> predicate)：返回传入SortedSet集合unfiltered中满足给定Predicate的元素集合SortedSet。

filter( NavigableSet<E> unfiltered, Predicate<? super E> predicate)：返回传入NavigableSet集合unfiltered中满足给定Predicate的元素集合NavigableSet。

cartesianProduct( List<? extends Set<? extends B>> sets)：返回通过从各给定集中选择一个元素所形成每一个可能的集合。

cartesianProduct( Set<? extends B>... sets)：返回通过从各给定集中选择一个元素所形成每一个可能的集合。

powerSet(Set<E> set)：返回一个set，包含给定set的所有可能父级集合。

unmodifiableNavigableSet( NavigableSet<E> set)：返回指定NavigableSet的不可修改视图。

synchronizedNavigableSet( NavigableSet<E> navigableSet)：返回一个同步的（线程安全的）NavigableSet，由指定的NavigableSet支持。

Sets类中提供的方法很多，我们这里对其中的一些重点和特别的方法做一些示例学习，其他的方法不再赘述，示例代码如下：

/**
 * Sets：处理Set实例的实用类
 * User: Realfighter
 * Date: 2014/9/3
 * Time: 20:00
 */
public class SetsTest {

    Set<Integer> set1;//测试用
    Set<Integer> set2;//测试用

    /**
     * 初始化测试集合
     */
    @Before
    public void setUp() {
        set1 = Sets.newHashSet(1, 2, 3, 4, 5);
        set2 = Sets.newHashSet(1, 3, 5, 7, 9);
    }

    /**
     * filter：返回传入Set集合unfiltered中满足给定Predicate的元素集合Set
     */
    @Test
    public void testFilter() {
        Set<String> set = Sets.newHashSet("i like u", "i miss u", "i love u");
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean apply(String input) {
                //过滤包含字母l的元素
                return input.contains("l");
            }
        };
        //输出：[i like u, i love u]
        System.out.println(Sets.filter(set, predicate));
    }

    /**
     * difference：返回两个set集合的差的不可修改SetView
     * A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做A与B的差集
     */
    @Test
    public void testDifference() {
        //输出：[2, 4]
        System.out.println(Sets.difference(set1, set2));
    }

    /**
     * symmetricDifference：返回两个set集合的对称差的不可修改SetView
     * 对称差，即两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合
     */
    @Test
    public void testSymmetricDifference() {
        //输出：[2, 4, 9, 7]
        System.out.println(Sets.symmetricDifference(set1, set2));
    }

    /**
     * intersection：返回两个set集合的交集的不可修改SetView
     * 两个集合A和集合B的交集是指含有所有既属于A又属于B的元素，而没有其他元素的集合
     */
    @Test
    public void testIntersection() {
        //输出：[1, 3, 5]
        System.out.println(Sets.intersection(set1, set2));
    }

    /**
     * Union：返回两个set集合的并集的不可修改SetView
     * 若A和B是集合，则A和B并集是有所有A的元素和所有B的元素，而没有其他元素的集合
     */
    @Test
    public void testUnion() {
        //输出：[1, 2, 3, 4, 5, 9, 7]
        System.out.println(Sets.union(set1, set2));
    }

    /**
     * cartesianProduct：返回通过从各给定集中选择一个元素所形成每一个可能的集合
     */
    @Test
    public void testCartesianProduct() {
        Set<String> set1 = Sets.newHashSet("i love u", "i hate u");
        Set<String> set2 = Sets.newHashSet("tom", "jerry");
        Set<List<String>> sets = Sets.cartesianProduct(set1, set2);
        //输出：[[i hate u, tom], [i hate u, jerry], [i love u, tom], [i love u, jerry]]
        System.out.println(sets);
    }

    /**
     * powerSet：返回一个set，包含给定set的所有可能父级集合
     */
    @Test
    public void testPowerSet() {
        Set<String> set1 = Sets.newHashSet("i love u", "i hate u");
        Set<Set<String>> sets = Sets.powerSet(set1);
        for (Set<String> set : sets) {
            System.out.print(set);
        }
        //输出：[][i hate u][i love u][i hate u, i love u]
    }

}

Maps：

immutableEnumMap( Map<K, ? extends V> map)：返回包含给定项的不可变映射实例。

newHashMap()：构造一个可变的空的HashMap实例。

newHashMapWithExpectedSize(int expectedSize)：构造一个期望长度为expectedSize的HashMap实例。

newHashMap( Map<? extends K, ? extends V> map)：构造一个与给定map有相同映射关系的可变HashMap实例。

newLinkedHashMap()：构造一个可变的、空的、插入排序的LinkedHashMap实例。

newLinkedHashMap( Map<? extends K, ? extends V> map)：构造一个可变的、插入排序的、与给定map有相同映射关系的LinkedHashMap实例。

newConcurrentMap()：返回一个通用的ConcurrentMap实例，支持ConcurrentMap接口的所有可选操作，它不允许null键或值，它是可序列化的。

newTreeMap()：构造一个可变的、空的TreeMap实例。

newTreeMap(SortedMap<K, ? extends V> map)：构造一个可变的、与给定SortedMap有相同映射关系的TreeMap实例。

newTreeMap( @Nullable Comparator<C> comparator)：构造一个可变的、空的、使用给定比较器的TreeMap实例。

newEnumMap(Class<K> type)：构造一个具有给定键类型的EnumMap实例。

newEnumMap( Map<K, ? extends V> map)：构造一个与给定map有相同映射关系的EnumMap实例。

newIdentityHashMap()：构造一个IdentityHashMap实例。

difference( Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right)：返回两个给定map之间的差异。

difference( Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right, Equivalence<? super V> valueEquivalence)：返回两个给定map之间的差异，通过所提供的valueEquivalence进行等值比较。

difference( SortedMap<K, ? extends V> left, Map<? extends K, ? extends V> right)：返回两个已排序的Map之间的差异，通过给定left的比较器。

asMap( Set<K> set, Function<? super K, V> function)：返回一个活动的map，键值为给定的set中的值，value为通过给定Function计算后的值。

asMap( SortedSet<K> set, Function<? super K, V> function)：返回有序Set集合的map表示，根据给定的Function从给定的Set中映射键值。

asMap( NavigableSet<K> set, Function<? super K, V> function)：返回NavigableSet集合的map表示，根据给定的Function从给定的Set中映射键值。

toMap(Iterable<K> keys,Function<? super K, V> valueFunction)、toMap(Iterator<K> keys,Function<? super K, V> valueFunction)：返回一个不可变的ImmutableMap实例，其键值为给定keys中去除重复值后的值，其值为键被计算了 valueFunction后的值。

uniqueIndex(Iterable<V> values, Function<? super V, K> keyFunction)、uniqueIndex(Iterator<V> values, Function<? super V, K> keyFunction)：返回一个不可变的ImmutableMap实例，其值为按照给定顺序的给定的values值，键值为相应的值经过给定 Function计算后的值。

fromProperties(Properties properties)：通过给定的Properties实例，返回一个不可变的ImmutableMap实例。

immutableEntry(@Nullable K key, @Nullable V value)：通过给定的key/value，返回一个不可变的map映射。

asConverter(final BiMap<A, B> bimap)：返回一个Converter转换器，通过bimap.get()方法转换值，它的逆视图使用bimap.inverse().get()方法转换值。

synchronizedBiMap(BiMap<K, V> bimap)：返回一个同步的（线程安全）的bimap，由给定的bimap支持。

unmodifiableBiMap( BiMap<? extends K, ? extends V> bimap)：返回给定的bimap的不可修改的BiMap表示。

transformValues( Map<K, V1> fromMap, Function<? super V1, V2> function)：返回一个map映射，其键值为给定fromMap的键值，其value为给定formMap中value通过Function转换后 的值。

transformValues( SortedMap<K, V1> fromMap, Function<? super V1, V2> function)：返回一个SortedMap映射，其键值为给定fromMap的键值，其value为给定formMap中value通过 Function转换后的值。

transformValues( NavigableMap<K, V1> fromMap, Function<? super V1, V2> function)：返回一个NavigableMap映射，其键值为给定fromMap的键值，其value为给定formMap中value通过 Function转换后的值。

transformEntries( Map<K, V1> fromMap, EntryTransformer<? super K, ? super V1, V2> transformer)：返回一个map映射，其Entry为给定fromMap.Entry通过给定EntryTransformer转换后的值。

transformEntries(SortedMap<K, V1> fromMap, EntryTransformer<? super K, ? super V1, V2> transformer)：返回一个SortedMap映射，其Entry为给定fromMap.Entry通过给定EntryTransformer转 换后的值。

transformEntries( final NavigableMap<K, V1> fromMap,EntryTransformer<? super K, ? super V1, V2> transformer)：返回一个NavigableMap映射，其Entry为给定fromMap.Entry通过给定 EntryTransformer转换后的值。

filterKeys(Map<K, V> unfiltered, final Predicate<? super K> keyPredicate)：返回给定unfilteredMap中的键值通过给定keyPredicate过滤后的map映射。

filterKeys(SortedMap<K, V> unfiltered, final Predicate<? super K> keyPredicate)：返回给定unfilteredMap中的键值通过给定keyPredicate过滤后的SortedMap映射。

filterKeys(NavigableMap<K, V> unfiltered, final Predicate<? super K> keyPredicate)：返回给定unfilteredMap中的键值通过给定keyPredicate过滤后的NavigableMap映射。

filterKeys(BiMap<K, V> unfiltered, final Predicate<? super K> keyPredicate)：返回给定unfilteredMap中的键值通过给定keyPredicate过滤后的BiMap映射。

filterValues( Map<K, V> unfiltered, final Predicate<? super V> valuePredicate)：返回给定unfilteredMap中的value值通过给定keyPredicate过滤后的map映射。

filterValues(SortedMap<K, V> unfiltered, final Predicate<? super V> valuePredicate)：返回给定unfilteredMap中的value值通过给定keyPredicate过滤后的SortedMap映 射。

filterValues(NavigableMap<K, V> unfiltered, final Predicate<? super V> valuePredicate)：返回给定unfilteredMap中的value值通过给定keyPredicate过滤后的 NavigableMap映射。

filterValues(BiMap<K, V> unfiltered, final Predicate<? super V> valuePredicate)：返回给定unfilteredMap中的value值通过给定keyPredicate过滤后的BiMap映射。

filterEntries( Map<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate)：返回给定unfilteredMap.Entry中的Entry值通过给定entryPredicate过滤后的map 映射。

filterEntries( SortedMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate)：返回给定unfilteredMap.Entry中的Entry值通过给定entryPredicate过滤后的 SortedMap映射。

filterEntries( NavigableMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate)：返回给定unfilteredMap.Entry中的Entry值通过给定entryPredicate过滤后的 NavigableMap映射。

filterEntries( BiMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate)：返回给定unfilteredMap.Entry中的Entry值通过给定entryPredicate过滤后的 BiMap映射。

unmodifiableNavigableMap(NavigableMap<K, V> map)：返回给定map的不可修改NavigableMap表示。

synchronizedNavigableMap( NavigableMap<K, V> navigableMap)：返回一个同步的（线程安全）的NavigableMap，由给定的navigableMap支持。

Maps类中提供的方法很多，对其中的一些方法也是一知半解，需要慢慢摸索，这里对其中的一些重点和特别的方法做一些示例学习，其他的方法不再赘述，示例代码如下：

/**
 * Maps：处理Map实例的实用类
 * Maps里面方法很多，一知半解，慢慢摸索
 * User: Realfighter
 * Date: 2014/9/5
 * Time: 15:11
 */
public class MapsTest {

    @Test
    public void testMaps() {
        /**
         * difference：返回两个给定map之间的差异。
         */
        Map<String, String> map1 = new HashMap<String, String>() {
            {
                put("a", "1");
            }
        };
        Map<String, String> map2 = new HashMap<String, String>() {
            {
                put("b", "2");
            }
        };
        Map<String, String> map3 = new HashMap<String, String>() {
            {
                put("a", "3");
            }
        };
        //输出：not equal: only on left={a=1}: only on right={b=2}
        System.out.println(Maps.difference(map1, map2));
        //输出：not equal: value differences={a=(1, 3)}
        System.out.println(Maps.difference(map1, map3));
        /**
         * asMap：返回一个活动的map
         * 键值为给定的set中的值
         * value为通过给定Function计算后的值。
         */
        Set<String> set = Sets.newHashSet("a", "b", "c");
        //Function：简单的对元素做大写转换，下面示例多次使用
        Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String input) {
                return input.toUpperCase();
            }
        };
        //输出：{b=B, c=C, a=A}
        System.out.println(Maps.asMap(set, function));
        /**
         * toMap：返回一个不可变的ImmutableMap实例
         * 其键值为给定keys中去除重复值后的值
         * 其值为键被计算了valueFunction后的值
         */
        List<String> keys = Lists.newArrayList("a", "b", "c", "a");
        //输出：{a=A, b=B, c=C}
        System.out.println(Maps.toMap(keys, function));
        /**
         * uniqueIndex：返回一个不可变的ImmutableMap实例，
         * 其value值为按照给定顺序的给定的values值
         * 键值为相应的值经过给定Function计算后的值
         */
        List<String> values = Lists.newArrayList("a", "b", "c", "d");
        /**
         * 注：这里的value值不可重复，重复的话在转换后会抛出异常：
         * IllegalArgumentException: Multiple entries with same key
         */
        //输出：{A=a, B=b, C=c, D=d}
        System.out.println(Maps.uniqueIndex(values, function));
        /**
         * transformValues：返回一个map映射
         * 其键值为给定fromMap的键值
         * 其value为给定formMap中value通过Function转换后的值
         */
        Map<String, Boolean> fromMap = Maps.newHashMap();
        fromMap.put("key", true);
        fromMap.put("value", false);
        //输出：{value=true, key=false}
        System.out.println(Maps.transformValues(fromMap, new Function<Boolean, Object>() {
            @Override
            public Object apply(Boolean input) {
                //对传入的元素取反
                return !input;
            }
        }));
        /**
         * transformEntries：返回一个map映射
         * 其Entry为给定fromMap.Entry通过给定EntryTransformer转换后的值
         */
        Maps.EntryTransformer<String, Boolean, String> entryTransformer = new Maps.EntryTransformer<String, Boolean, String>() {
            public String transformEntry(String key, Boolean value) {
                //value为假，则key变大写
                return value ? key : key.toUpperCase();
            }
        };
        //输出：{value=VALUE, key=key}
        System.out.println(Maps.transformEntries(fromMap, entryTransformer));
        /**
         * filterKeys：返回给定unfilteredMap中的键值通过给定keyPredicate过滤后的map映射
         */
        //输出：{key=true}
        System.out.println(Maps.filterKeys(fromMap, new Predicate<String>() {
            @Override
            public boolean apply(String input) {
                //过滤Map中键值包含字母y的元素
                return input.contains("y");
            }
        }));
        /**
         * filterValues：返回给定unfilteredMap中的value值通过给定keyPredicate过滤后的map映射
         */
        //输出：{value=false}
        System.out.println(Maps.filterValues(fromMap, new Predicate<Boolean>() {
            @Override
            public boolean apply(Boolean input) {
                //过滤Map中value值为假的元素
                return !input;
            }
        }));
        /**
         * filterEntries：返回给定unfilteredMap.Entry中的Entry值通过给定entryPredicate过滤后的map映射
         */
        //输出：{key=true}
        System.out.println(Maps.filterEntries(fromMap, new Predicate<Map.Entry<String, Boolean>>() {
            @Override
            public boolean apply(Map.Entry<String, Boolean> input) {
                //过滤Map.Entry中getValue()为真的元素
                return input.getValue();
            }
        }));
    }

}

Multimaps：
想 Map<String, List<StudentScore>> StudentScoreMap = new HashMap<String, List<StudentScore>>()这样的数据结构，自己实现起来太麻烦，你需要检查key是否存在，
不存在时则创建一个，存在时在List后面添加上一个。这个过程是比较痛苦的，如果你希望检查List中的对象是否存在，删除一个对象，或者遍历整个数据结构，那么则需要更多的代码来实现。

import java.util.Collection;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimap;

public class MutliMapTest {
    public static void main(String... args) {
        Multimap<String, String> myMultimap = ArrayListMultimap.create();

        // Adding some key/value
        myMultimap.put("Fruits", "Bannana");
        myMultimap.put("Fruits", "Apple");
        myMultimap.put("Fruits", "Pear");
        myMultimap.put("Fruits", "Pear");
        myMultimap.put("Vegetables", "Carrot");

        // Getting the size
        int size = myMultimap.size();
        System.out.println(size); // 5

        // Getting values
        Collection<String> fruits = myMultimap.get("Fruits");
        System.out.println(fruits); //  [Bannana, Apple, Pear, Pear]
        System.out.println(ImmutableSet.copyOf(fruits));// [Bannana, Apple, Pear]
        // Set<Foo> set = Sets.newHashSet(list);
        // Set<Foo> foo = new HashSet<Foo>(myList);

        Collection<String> vegetables = myMultimap.get("Vegetables");
        System.out.println(vegetables); // [Carrot]

        // Iterating over entire Mutlimap
        for (String value : myMultimap.values()) {
            System.out.println(value);
        }

        // Removing a single value
        myMultimap.remove("Fruits", "Pear");
        System.out.println(myMultimap.get("Fruits")); // [Bannana, Apple, Pear]

        // Remove all values for a key
        myMultimap.removeAll("Fruits");
        System.out.println(myMultimap.get("Fruits")); // [] (Empty Collection!)
    }
}

如果你需要基于multimap直接操作list或者set，那么可以使用在定义类型的时候使用子类名称：ListMultimap，SetMultimap和SortedSetMultimap。例如：

ListMutlimap<String,String> myMutlimap = ArrayListMultimap.create();

List<string> myValues = myMutlimap.get("myKey");  // Returns a List, not a Collection.

BiMap:
BiMap提供了一种新的集合类型，它提供了key和value的双向关联的数据结构。
通常情况下，我们在使用Java的Map时，往往是通过key来查找value的，但是如果出现下面一种场景的情况，我们就需要额外编写一些代码了：value查key。

　　　　 BiMap<Integer,String> logfileMap = HashBiMap.create();
        logfileMap.put(1,"a.log");
        logfileMap.put(2,"b.log");
        logfileMap.put(3,"c.log");
        System.out.println("logfileMap:"+logfileMap);
        BiMap<String,Integer> filelogMap = logfileMap.inverse();
        System.out.println("filelogMap:"+filelogMap);

在使用BiMap时，会要求Value的唯一性。如果value重复了则会抛出错误：java.lang.IllegalArgumentException。
如果我们确实需要插入重复的value值，那可以选择forcePut方法。但是我们需要注意的是前面的key也会被覆盖了。
inverse方法会返回一个反转的BiMap，但是注意这个反转的map不是新的map对象，它实现了一种视图关联，这样你对于反转后的map的所有操作都会影响原先的map对象。

Multiset：
Multiset是什么？顾名思义，Multiset和Set的区别就是可以保存多个相同的对象。在JDK中，List和Set有一个基本的区别，就是List可以包含多个相同对象，且是有顺序的，而Set不能有重复，且不保证顺序（有些实现有顺序，例如LinkedHashSet和SortedSet等）所以Multiset占据了List和Set之间的一个灰色地带：允许重复，但是不保证顺序。 
常见使用场景：Multiset有一个有用的功能，就是跟踪每种对象的数量，所以你可以用来进行数字统计。实现方式如下：

String strWorld="wer|dfd|dd|dfd|dda|de|dr";
        String[] words=strWorld.split("\\|");
        List<String> wordList=new ArrayList<String>();
        for (String word : words) {
            wordList.add(word);
        }
        Multiset<String> wordsMultiset = HashMultiset.create();
        wordsMultiset.addAll(wordList);
 
        for(String key:wordsMultiset.elementSet()){
            System.out.println(key+" count："+wordsMultiset.count(key));
        }

上面的代码实现的功能非常简单，用于记录字符串在数组中出现的次数。这种场景在实际的开发过程还是容易经常出现的。

Multiset主要方法

　　Multiset接口定义的接口主要有：
　　　　add(E element) :向其中添加单个元素
　　　　add(E element,int occurrences) : 向其中添加指定个数的元素
　　　　count(Object element) : 返回给定参数元素的个数
　　　　remove(E element) : 移除一个元素，其count值 会响应减少
　　　　remove(E element,int occurrences): 移除相应个数的元素
　　　　elementSet() : 将不同的元素放入一个Set中
　　　　entrySet(): 类似与Map.entrySet 返回Set<Multiset.Entry>。包含的Entry支持使用getElement()和getCount()
　　　　setCount(E element ,int count): 设定某一个元素的重复次数
　　　　setCount(E element,int oldCount,int newCount): 将符合原有重复个数的元素修改为新的重复次数
　　　　retainAll(Collection c) : 保留出现在给定集合参数的所有的元素 
　　　　removeAll(Collectionc) : 去除出现给给定集合参数的所有的元素

public void testMultsetWordCount(){
        String strWorld="wer|dfd|dd|dfd|dda|de|dr";
        String[] words=strWorld.split("\\|");
        List<String> wordList=new ArrayList<String>();
        for (String word : words) {
            wordList.add(word);
        }
        Multiset<String> wordsMultiset = HashMultiset.create();
        wordsMultiset.addAll(wordList);

        //System.out.println("wordsMultiset："+wordsMultiset);

        for(String key:wordsMultiset.elementSet()){
            System.out.println(key+" count："+wordsMultiset.count(key));
        }

        if(!wordsMultiset.contains("peida")){
            wordsMultiset.add("peida", 2);
        }
        System.out.println("============================================");
        for(String key:wordsMultiset.elementSet()){
            System.out.println(key+" count："+wordsMultiset.count(key));
        }

        if(wordsMultiset.contains("peida")){
            wordsMultiset.setCount("peida", 23);
        }

        System.out.println("============================================");
        for(String key:wordsMultiset.elementSet()){
            System.out.println(key+" count："+wordsMultiset.count(key));
        }

        if(wordsMultiset.contains("peida")){
            wordsMultiset.setCount("peida", 23,45);
        }

        System.out.println("============================================");
        for(String key:wordsMultiset.elementSet()){
            System.out.println(key+" count："+wordsMultiset.count(key));
        }

        if(wordsMultiset.contains("peida")){
            wordsMultiset.setCount("peida", 44,67);
        }

        System.out.println("============================================");
        for(String key:wordsMultiset.elementSet()){
            System.out.println(key+" count："+wordsMultiset.count(key));
        }
    }

输出：

de count：1
dda count：1
dd count：1
dfd count：2
wer count：1
dr count：1
============================================
de count：1
dda count：1
dd count：1
dfd count：2
peida count：2
wer count：1
dr count：1
============================================
de count：1
dda count：1
dd count：1
dfd count：2
peida count：23
wer count：1
dr count：1
============================================
de count：1
dda count：1
dd count：1
dfd count：2
peida count：45
wer count：1
dr count：1
============================================
de count：1
dda count：1
dd count：1
dfd count：2
peida count：45
wer count：1
dr count：1

说明：setCount(E element,int oldCount,int newCount): 方法，如果传入的oldCount和element的不一致的时候，是不能讲element的count设置成newCount的。需要注意。

Multiset不是Map

　　需要注意的是Multiset不是一个Map<E,Integer>,尽管Multiset提供一部分类似的功能实现。其它值得关注的差别有:
　　Multiset中的元素的重复个数只会是正数，且最大不会超过Integer.MAX_VALUE。设定计数为0的元素将不会出现multiset中，也不会出现elementSet()和entrySet()的返回结果中。
　　multiset.size() 方法返回的是所有的元素的总和，相当于是将所有重复的个数相加。如果需要知道每个元素的个数可以使用elementSet().size()得到.(因而调用add(E)方法会是multiset.size()增加1).
　　multiset.iterator() 会循环迭代每一个出现的元素，迭代的次数与multiset.size()相同。 iterates over each occurrence of each element, so the length of the iteration is equal to multiset.size().
　　Multiset 支持添加、移除多个元素以及重新设定元素的个数。执行setCount(element,0)相当于移除multiset中所有的相同元素。
　　调用multiset.count(elem)方法时，如果该元素不在该集中，那么返回的结果只会是0。