Guava for Android 概述

2017-07-11 本文已影响1024人我叫陆大旭

Guava

Hi~我是Guava

简介

Guava （潘石榴）是一个 Google 的基于java的类库集合的扩展项目，集合、缓存、原始类型、并发库、注解、字符串处理、I / O 等等。

文档地址

https://github.com/google/guava/wiki

项目地址

https://github.com/google/guava

源代码说明

com.google.common.annotations：
普通注解类型。
com.google.common.base
基本工具类库和接口，让使用Java语言更令人愉快。
com.google.common.cache
缓存工具包，非常简单易用且功能强大的JVM内缓存。
com.google.common.collect
带泛型的集合接口扩展和实现，以及工具类和排序。
com.google.common.escape
转义工具。
com.google.common.eventbus
发布订阅风格的事件总线。
com.google.common.graph
处理基于图的数据结构数据。
com.google.common.hash
哈希工具包。比Object.hashCode()提供的hash更复杂的工具，包括了Bloom过滤器，hash函数： FarmHash 、Fingerprint64 、HMAC 算法。
com.google.common.html
Html字符串转义。
com.google.common.io
I/O工具包。简化IO操作，尤其是Java 5 and 6的整个IO流和文件。
com.google.common.math
原始算术类型和超大数的运算工具包。包括没有被JDK提供的各种运算。
com.google.common.net
网络工具包。
com.google.common.primitives
八种原始类型和无符号类型的静态工具包。
com.google.common.reflect
反射工具包。
com.google.common.util.concurrent
多线程工具包。
com.google.common.xml
xml字符串转义
com.google.thirdparty.publicsuffix

基础工具

1.Optional

创建Optional实例

方法	作用
Optional.of(T)	创建指定引用的Optional实例，若引用为null则快速失败
Optional.absent()	创建引用缺失的Optional实例
Optional.fromNullable(T)	创建指定引用的Optional实例，若引用为null则表示缺失

使用Optional实例

方法	作用
boolean isPresent()	如果Optional包含非null的引用（引用存在），返回true
T get	返回Optional所包含的引用，若引用缺失，则抛出java.lang.IllegalStateException
T or(T)	返回Optional所包含的引用，若引用缺失，返回指定的值
T orNull()	返回Optional所包含的引用，若引用缺失，返回null
Set<T> asSet()	返回Optional所包含引用的单例不可变集，如果引用存在，返回一个只有单一元素的集合，如果引用缺失，返回一个空集合。

2.Preconditions

方法声明（不包括额外参数）	描述	检查失败时抛出的异常
checkArgument(boolean)	检查boolean是否为true，用来检查传递给方法的参数。	IllegalArgumentException
checkNotNull(T)	检查value是否为null，该方法直接返回value，因此可以内嵌使用checkNotNull。	NullPointerException
checkState(boolean)	用来检查对象的某些状态。	IllegalStateException
checkElementIndex(int index, int size)	检查index作为索引值对某个列表、字符串或数组是否有效。index>=0 && index<size *	IndexOutOfBoundsException
checkPositionIndex(int index, int size)	检查index作为位置值对某个列表、字符串或数组是否有效。index>=0 && index<=size *	IndexOutOfBoundsException
checkPositionIndexes(int start, int end, int size)	检查[start, end]表示的位置范围对某个列表、字符串或数组是否有效*	IndexOutOfBoundsException

3.Ordering

创建排序器

方法	描述
natural()	对可排序类型做自然排序，如数字按大小，日期按先后排序
usingToString()	按对象的字符串形式做字典排序[lexicographical ordering]
from(Comparator)	把给定的Comparator转化为排序器

链式调用方法：通过链式调用，可以由给定的排序器衍生出其它排序器

方法	描述
reverse()	获取语义相反的排序器。
nullsFirst()	使用当前排序器，但额外把null值排到最前面。
nullsLast()	使用当前排序器，但额外把null值排到最后面。
compound(Comparator)	合成另一个比较器，以处理当前排序器中的相等情况。
lexicographical()	基于处理类型T的排序器，返回该类型的可迭代对象Iterable<T>的排序器。
onResultOf(Function)	对集合中元素调用Function，再按返回值用当前排序器排序。

运用排序器：Guava的排序器实现有若干操纵集合或元素值的方法

|方法|描述|另请参见|
|---|---|
|greatestOf(Iterable iterable, int k) |获取可迭代对象中最大的k个元素。 |leastOf|
|isOrdered(Iterable)| 判断可迭代对象是否已按排序器排序：允许有排序值相等的元素。| isStrictlyOrdered|
|sortedCopy(Iterable) |判断可迭代对象是否已严格按排序器排序：不允许排序值相等的元素。| immutableSortedCopy|
|min(E, E)| 返回两个参数中最小的那个。如果相等，则返回第一个参数。 |max(E, E)|
|min(E, E, E, E...) |返回多个参数中最小的那个。如果有超过一个参数都最小，则返回第一个最小的参数。| max(E, E, E, E...)|
|min(Iterable) |返回迭代器中最小的元素。如果可迭代对象中没有元素，则抛出NoSuchElementException。| max(Iterable), min(Iterator), max(Iterator)|

集合

1.不可变集合

关联可变集合和不可变集合

|可变集合接口 |属于JDK还是Guava |不可变版本|
|---|---|
|Collection|JDK |ImmutableCollection|
|List |JDK |ImmutableList|
|Set |JDK |ImmutableSet|
|SortedSet/NavigableSet |JDK |ImmutableSortedSet|
|Map |JDK |ImmutableMap|
|SortedMap |JDK |ImmutableSortedMap|
|Multiset |Guava |ImmutableMultiset|
|SortedMultiset |Guava |ImmutableSortedMultiset|
|Multimap |Guava |ImmutableMultimap|
|ListMultimap |Guava |ImmutableListMultimap|
|SetMultimap |Guava |ImmutableSetMultimap|
|BiMap |Guava |ImmutableBiMap|
|ClassToInstanceMap |Guava |ImmutableClassToInstanceMap|
|Table |Guava |ImmutableTable|

创建方式

1.ImmutableSet.copyOf()

Set<String> sets = new HashSet<>();
sets.add("set obj1");
sets.add("set obj2");
ImmutableSet<String> immutableSet = ImmutableSet.copyOf(sets);
System.out.println(immutableSet.size());

2.ImmutableSet.of()

ImmutableSet<String> immutableSet2 = ImmutableSet.of("a", "b", "c", "a", "d", "a");
System.out.println(immutableSet2.size());

3.ImmutableSet.Builder()

ImmutableSet immutableSet1 = ImmutableSet.builder().add("ImmutableSet obj1").add("ImmutableSet obj2").build();
System.out.println(immutableSet1.size());

2.新集合类型

Multiset

相同于Set可以重复加入数据，但是不像Set有顺序

/**
 * 相同于set可以重复加入，但是不像set有顺序
  */
Multiset multiset = HashMultiset.create();
multiset.add("a");
multiset.add("b");
multiset.add("c");
multiset.add("b");
multiset.add("a");
System.out.println("multiset size:"+multiset.size());
//multiset size:5

Multimap

把一个键映射到多个值。

Multimap<String,String> multimap = HashMultimap.create();
multimap.put("key1","key1 obj1");
multimap.put("key1","key1 obj2");
multimap.put("key1","key1 obj3");

Iterator<String> stringIterator = multimap.get("key1").iterator();
System.out.println("key values:");
while (stringIterator.hasNext()){
    System.out.println(stringIterator.next());
}
/*
key values:
key1 obj3
key1 obj2
key1 obj1
 */

/**
 * 转换视图
 */
Map<String,Collection<String>> map = multimap.asMap();
Iterator<String > stringIterator1 = map.get("key1").iterator();
System.out.println("map key values:");
while (stringIterator1.hasNext()){
    System.out.println(stringIterator1.next());
}
/*
map key values:
key1 obj3
key1 obj2
key1 obj1
 */

BiMap

双向映射

BiMap<String, Integer> userIds = HashBiMap.create();
userIds.put("User1",1);
userIds.put("User2",2);
userIds.put("User3",3);
userIds.put("User4",4);
String userForId = userIds.inverse().get(2);
System.out.println(userForId);

Table

有两个支持所有类型的键：”行”和”列。

HashBasedTable hashBasedTable = HashBasedTable.create();
hashBasedTable.put("row1","column1","row1+column1:value");
hashBasedTable.put("row1","column2","row1+column2:value");
hashBasedTable.put("row2","column1","row2+column1:value");
hashBasedTable.put("row3","column2","row2+column2:value");
Map<String,String> hashBasedTableRowMap = hashBasedTable.row("row1");
Iterator<String> iterator = hashBasedTableRowMap.keySet().iterator();
while (iterator.hasNext()){
    String column = iterator.next();
    String value = hashBasedTableRowMap.get(column);
    System.out.println("column:"+column + "  value:"+ value);
}
/*
column:column1  value:row1+column1:value
column:column2  value:row1+column2:value
*/

ClassToInstanceMap

特殊的Map：它的键是类型，而值是符合键所指类型的对象。

ClassToInstanceMap<Number> numberDefaults= MutableClassToInstanceMap.create();
numberDefaults.putInstance(Integer.class, Integer.valueOf(0));

RangeSet

描述了一组不相连的、非空的区间。
关于区间的概念后面会解释。

RangeSet<Integer> rangeSet = TreeRangeSet.create();
rangeSet.add(Range.closed(1, 10)); // {[1,10]}
System.out.println(rangeSet.asRanges().toString());
rangeSet.add(Range.closedOpen(11, 15));//不相连区间:{[1,10], [11,15)}
System.out.println(rangeSet.asRanges().toString());
rangeSet.add(Range.closedOpen(15, 20)); //相连区间; {[1,10], [11,20)}
System.out.println(rangeSet.asRanges().toString());
rangeSet.add(Range.openClosed(0, 0)); //空区间; {[1,10], [11,20)}
System.out.println(rangeSet.asRanges().toString());
rangeSet.remove(Range.open(5, 10)); //分割[1, 10]; {[1,5], [10,10], [11,20)}
System.out.println(rangeSet.asRanges().toString());

/**
 * RangeSet最基本的操作，判断RangeSet中是否有任何区间包含给定元素。
 */
boolean isContains = rangeSet.contains(1);
System.out.println("isContains:"+isContains);

/**
 * 返回包含给定元素的区间；若没有这样的区间，则返回null。
 */
Range<Integer> range = rangeSet.rangeContaining(1);
System.out.println("range:"+range);

3.集合工具类

Iterables

|方法|描述|备注|
|---|---|
|concat(Iterable<Iterable>) |串联多个iterables的懒视图* |concat(Iterable...)|
|frequency(Iterable, Object) |返回对象在iterable中出现的次数 |与Collections.frequency (Collection, Object)比较；Multiset|
|partition(Iterable, int) |把iterable按指定大小分割，得到的子集都不能进行修改操作 |Lists.partition(List, int)；paddedPartition(Iterable, int)|
|getFirst(Iterable, T default) |返回iterable的第一个元素，若iterable为空则返回默认值 |与Iterable.iterator(). next()比较;FluentIterable.first()|
|getLast(Iterable) |返回iterable的最后一个元素，若iterable为空则抛出NoSuchElementException |getLast(Iterable, T default)；FluentIterable.last()|
|elementsEqual(Iterable, Iterable) |如果两个iterable中的所有元素相等且顺序一致，返回true |与List.equals(Object)比较|
|unmodifiableIterable(Iterable) |返回iterable的不可变视图 |与Collections. unmodifiableCollection(Collection)比较|
|limit(Iterable, int) |限制iterable的元素个数限制给定值 |FluentIterable.limit(int)|
|getOnlyElement(Iterable) |获取iterable中唯一的元素，如果iterable为空或有多个元素，则快速失败 |getOnlyElement(Iterable, T default)|

FluentIterable

把自己拷贝到不可变集合

转换的类型	方法
ImmutableSet	toImmutableSet()
ImmutableSortedSet	toImmutableSortedSet(Comparator)

Lists、Sets、Maps、Multisets、Multimaps、Tables

都有各自的静态类方法

缓存

基本使用

LoadingCache<String, String> stringStringLoadingCache = CacheBuilder.newBuilder().build(new CacheLoader<String, String>() {
    @Override
    public String load(String key) throws Exception {
        if(key.equals("key2")){
            System.out.println("load key2");
            return "values2";
        }
        System.out.println("load else");
        return "values0";
    }
    public Map<String, String> loadAll(Iterable<? extends String> keys) throws Exception {
        System.out.println("loadAll:"+keys.toString());
        Map<String,String> loadAll = new HashMap<String, String>();
        Iterator keysIt = keys.iterator();
        while (keysIt.hasNext()){
            String key = (String) keysIt.next();
            loadAll.put(key,key+":::values");
        }
        return loadAll;
    }


});
stringStringLoadingCache.put("key1","value1");
String values1 = stringStringLoadingCache.getUnchecked("key1");
System.out.println(values1);
String values2 = stringStringLoadingCache.getUnchecked("key2");
System.out.println(values2);
String values3 = stringStringLoadingCache.getUnchecked("key3");
System.out.println(values3);
String values11 = stringStringLoadingCache.getUnchecked("key1");
System.out.println(values11);
Set<String> keySet = Sets.newSet("key4");
try {
    ImmutableMap<String, String> immutableMap = stringStringLoadingCache.getAll(keySet);
    System.out.println(immutableMap.toString());
} catch (ExecutionException e) {
    e.printStackTrace();
}
/*
value1
load key2
values2
load else
values0
value1
loadAll:[key4]
{key4=key4:::values}
 */

1.创建的CacheLoader并简单的实现 V load(K key)。
2.获取元素用get()或getUnchecked()。
3.getAll()会调用loadAll()方法，从而增加效率。
4.put()显示插入数据。

缓存回收

基于容量的回收
CacheBuilder.maximumSize(long)：创建数量限制
CacheBuilder.maximumWeight(long)：创建权重限制
CacheBuilder.weigher(Weigher)：创建权重函数
定时回收
expireAfterAccess(long, TimeUnit)：缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。
expireAfterWrite(long, TimeUnit)：缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。
基于引用的回收
CacheBuilder.weakKeys()：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用键的缓存用==而不是equals比较键。
CacheBuilder.weakValues()：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用值的缓存用==而不是equals比较值。
CacheBuilder.softValues()：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。考虑到使用软引用的性能影响，我们通常建议使用更有性能预测性的缓存大小限定（见上文，基于容量回收）。使用软引用值的缓存同样用==而不是equals比较值。
显式清除
Cache.invalidate(key)：个别清除。
Cache.invalidateAll(keys)：批量清除。
Cache.invalidateAll()：清除所有缓存项。
移除监听器
CacheBuilder.removalListener(RemovalListener)：移除监听。
刷新
LoadingCache.refresh(K)：刷新表示为键加载新值。
CacheLoader.reload(K, V)]：在刷新时重新计算值。
CacheBuilder.refreshAfterWrite(long, TimeUnit)：定时刷新功能。

统计

CacheBuilder.recordStats()：开启统计。
Cache.stats()：返回CacheStats统计内容。
CacheStats.hitRate()：缓存命中率；
CacheStats.averageLoadPenalty()：加载新值的平均时间，单位为纳秒；
CacheStats.evictionCount()：缓存项被回收的总数，不包括显式清除

字符串处理

连接器

Joiner joiner = Joiner.on(":").skipNulls();
String string = joiner.join("AAA", null, "BBB", "CCC");
String string0 = joiner.join(Arrays.asList("DDD", "EEEE"));
System.out.println(string);
System.out.println(string0);

拆分器

Iterable<String> stringSet= Splitter.on(',')
        //.limit(3)
        .omitEmptyStrings()
        .trimResults()
        .split("a,b,,c,d,e,f");
Iterator<String> iterator = stringSet.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next());
}

拆分工厂

方法	描述	范例
Splitter.on(char)	按单个字符拆分	Splitter.on(‘;’)
Splitter.on(CharMatcher)	按字符匹配器拆分	Splitter.on(CharMatcher.BREAKING_WHITESPACE)
Splitter.on(String)	按字符串拆分	Splitter.on(“, “)
Splitter.on(Pattern) Splitter.onPattern(String)	按正则表达式拆分	Splitter.onPattern(“\r?\n”)
Splitter.fixedLength(int)	按固定长度拆分；最后一段可能比给定长度短，但不会为空。	Splitter.fixedLength(3)

拆分修饰

方法	描述
omitEmptyStrings()	从结果中自动忽略空字符串
trimResults()	移除结果字符串的前导空白和尾部空白
trimResults(CharMatcher)	给定匹配器，移除结果字符串的前导匹配字符和尾部匹配字符
limit(int)	限制拆分出的字符串数量

原生类型处理

原生类型相对应的工具类

原生类型	Guava工具类
byte	Bytes, SignedBytes, UnsignedBytes
short	Shorts
int	Ints, UnsignedInteger, UnsignedInts
long	Longs, UnsignedLong, UnsignedLongs
float	Floats
double	Doubles
char	Chars
boolean	Booleans

原生类型数组工具

方法签名	描述	类似方法	可用性
List<Wrapper> asList(prim… backingArray)	把数组转为相应包装类的List	Arrays.asList	符号无关*
prim[] toArray(Collection<Wrapper> collection)	把集合拷贝为数组，和collection.toArray()一样线程安全	Collection.toArray()	符号无关
prim[] concat(prim[]… arrays)	串联多个原生类型数组	Iterables.concat	符号无关
boolean contains(prim[] array, prim target)	判断原生类型数组是否包含给定值	Collection.contains	符号无关
int indexOf(prim[] array, prim target)	给定值在数组中首次出现处的索引，若不包含此值返回-1	List.indexOf	符号无关
int lastIndexOf(prim[] array, prim target)	给定值在数组最后出现的索引，若不包含此值返回-1	List.lastIndexOf	符号无关
prim min(prim… array)	数组中最小的值	Collections.min	符号相关*
prim max(prim… array)	数组中最大的值	Collections.max	符号相关
String join(String separator, prim… array)	把数组用给定分隔符连接为字符串	Joiner.on(separator).join	符号相关
Comparator<prim[]> lexicographicalComparator()	按字典序比较原生类型数组的Comparator	Ordering.natural().lexicographical()	符号相关

int[] ints= {1,2,3};
int[] ints0= {8,9,0};

List<Integer> integerList = Ints.asList(ints);
for (Integer integerListItem:integerList){
    System.out.println(integerListItem);
}
//123
System.out.println("================");

int[] ints1 = Ints.toArray(integerList);
for (int i :ints1){
    System.out.println(i);
}
//123
System.out.println("================");

int[] ints2 = Ints.concat(ints,ints0);
for (int i :ints2){
    System.out.println(i);
}
//123890
System.out.println("================");

boolean isContains = Ints.contains(ints,2);
System.out.println(isContains);
//true
System.out.println("================");

int index = Ints.indexOf(ints,0);
System.out.println(index);
//-1
System.out.println("================");

int index1 = Ints.indexOf(ints,1);
System.out.println(index1);
//0
System.out.println("================");

int max = Ints.max(ints2);
System.out.println(max);
//9
System.out.println("================");

int min = Ints.min(ints2);
System.out.println(min);
//1
System.out.println("================");

String string = Ints.join(";",ints);
System.out.println(string);
//1;2;3
System.out.println("================");

int c = Ints.constrainToRange(-3,0,9);
System.out.println(c);
//0
System.out.println("================");

区间

区间的构建

由Range类的静态方法构建区间

区间描述	方法
(a..b)	open(C, C)
[a..b]	closed(C, C)
[a..b)	closedOpen(C, C)
(a..b]	openClosed(C, C)
(a..+∞)	greaterThan(C)
[a..+∞)	atLeast(C)
(-∞..b)	lessThan(C)
(-∞..b]	atMost(C)
(-∞..+∞)	all()

用明确指定边界类型构造区间

区间描述	方法
有界区间	range(C, BoundType, C, BoundType)
无上界区间：((a..+∞) 或[a..+∞))	downTo(C, BoundType)
无下界区间：((-∞..b) 或(-∞..b])	upTo(C, BoundType)

BoundType类型:BoundType.CLOSED或BoundType.OPEN

特别描述

[a..a]：单元素区间
[a..a); (a..a]：空区间，但它们是有效的
(a..a)：无效区间

区间运算

Range range0 = Range.closedOpen(0,4);//[0,4)
Range range1 = Range.openClosed(3,5);//(3,5]
System.out.println(range0.toString());
//[0..4)
System.out.println(range1.toString());
//(3..5]

/**
 * 判断是否是空区间
 */
boolean isEmpty = range0.isEmpty();
System.out.println("isEmpty:"+isEmpty);
//isEmpty:false

/**
 * 判断是否有上限
 */
boolean hasLowerBound = range0.hasLowerBound();
boolean hasUpperBound = range0.hasUpperBound();
System.out.println("hasLowerBound:"+hasLowerBound +"   hasUpperBound:"+hasUpperBound);
//hasLowerBound:true   hasUpperBound:true

/**
 * 返回区间边界类型，CLOSED或OPEN；如果区间没有对应的边界，抛出IllegalStateException；
 */
BoundType lowerBoundType = range0.lowerBoundType();
BoundType upperBoundType = range0.upperBoundType();
System.out.println("hasLowerBound:"+hasLowerBound +"   hasUpperBound:"+hasUpperBound);
//hasLowerBound:true   hasUpperBound:true

/**
 * 返回区间的端点值
 */
Comparable<Integer> lowerEndpoint = range0.lowerEndpoint();
Comparable<Integer> upperEndpoint = range0.upperEndpoint();
System.out.println("lowerEndpoint:"+lowerEndpoint +"   upperEndpoint:"+upperEndpoint);
//lowerEndpoint:0   upperEndpoint:4

/**
 * 区间之间的包含关系
 */
boolean encloses = range0.encloses(range1);
System.out.println("encloses:"+encloses);
//encloses:false

/**
 * 判断区间是否是相连
 */
boolean isConnected = range0.isConnected(range1);
System.out.println("isConnected:"+isConnected);
//isConnected:true

/**
 * 交集：既包含于第一个区间，又包含于另一个区间的最大区间
 */
Range range2 = range0.intersection(range1);
System.out.println("intersection:"+range2.toString());
//intersection:(3..4)


/**
 * 跨区间：同时包括两个区间的最小区间
 */
Range rang3 = range0.span(range1);
System.out.println("span:"+rang3.toString());
//span:[0..5]

离散域

ImmutableSortedSet set = ContiguousSet.create(range0, DiscreteDomain.integers());
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
//0 1 2 3

散列

事件总线

EventBus 事件发布/订阅轻量级框架

数学运算

溢出检查运算

主要针对三种整数运算，int，long和BigInteger。

try {
    /**
     * 这里相加不会报错
     */
    int i0 = Integer.MAX_VALUE + 2;
    System.out.println(i0);
    /**
     * 这里会抛出异常，java.lang.ArithmeticException: overflow
     */
    int i1 = IntMath.checkedAdd(Integer.MAX_VALUE, 2);

} catch (Exception e) {
    e.printStackTrace();
}

IntMath和LongMath有相应的方法

checkedAdd()：相加检测
checkedSubstract()：相除检测
checkedMultiply()：相乘检测
checkedPow()：次幂检测

实数运算

IntMath、LongMath和BigIntegerMath提供相应的运算方法
RoundingMode模式：

DOWN：向零方向舍入（去尾法）
UP：远离零方向舍入
FLOOR：向负无限大方向舍入
CEILING：向正无限大方向舍入
UNNECESSARY：不需要舍入，如果用此模式进行舍入，应直接抛出ArithmeticException
HALF_UP：向最近的整数舍入，其中x.5远离零方向舍入
HALF_DOWN：向最近的整数舍入，其中x.5向零方向舍入
HALF_EVEN：向最近的整数舍入，其中x.5向相邻的偶数舍入

方法(以IntMath为例)

divide(int, int, RoundingMode)：除法
log2(int,RoundingMode)：2为底的对数
log10(int,RoundingMode)：10为底的对数
sqrt(int,RoundingMode)：平方根
gcd(int,int)：最大公约数
mod(int,int)：取模
pow(int,int)：取幂
isPowerOfTwo(int)：是否2的幂
factorial(int)：阶乘
binomial(int ,int)：二项式系数

浮点数运算

isMathematicalInteger(double)：判断该浮点数是不是一个整数
roundToInt(double, RoundingMode)：舍入为int；对无限小数、溢出抛出异常
roundToLong(double, RoundingMode)：舍入为long；对无限小数、溢出抛出异常
roundToBigInteger(double, RoundingMode) ：舍入为BigInteger；对无限小数抛出异常
log2(double, RoundingMode)：2的浮点对数，并且舍入为int，比JDK的Math.log(double) 更快

并发

暂略

反射

暂略

I/O

暂略

散列

暂略

图形

暂略

项目地址

https://github.com/iamludaxu/ae/tree/master/app/src/test/java/gift/witch/android/ae/guava

参考

Google Guava官方教程（中文版）
Guava User Guide

Guava for Android 概述

简介

文档地址

项目地址

源代码说明

基础工具

1.Optional

2.Preconditions

3.Ordering

集合

1.不可变集合

创建方式

2.新集合类型

Multiset

Multimap

BiMap

Table

ClassToInstanceMap

RangeSet

3.集合工具类

Iterables

FluentIterable

Lists、Sets、Maps、Multisets、Multimaps、Tables

缓存

基本使用

缓存回收

统计

字符串处理

连接器

拆分器

原生类型处理

区间

区间的构建

特别描述

区间运算

离散域

散列

事件总线

数学运算

溢出检查运算

实数运算

浮点数运算

并发

反射

I/O

散列

图形

项目地址

参考

猜你喜欢

热点阅读