guava（一）Preconditions

工具类 就是封装平常用的方法，不需要你重复造轮子，节省开发人员时间，提高工作效率。谷歌作为大公司，当然会从日常的工作中提取中很多高效率的方法出来。所以就诞生了guava。。

• 高效设计良好的API，被Google的开发者设计，实现和使用
• 遵循高效的java语法实践
• 使代码更刻度，简洁，简单
• 节约时间，资源，提高生产力

Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库，例如：

1. 集合 [collections]
2. 缓存 [caching]
3. 原生类型支持 [primitives support]
4. 并发库 [concurrency libraries]
5. 通用注解 [common annotations]
6. 字符串处理 [string processing]
7. I/O 等等

使用

maven

    <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>18.0</version>
        </dependency>

一、集合

1、集合的创建与转换

普通集合的创建

 List<String> list=Lists.newArrayList();
 Set<String> set= Sets.newHashSet();
 Map<String,String> map= Maps.newHashMap();

不变集合的创建

 ImmutableList<String> ilist=ImmutableList.of("a","b");
 ImmutableMap<String,String> imap=ImmutableMap.of("key1","v1","key2","v2");
 ImmutableSet<String> iset=ImmutableSet.of("a","b");

当我们需要一个map中包含key为String value为List类型的时候

 Multimap<String,Integer> multimap=ArrayListMultimap.create();
 multimap.put("aa",1);
 multimap.put("aa",2);
 System.out.println(multimap.get("aa"));

将list转一定规则字符串

 ImmutableList<String> ilist=ImmutableList.of("a","b");
 System.out.println(Joiner.on(":").join(ilist));

将map转一定规则字符串

  Map<String,String> map= Maps.newHashMap();
  map.put("lanlan","11");
  map.put("honghong","22");
  System.out.println(Joiner.on(",").withKeyValueSeparator("==").join(map));

将string转list

  String str="1-2-3-4-";
  List<String> list1=Splitter.on("-").splitToList(str);
  System.out.println(list1);
  System.out.println(list1.size());

  List<String> list2=Splitter.on("-").omitEmptyStrings().trimResults().splitToList(str);//去除空串与空格
  System.out.println(list2);
  System.out.println(list2.size());

将string转map

 String input="xiaolan=11,honghong=22";
 Map<String,String> map1=Splitter.on(",").withKeyValueSeparator("=").split(input);
 System.out.println(map1);

2、集合的过滤

按照条件过滤

 ImmutableList<String> ilist=ImmutableList.of("java","guava","c#","c++");
        Iterable<String> fi=Iterables.filter(ilist,Predicates.or(Predicates.equalTo("java"),Predicates.equalTo("c++")));
        System.out.println(fi);

自定义过滤条件

 ImmutableMap<String,Integer> imap2=ImmutableMap.of("lanlan",11,"honghong",22);
        Map<String,Integer> m= Maps.transformValues(imap2, new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) {
                if (integer>15){
                    return integer-5;
                }else {
                    return integer;
                }
            }
        });
        System.out.println(m);

二、参数校验 Preconditions

1 .checkArgument(boolean) ：
　　功能描述：检查boolean是否为真。 用作方法中检查参数
　　失败时抛出的异常类型: IllegalArgumentException

2.checkNotNull(T)：     
　　功能描述：检查value不为null， 直接返回value；
　　失败时抛出的异常类型：NullPointerException

3.checkState(boolean)：
　　功能描述：检查对象的一些状态，不依赖方法参数。
　　失败时抛出的异常类型：IllegalStateException

4.checkElementIndex(int index, int size)：
　　功能描述：检查index是否为在一个长度为size的list， string或array合法的范围。 index的范围区间是[0, size)。
　　失败时抛出的异常类型：IndexOutOfBoundsException

5.checkPositionIndex(int index, int size)：
　　功能描述：检查位置index是否为在合法的范围。 index的范围区间是[0， size]。
　　失败时抛出的异常类型：IndexOutOfBoundsException

6.checkPositionIndexes(int start, int end, int size)：
　　功能描述：检查[start, end)是一个长度为size的list， string或array合法的范围子集。0<=start<=end<=size。
　　失败时抛出的异常类型：IndexOutOfBoundsException

举个例子

 int count=20;
//use java
        if (count<20){
            throw new IllegalArgumentException("must be positive : "+count);
        }
//use guava
        Preconditions.checkArgument(count>0,"must be positive:%s",count);

三、NULL 判断 Optional

以更优雅的方式判断非空

        String s=null;
        Optional<String> opt=Optional.ofNullable(s);
        Optional<String> opt1=Optional.of(s);

        if (opt.isPresent()){
            System.out.println(opt.get());
        }

四、集合工具类

Iterables

1、boolean removeAll(Iterable removeFrom,Collection elementsToRemove) 从第一个集合中 移除第二个集合的所有项

2、boolean retainAll(Iterable removeFrom,Collection elementsToRetain) 从第一个集合中 移除 除第二个集合外的所有项

3、boolean removeIf(Iterable removeFrom,Predicate predicate) 从第一个集合中，移除符合条件的项

 Iterables.removeIf(list, new Predicate<String>() {
            // 移除集合中使得apply()方法返回为true的元素
            @Override
            public boolean apply(String input) {
                return input.length() == 5;
            }
        });

4 filter 保留条件中的项

Iterable<String> ite=Iterables.filter(list,Predicates.containsPattern("a"));

5、concat 拼接多个集合

Iterable<Integer> it=Iterables.concat(Ints.asList(1,2,3),Ints.asList(4,5),Ints.asList(6));

6、frequency 查询集合中object出现的次数

Iterables.frequency(list,"aa")

7、partition 按大小分割集合

 Iterable<List<String>>  ii=Iterables.partition(list,2);
        Iterator iterator=ii.iterator();
        while (iterator.hasNext()){
            List<String> li= (List<String>) iterator.next();
            System.out.println(li);
        }

8 getFirst(Iterable, T default) 返回iterable的第一个元素，若iterable为空则返回默认值

Iterables.getFirst(list,null));

9 getLast(Iterable) 返回iterable的最后一个元素，若iterable为空则抛出NoSuchElementException

10 elementsEqual(Iterable, Iterable) 如果两个iterable中的所有元素相等且顺序一致，返回true

11 unmodifiableIterable(Iterable) 返回iterable的不可变视图

12 limit(Iterable, int) 返回 iterable的前limit个元素集合

13 getOnlyElement(Iterable) 获取iterable中唯一的元素，如果iterable为空或有多个元素，则快速失败

14 boolean any(Iterable<T> iterable, Predicate<? super T> predicate) 是否有满足条件的元素

Iterables.any(list,Predicates.containsPattern("yy")));

15 Iterable<T> cycle(final Iterable<T> iterable) 无限循环集合

 Iterable<String> ite=Iterables.cycle(list);
        Iterator iterator=ite.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

16 int indexOf(Iterable<T> iterable, Predicate<? super T> predicate) 满足条件的元素第一次出现的index

int index=Iterables.indexOf(list,Predicates.containsPattern("cc"));

Collections2
1 Collection<E> filter(Collection<E> unfiltered, Predicate<? super E> predicate) 保留符合条件的元素

 Collection<String> li=Collections2.filter(list,Predicates.containsPattern("a"));
        for (String str:li){
            System.out.println(str);
        }

2 Collection<List<E>> permutations(Collection<E> elements) 求集合的排列组合

  Collection<List<String>> collection = Collections2.permutations(list);
        Iterator iterator1 = collection.iterator();
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
        }

3 Collection<List<E>> orderedPermutations(Iterable<E> elements, Comparator<? super E> comparator) 先排序，再排列组合

 Collection<List<String>> collection1 = Collections2.orderedPermutations(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        Iterator iterator = collection1.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

4 <E extends Comparable<? super E>> Collection<List<E>> orderedPermutations(Iterable<E> elements) 按默认顺序排序，并排列组合

  Collection<List<String>> collection1 = Collections2.orderedPermutations(list);
        Iterator iterator = collection1.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

5、Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) 按条件改变集合元素的值

 Collection<Integer> collection = Collections2.transform(list, new Function<String,Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });
        for (Integer in:collection){
            System.out.println(in);
        }

Lists

1 newlist 创建各种集合

2 partition 分割集合

List<List<String>> partitions= Lists.partition(list,2);

3 asList  将数组转成集合，并增加头元素

  String[] s = {"11"};
  List<String> list = Lists.asList("aa", s);

4 Lists.cartesianProduct 笛卡尔积

List<List<String>> lisss = Lists.cartesianProduct(list, list1);

4 charactersOf 将字符串转不可变集合

ImmutableList<Character> immutableList=Lists.charactersOf("123456大众点评");

sets

1 newxxset 创建各种set

2 cartesianProduct 笛卡尔积

3 filter 保留选中元素

4 complementOf 给定集合的补集,枚举

EnumSet<Test> es= Sets.complementOf(collection);

enum Test {
    aa, bb, cc;
}

5 difference 移除与set1相同的元素

Set<String> result=Sets.difference(set,set1);

6 intersection 交集

Set<String> result=Sets.intersection(set,set1);

7 powerSet 球组合

Set<Set<String>> result=Sets.powerSet(set1);

8 <K extends Comparable<? super K>> NavigableSet<K> subSet(NavigableSet<K> set, Range<K> range) 按range分割set

        Set<String> set = Sets.newHashSet("2","1","333");
        NavigableSet<String> see=Sets.newTreeSet(set);
        NavigableSet<String> lala = Sets.subSet(see, Range.all());

9 symmetricDifference 球两个集合的不同元素的集合

Set<String> re=Sets.symmetricDifference(set,set1);

10 union 连接集合，并排序

Set<String> re=Sets.union(set,set1);

maps

1 new xxxmap 创建各种map

2 difference 比较两个map的不同点

MapDifference<String,String> diff= Maps.difference(map,map1);
System.out.println(diff.entriesDiffering()); //返回两个map key相同 value不同的
System.out.println(diff.entriesInCommon()); //相同的元素
System.out.println(diff.entriesOnlyOnLeft()); //只有左边集合有的key
System.out.println(diff.entriesOnlyOnRight()); //只有右边集合有的key

3 transformValues 改变value的值

 Map<String, Object> result = Maps.transformValues(map, new Function<String, Object>() {
            @Override
            public Object apply(String input) {
                if (input.equals("1")) {
                    return "55555";
                }
                return input;
            }
        });

4 asMap 将set转map

  Map<String, String>  result=Maps.asMap(set, new Function<String, String>() {
            @Override
            public String apply(String input) {
                if (input.equals("2")){
                    return "22222";
                }
                return input;
            }
        });

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

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

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

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

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

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

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

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

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

14 immutableEnumMap( Map<K, ? extends V> map) 转不可变集合

五 函数式编程

一个问题：为什么functions和predicates要重写equal

Functions
1 Function<Object, String> toStringFunction() 转string

Map<String, String> result = Maps.transformValues(ImmutableMap.of("a", 1, "b", 2), Functions.toStringFunction());

2  Function<T, Boolean> forPredicate(Predicate<T> predicate)  转Function<T, Boolean>

 Map<String, String> map = ImmutableMap.of("a", "1", "b", "2");
 Map<String, Boolean> result = Maps.transformValues(map, Functions.forPredicate(Predicates.containsPattern("a")));

3 Function<Object, E> constant(@Nullable E value) 转常量

 Map<String, String> map = ImmutableMap.of("a", "1", "b", "2");
 Map<String, String> result = Maps.transformValues(map, Functions.constant("sss"));

4 Function<K, V> forMap(Map<K, V> map 以map的映射方式为funtion

  Map<String, String> map = ImmutableMap.of("a", "1", "b", "2");
  Map<String, Integer> result = Maps.transformValues(map, Functions.forMap(ImmutableMap.of("1",1,"2",222)));

5 compose(Function<B, C> g, Function<A, ? extends B> f) 组合两个function，计算顺序是从后到前

  Map<String, Integer> map = ImmutableMap.of("a", 1, "b", 2);
  Map<String, String> result = Maps.transformValues(map, Functions.compose(Functions.constant("la"),Functions.toStringFunction()));

Predicates

1 Predicate<T> equalTo(@Nullable T target) 比较相等

Map<String, Integer> result = Maps.filterKeys(ImmutableMap.of("a", 1, "b", 2),Predicates.equalTo("a"));

2 Predicate<CharSequence> containsPattern(String pattern) 是否包含

 Map<String, Integer> map = ImmutableMap.of("a", 1, "b", 2);
 Map<String, Integer> result = Maps.filterKeys(map,Predicates.containsPattern("a"));

3 Predicate<CharSequence> contains(Pattern pattern) 是否匹配正则

Map<String, Integer> result = Maps.filterKeys(ImmutableMap.of("a", 1, "b", 2),Predicates.contains(Pattern.compile("a")));

4 Predicate<T> or(Predicate<? super T> first, Predicate<? super T> second) |

Map<String, Integer> result = Maps.filterKeys(ImmutableMap.of("a", 1, "b", 2),Predicates.or(Predicates.equalTo("aa"),Predicates.containsPattern("a")));

5 Predicate<T> and(Predicate<? super T> first, Predicate<? super T> second) &

Map<String, Integer> result = Maps.filterKeys(ImmutableMap.of("a", 1, "b", 2),Predicates.and(Predicates.equalTo("aa"),Predicates.containsPattern("a")));

6 Predicate<T> in(Collection<? extends T> target) in

Map<String, Integer> result = Maps.filterKeys(ImmutableMap.of("aa", 1, "ab", 2),Predicates.in(ImmutableList.of("aa")));

7 Predicate<Object> instanceOf(Class<?> clazz) 是否继承自某种类型

Map<String, Integer> result = Maps.filterKeys(ImmutableMap.of("aa", 1, "ab", 2),Predicates.instanceOf(String.class));

8 Predicate<T> not(Predicate<T> predicate) 取反

Map<String, Integer> result = Maps.filterKeys(ImmutableMap.of("aa", 1, "ab", 2),Predicates.not(Predicates.containsPattern("aa")));

9 Predicate<T> notNull()

10 Predicate<T> isNull()

11 Predicate<T> alwaysFalse()

12 Predicate<T> alwaysTrue()

FluentIterable
举个例子

 FluentIterable<String> fluentIterable = FluentIterable.from(ImmutableList.of("233")).filter(Predicates.containsPattern("2"))
                .filter(Predicates.containsPattern("3"));

六 比较器

Ordering

Ordering中有4种静态方法用于创建Ordering排序器

1 Ordering<Object> arbitrary() 任意顺序比较器

List<String> result= Ordering.arbitrary().sortedCopy(ImmutableList.of("33","11","22"));

2 <C extends Comparable> Ordering<C> natural() 自然顺序

List<String> result= Ordering.natural().sortedCopy(ImmutableList.of("33","11","22"));

3  Ordering<Object> usingToString() 以转成string后比较

List<Integer> result= Ordering.usingToString().sortedCopy(Ints.asList(2,3));

4 Ordering<T> from(Comparator<T> comparator) Comparator转Ordering

List<Integer> result = Ordering.from(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        }).sortedCopy(Ints.asList(3, 2));

根据上面的方法创建Ordering后，可以继续调用如下方法创建组合功能的排序器：

1 Ordering<S> reverse() 获取语义相反的排序器

Ordering or = Ordering.natural().reverse();

2 Ordering<S> nullsFirst() 将null元素放在前面

Ordering or = Ordering.natural().nullsFirst();

3 Ordering<S> nullsLast() 将null元素放在后面

Ordering or = Ordering.natural().nullsLast();

4 Ordering<U> compound(Comparator<? super U> secondaryComparator) 合成另一个比较器，以处理排序中相等的元素

 Ordering or = Ordering.natural().compound(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return 0;
            }
        });

5 onResultOf(Function<F, ? extends T> function) 先调用function，再按排序器排序

 Ordering or = Ordering.natural().onResultOf(new Function<String, String>() {
            @Override
            public String apply(String input) {
                return null;
            }
        });

创建完Ordering排序器后，即可使用它对集合或元素进行操作

1 List<E> greatestOf(Iterable<E> iterable, int k) 最大的k个元素

List<String> lis=Ordering.natural().greatestOf(ImmutableList.of("a","b","c","d"),2);

2 boolean isOrdered(Iterable<? extends T> iterable) 是否已按迭代器排序,允许有相等元素

boolean ordered=Ordering.natural().isOrdered(ImmutableList.of("a","b","c","d"));

3 boolean isStrictlyOrdered(Iterable<? extends T> iterable) 是否严格排序，不允许有相等元素

boolean ordered=Ordering.natural().isStrictlyOrdered(ImmutableList.of("a","b","b","d"));

4 List<E> sortedCopy(Iterable<E> elements) 排序

List<String> li =Ordering.natural().sortedCopy(ImmutableList.of("e","b","c","d"));

5 E max(@Nullable E a, @Nullable E b)

String li =Ordering.natural().max("a","b");

5 E min(@Nullable E a, @Nullable E b)

String li =Ordering.natural().min("a","b");