guava集合增强

不可变集合的意义

不可便集合具有以下优点：

1. 当对象被不可信源调用的时候，不可变形式是安全的
2. 当多线程访问不可变集合时，不存在竞态条件
3. 不可变集合不需要考虑变化，因此可以节省时间和空间，比他们的可变形式具有更好的利用率
4. 可以作为常量来使用

不可变集合的使用

创建不可变集合

• 使用builder创建

Set<String> immutable = ImmutableSet.<String>builder()
                .add("i", "a", "m", "a", "b", "o", "y").build();

        for (String word : immutable) {
            System.out.println(word);
        }

• 使用of 静态方法

ImmutableSet<String> stringImmutableSet = ImmutableSet.of("i", "a", "m", "a", "b", "o", "y");

• 使用copy Of静态方法

ImmutableSet<String> strings = ImmutableSet.copyOf(new String[]{"i", "a", "m", "a", "b", "o", "y"});

使用asList()获得不可变集合的list视图

asList是在ImmutableCollection中定义，所有的不可变集合都是集成自ImmutableCollection，所以不可变集合都有　asList()这个方法，返回不可变集合的视图，该视图也是不可变的

使用方法

和普通集合一样使用，只是不能对他们add,remove等修改集合的操作

---

不可变集合之－－MultiSet

multiset看似是一个Set，但是实质上它不是一个Set，它没有继承Set接口，它继承的是Collection接口，你可以向Multiset中添加重复的元素，Multiset会对添加的元素做一个计数

使用方法

Multiset<String> multiset = HashMultiset.create();
        String sentens = "this is a history,there is a good girl in the history";
        Iterable<String> words = Splitter.onPattern("[^a-z]{1,}").omitEmptyStrings().trimResults().split(sentens);

        for (String word : words) {
            multiset.add(word);
        }
        for (String word : words) {
            System.out.println("word:" + word + ",count:" + multiset.count(word));
        }

结果

word:this,count:1
word:is,count:2
word:a,count:2
word:history,count:2
word:there,count:1
word:is,count:2
word:a,count:2
word:good,count:1
word:girl,count:1
word:in,count:1
word:the,count:1
word:history,count:2

常用实现

HashMultiset: 元素存放于 HashMap
LinkedHashMultiset: 元素存放于 LinkedHashMap，即元素的排列顺序由第一次放入的顺序决定
TreeMultiset:元素被排序存放于TreeMap
EnumMultiset: 元素必须是 enum 类型
ImmutableMultiset: 不可修改的 Mutiset

不可变集合之－－双向Map BiMap

BiMap也是一种Map,他的特别之处在于，既有键到值的映射　也有值到键的映射，所以是双向Map

使用方法

weekMap.get(key)
weekMap.inverse().get(value)

BIMap的值键对的Map可以通过inverse()方法得到

---

Multimaps：一键多值的Map

有时候我们会遇到这样的场景：Map<String,Collection<String>> guava中Multimaps就是为了解决这类问题

MultiMaps实现
在程序里用它来替代程序里的Map<K, Collection<V>>

实现	key 实现	value 实现
ArrayListMultiMap	HasMap	ArrayList
HashMultiMap	HasMap	HashSet
LinkedListMultiMap	LinkedHashMap	LinkedList
LinkedHashMultiMap	LinkedHashMap	LinkedHashSet
TreeMultiMap	TreeMap	TreeSet
ImmutableListMultiMap	ImmutableMap	ImmutableList
ImmutableSetMultiMap	ImmutableMap	ImmutableSet

---

使用

ArrayListMultimap<String, String> multiMap = ArrayListMultimap.create();
        multiMap.put("room", "students1");
        multiMap.put("school", "techer");

        multiMap.put("room", "students2");
        multiMap.put("room", "students3");
        multiMap.put("room", "students4");
        multiMap.put("room", "students5");

        int size = multiMap.size();
        System.out.println(size);
        List<String> room = multiMap.get("room");
        System.out.println(room);
        List<String> school = multiMap.get("school");
        System.out.println(school);


        //遍历multimap
        for (String value : multiMap.values()) {
            System.out.print(value+",");
        }
        System.out.println();

        multiMap.remove("room", "student");

        System.out.println(multiMap.get("room"));
        // remove all value of a key

        multiMap.removeAll("room");

        System.out.println(multiMap.get("room"));

使用Iterator简化Iterator操作

判断迭代器中的元素是否都满足某个条件（all)

List<String> list = Lists.newArrayList("sed", "book", "bear", "apple");
        Predicate<String> condition = new Predicate<String>() {
            @Override
            public boolean apply(String input) {
               return input.startsWith("b");
            }
        };
 boolean flag = Iterators.all(list.iterator(), condition);
 System.out.println("flag:" + flag);

all方法的第一个参数是Iterator，第二个参数是Predicate的实现，这个方法的意义是不需要我们自己去写while循环了，他的内部实现中帮我们做了循环，把循环体中的条件判断抽象出来了。

2.any()方法判断迭代器中是否有一个满足，使用方法和all()一样

3.获得迭代器中的第ｘ个元素

String nextElement = Iterators.get(list.iterator(), 1);

4.filter方法过滤

Iterator<String> filteredList = Iterators.filter(list.iterator(), new Predicate<String>() {
            @Override
            public boolean apply(String input) {
               return input.startsWith("b");
            }
        });

find方法返回符合条件的第一个元素

String ele = Iterators.find(list.iterator(), new Predicate<String>() {
            @Override
            public boolean apply(String input) {
                return input.length() == 3;
            }
        });

transform方法，对迭代器元素做转换

Iterator<Integer> transform = Iterators.transform(list.iterator(), new Function<String, Integer>() {
            @Nullable
            @Override
            public Integer apply(String input) {
                return input.length();
            }
        });

java 8 中　也有Predicate　，和Function了