guava

返回开源：google

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

• 集合 [collections]
• 缓存 [caching]
• 原生类型支持 [primitives support]
• 并发库 [concurrency libraries]
• 通用注解 [common annotations]
• 字符串处理 [string processing]
• I/O 等等。

Guava是一种基于开源的Java库，其中包含谷歌正在由他们很多项目使用的很多核心库。这个库是为了方便编码，并减少编码错误。这个库提供用于集合，缓存，支持原语，并发性，常见注解，字符串处理，I/O和验证的实用方法。

引入

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>28.0-jre</version>
        </dependency>

官方文档

集合工具

集合名称	说明
Multiset	一个扩展来设置界面，允许重复的元素
Multimap	一个扩展来映射接口，以便其键可一次被映射到多个值
BiMap	一个扩展来映射接口，支持反向操作
Table	表代表一个特殊的图，其中两个键可以在组合的方式被指定为单个值

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

        ImmutableList<String> immutableList = ImmutableList.of("a","b");
        ImmutableSet<String> immutableSet = ImmutableSet.of("c","d","d");
        ImmutableMap<String,Integer> immutableMap = ImmutableMap.of("a",34,"b",45);

        immutableList.forEach(System.out::println);
        log.info("不可变set也是正常set：[{}]",immutableSet.contains("v"));

创建不可变集合，先理解什么是immutable(不可变)对象

• 1.在多线程操作下，是线程安全的。
• 2.所有不可变集合会比可变集合更有效的利用资源。
• 3.中途不可改变

不可变集合中的操作（增删改等）均声明为过期，且抛出异常

Multimap

• 以前的做法

Map<String,List<Integer>> map = new HashMap<String,List<Integer>>();
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
map.put("aa", list);
System.out.println(map.get("aa"));//[1, 2]

• 现在的做法

Multimap<String,Integer> multimap = ArrayListMultimap.create();
        multimap.put("a",34);
        multimap.put("a",35);
        multimap.put("a",36);
        log.info("MultiMap:[{}]",multimap.get("a"));

• MultiSet: 无序+可重复 count()方法获取单词的次数 增强了可读性+操作简单

创建方式: Multiset<String> set = HashMultiset.create();

• Multimap: key-value key可以重复

创建方式: Multimap<String, String> teachers = ArrayListMultimap.create();

• BiMap: 双向Map(Bidirectional Map) 键与值都不能重复

创建方式: BiMap<String, String> biMap = HashBiMap.create();

• Table: 双键的Map Map--> Table-->rowKey+columnKey+value //和sql中的联合主键有点像

创建方式: Table<String, String, Integer> tables = HashBasedTable.create();

...等等(guava中还有很多java里面没有给出的集合类型)

Multiset

@GwtCompatible
public interface Multiset<E> extends Collection<E> {

方法	说明
boolean add(E element)	添加一个出现的指定元素这个multiset
int add(E element, int occurrences)	增加大量的元素到这个multiset
boolean contains(Object element)	确定此多集是否包含指定的元素
boolean containsAll(Collection<?> elements)	返回true，如果这个多集至少包含一个出现的指定集合中的所有元素
int count(Object element)	返回出现的元素的在该multiset的数目（元素的数量）
Set<E> elementSet()	返回集包含在此多集不同的元素
Set<Multiset.Entry<E>> entrySet()	返回此多集的内容的视图，分组在Multiset.Entry实例中，每一个都提供了多集的一个元素和元素的计数
boolean equals(Object object)	比较指定对象与此multiset是否相等
int hashCode()	返回此multiset的哈希码
Iterator<E> iterator()	返回一个迭代在这个集合中的元素
boolean remove(Object element)	移除此多集multiset的单个出现的指定元素，如果存在
int remove(Object element, int occurrences)	删除了一些出现，从该多集multiset的指定元素
boolean removeAll(Collection<?> c)	删除所有这一切都包含在指定集合（可选操作）在此集合的元素
boolean retainAll(Collection<?> c)	保持那些包含在指定collection（可选操作）在此只集合中的元素
int setCount(E element, int count)	添加或删除，使得该元素达到所期望的计数的元件的必要出现
boolean setCount(E element, int oldCount, int newCount)	有条件设置元素的计数为一个新值，如在setCount（对象，INT）中所述，条件是该元素预期的当前计数
String toString()	返回该对象的字符串表示

Multiset<String> multiset = HashMultiset.create();
        multiset.add("a");
        multiset.add("a");
        multiset.add("a");
        multiset.add("b");
        multiset.add("b");
        multiset.add("c");
        log.info("统计个数：[{}]",multiset.count("a"));
        for (Multiset.Entry<String> entry : multiset.entrySet()) {
            System.out.println(entry.getCount()+entry.getElement());
        }

public static void main(String[] argv) {
        String[] frutes = {"apple", "bnana", "watermallon", "apple", "apple", "bnana", "apple", "orange"};
        Multiset<String> stringMultiset = HashMultiset.create();
        Collections.addAll(stringMultiset, frutes);
        for (Multiset.Entry<String> fruteEntry : stringMultiset.entrySet()) {
                System.out.println(fruteEntry.getElement() + " : " + fruteEntry.getCount());
        }
}

输出

统计个数a：3
3a
2b
1c

BiMap

back

BiMap是一种特殊的映射其保持映射，同时确保没有重复的值是存在于该映射和一个值可以安全地用于获取键背面的倒数映射

@GwtCompatible
public interface BiMap<K,V>
extends Map<K,V>

方法|说明 V forcePut(K key, V value)另一种put的形式是默默删除，在put(K, V)运行前的任何现有条目值值 BiMap<V,K> inverse()|返回此bimap，每一个bimap的值映射到其相关联的键的逆视图 V put(K key, V value)|关联指定值与此映射中(可选操作)指定的键 void putAll(Map<? extends K,? extends V> map)|将所有从指定映射此映射(可选操作)的映射 Set<V> values()|返回此映射中包含Collection的值视图

BiMap<Integer, String> empIDNameMap = HashBiMap.create();

      empIDNameMap.put(new Integer(101), "Mahesh");
      empIDNameMap.put(new Integer(102), "Sohan");
      empIDNameMap.put(new Integer(103), "Ramesh");

      //Emp Id of Employee "Mahesh"
      System.out.println(empIDNameMap.inverse().get("Mahesh"));

Table

Table代表一个特殊的映射，其中两个键可以在组合的方式被指定为单个值。它类似于创建映射的映射。

方法	描述
Set<Table.Cell<R,C,V>> cellSet()	返回集合中的所有行键/列键/值三元组
void clear()	从表中删除所有映射
Map<R,V> column(C columnKey)	返回在给定列键的所有映射的视图
Set<C> columnKeySet()	返回一组具有表中的一个或多个值的列键
Map<C,Map<R,V>> columnMap()	返回关联的每一列键与行键对应的映射值的视图
boolean contains(Object rowKey, Object columnKey)	返回true，如果表中包含与指定的行和列键的映射
boolean containsColumn(Object columnKey)	返回true，如果表中包含与指定列的映射
boolean containsRow(Object rowKey)	返回true，如果表中包含与指定的行键的映射关系
boolean containsValue(Object value)	返回true，如果表中包含具有指定值的映射
boolean equals(Object obj)	比较指定对象与此表是否相等
V get(Object rowKey, Object columnKey)	返回对应于给定的行和列键，如果没有这样的映射存在值，返回null
int hashCode()	返回此表中的哈希码
boolean isEmpty()	返回true，如果表中没有映射
V put(R rowKey, C columnKey, V value)	关联指定值与指定键
void putAll(Table<? extends R,? extends C,? extends V> table)	复制从指定的表中的所有映射到这个表
V remove(Object rowKey, Object columnKey)	如果有的话，使用给定键相关联删除的映射
Map<C,V> row(R rowKey)	返回包含给定行键的所有映射的视图
Set<R> rowKeySet()	返回一组行键具有在表中的一个或多个值
Map<R,Map<C,V>> rowMap()	返回关联的每一行按键与键列对应的映射值的视图
int size()	返回行键/列键/表中的值映射关系的数量
Collection<V> values()	返回所有值，其中可能包含重复的集合

Table<String, String, String> employeeTable = HashBasedTable.create();
//initialize the table with employee details
      employeeTable.put("IBM", "101","Mahesh");
      employeeTable.put("IBM", "102","Ramesh");
      employeeTable.put("IBM", "103","Suresh");

      employeeTable.put("Microsoft", "111","Sohan");
      employeeTable.put("Microsoft", "112","Mohan");
      employeeTable.put("Microsoft", "113","Rohan");

      employeeTable.put("TCS", "121","Ram");
      employeeTable.put("TCS", "122","Shyam");
      employeeTable.put("TCS", "123","Sunil");

      //get Map corresponding to IBM
      Map<String,String> ibmEmployees =  employeeTable.row("IBM");

      System.out.println("List of IBM Employees");
      for(Map.Entry<String, String> entry : ibmEmployees.entrySet()){
         System.out.println("Emp Id: " + entry.getKey() + ", Name: " + entry.getValue());
      }

      //get all the unique keys of the table
      Set<String> employers = employeeTable.rowKeySet();
      System.out.print("Employers: ");
      for(String employer: employers){
         System.out.print(employer + " ");

字符串工具

程序名称	说明
Joiner	实用加入对象，字符串等
Spilter	实用程序用来分割字符串
CharMatcher	实用的字符操作
CaseFormat	实用程序，用于改变字符串格式

Splitter

Splitter详解

将String转换为map

String str = "xiaoming=11,xiaohong=23";
Map<String,String> map = Splitter.on(",").withKeyValueSeparator("=").split(str);

还支持多个字符切割，或者特定的正则分隔

String input = "aa.dd,,ff,,.";
        List<String> result = Splitter.onPattern("[.|,]").omitEmptyStrings().splitToList(input);
        //[aa, dd, ff]

CharMatcher

ChartMather详解

// 判断匹配结果
boolean result = CharMatcher.inRange('a', 'z').or(CharMatcher.inRange('A', 'Z')).matches('K'); //true
// 保留数字文本
String s1 = CharMatcher.digit().retainFrom("abc 123 efg"); //123
// 删除数字文本
String s2 = CharMatcher.digit().removeFrom("abc 123 efg");    //abc  efg

Joiner

back

Joiner详解

处理List

以前我们将list转换为特定规则的字符串是这样写的:

List<String> list = new ArrayList<String>();
list.add("aa");
list.add("bb");
list.add("cc");
String str = "";
for(int i=0; i<list.size(); i++){
str = str + "-" +list.get(i);
}

现在用了Guava

List<String> list = new ArrayList<String>();
list.add("aa");
list.add("bb");
list.add("cc");
String result = Joiner.on("-").join(list);

处理Map

System.out.println(Joiner.on(".,").withKeyValueSeparator(":").join(immutableMap));

输出：a:34.,b:45

原语工具

返回顶部

程序名称	说明
Bytes	实用程序的原始字节。
Shorts	实用的原始short。
Ints	实用为基本整型。
Longs	实用的原始长整型。
Floats	实用为基本float。
Doubles	实用为基本的double。
Chars	实用的原始字符。
Booleans	实用为基本布尔。

数学工具

返回顶部

程序名称	说明
IntMath	数学工具为int类型
LongMath	数学工具为long类型
BigIntegerMath	数学实用程序处理BigInteger。

Preconditions

返回顶部

Preconditions提供静态方法来检查方法或构造函数，被调用是否给定适当的参数。它检查的先决条件。其方法失败抛出IllegalArgumentException。

S.N.	方法及说明
1	static void checkArgument(boolean expression)确保涉及的一个或多个参数来调用方法表达式的真相。
2	static void checkArgument(boolean expression, Object errorMessage)确保涉及的一个或多个参数来调用方法表达式的真相。
3	static void checkArgument(boolean expression, String errorMessageTemplate, Object... errorMessageArgs)确保涉及的一个或多个参数来调用方法表达式的真相。
4	static int checkElementIndex(int index, int size)确保索引指定一个数组，列表或尺寸大小的字符串有效的元素。
5	static int checkElementIndex(int index, int size, String desc)确保索引指定一个数组，列表或尺寸大小的字符串有效的元素。
6	static <T> T checkNotNull(T reference)确保对象引用作为参数传递给调用方法不为空。
7	static <T> T checkNotNull(T reference, Object errorMessage)确保对象引用作为参数传递给调用方法不为空。
8	static <T> T checkNotNull(T reference, String errorMessageTemplate, Object... errorMessageArgs)确保对象引用作为参数传递给调用方法不为空。
9	static int checkPositionIndex(int index, int size)确保索引指定一个数组，列表或尺寸大小的字符串的有效位置。
10	static int checkPositionIndex(int index, int size, String desc)确保索引指定一个数组，列表或尺寸大小的字符串的有效位置。
11	static void checkPositionIndexes(int start, int end, int size)确保开始和结束指定数组，列表或字符串大小有效的位置，并按照顺序。
12	static void checkState(boolean expression)确保涉及调用实例的状态，但不涉及任何参数来调用方法表达式的真相。
13	static void checkState(boolean expression, Object errorMessage)确保涉及调用实例的状态，但不涉及任何参数来调用方法表达式的真相。
14	static void checkState(boolean expression, String errorMessageTemplate, Object... errorMessageArgs)确保涉及调用实例的状态，但不涉及任何参数来调用方法表达式的真相。

MoreObjects

返回顶部

Ordering

返回顶部

@GwtCompatible
public abstract class Ordering<T>
   extends Object
      implements Comparator<T>

Ordering(排序)可以被看作是一个丰富的比较具有增强功能的链接，多个实用方法，多类型排序功能等。
natural()对可排序类型做自然排序，如数字按大小，日期按先后排序
usingToString()按对象的字符串形式做字典排序[lexicographical ordering]
from(Comparator)把给定的Comparator转化为排序器
reverse()获取语义相反的排序器
nullsFirst()使用当前排序器，但额外把null值排到最前面。
nullsLast()使用当前排序器，但额外把null值排到最后面。
compound(Comparator)合成另一个比较器，以处理当前排序器中的相等情况。
lexicographical()基于处理类型T的排序器，返回该类型的可迭代对象Iterable<T>的排序器。
onResultOf(Function)对集合中元素调用Function，再按返回值用当前排序器排序。

Person person = new Person("aa",14);  //String name  ,Integer age
Person ps = new Person("bb",13);
Ordering<Person> byOrdering = Ordering.natural().nullsFirst().onResultOf(new Function<Person,String>(){
public String apply(Person person){
    return person.age.toString();
}
});
byOrdering.compare(person, ps);
System.out.println(byOrdering.compare(person, ps)); //1      person的年龄比ps大 所以输出1

方法	说明
static Ordering<Object> allEqual()	返回一个排序，它把所有的值相等，说明“没有顺序。”通过这个顺序以任何稳定的排序算法的结果，在改变没有顺序元素。
static Ordering<Object> arbitrary()	返回一个任意顺序对所有对象，其中compare(a, b) == 0 意味着a == b（身份平等）。
int binarySearch(List<? extends T> sortedList, T key)	搜索排序列表使用键的二进制搜索算法。
abstract int compare(T left, T right)	比较两个参数的顺序。
<U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator)	返回首先使用排序这一点，但它排序中的“tie”，然后委托给secondaryComparator事件。
static <T> Ordering<T> compound(Iterable<? extends Comparator<? super T>> comparators)	返回一个排序它尝试每个给定的比较器，以便直到一个非零结果找到，返回该结果，并返回零仅当所有比较器返回零。
static <T> Ordering<T> explicit(List<T> valuesInOrder)	返回根据它们出现的定列表中的顺序比较对象进行排序。
static <T> Ordering<T> explicit(T leastValue, T... remainingValuesInOrder)	返回根据它们所赋予本方法的顺序进行比较的对象进行排序。
static <T> Ordering<T> from(Comparator<T> comparator)	返回基于现有的比较实例进行排序。
<E extends T> List<E> greatestOf(Iterable<E> iterable, int k)	返回根据这个顺序给出迭代，为了从最大到最小的k个最大的元素。
<E extends T> List<E> greatestOf(Iterator<E> iterator, int k)	返回从给定的迭代器按照这个顺序，从最大到最小k个最大的元素。
<E extends T> ImmutableList<E> immutableSortedCopy(Iterable<E> elements)	返回包含的元素排序这种排序的不可变列表。
boolean isOrdered(Iterable<? extends T> iterable)	返回true如果在迭代后的第一个的每个元素是大于或等于在它之前，根据该排序的元素。
boolean isStrictlyOrdered(Iterable<? extends T> iterable)	返回true如果在迭代后的第一个的每个元素是严格比在它之前，根据该排序的元素更大。
<E extends T> List<E> leastOf(Iterable<E> iterable, int k)	返回根据这个顺序给出迭代，从而从低到最大的k个最低的元素。
<E extends T> List<E> leastOf(Iterator<E> elements, int k)	返回第k从给定的迭代器，按照这个顺序从最低到最大至少元素
<S extends T> Ordering<Iterable<S>> lexicographical()	返回一个新的排序它通过比较对应元素两两直到非零结果发现排序迭代;规定“字典顺序”。
<E extends T> E max(E a, E b)	返回两个值按照这个顺序的较大值。
<E extends T> E max(E a, E b, E c, E... rest)	返回指定的值，根据这个顺序是最大的。
<E extends T> E max(Iterable<E> iterable)	返回指定的值，根据这个顺序是最大的。
<E extends T> E max(Iterator<E> iterator)	返回指定的值，根据这个顺序是最大的。
<E extends T> E min(E a, E b)	返回两个值按照这个顺序的较小者。
<E extends T> E min(E a, E b, E c, E... rest)	返回最少指定的值，根据这个顺序。
<E extends T> E min(Iterable<E> iterable)	返回最少指定的值，根据这个顺序。
<E extends T> E min(Iterator<E> iterator)	返回最少指定的值，根据这个顺序。
static <C extends Comparable> Ordering<C> natural()	返回使用值的自然顺序排序序列化。
<S extends T> Ordering<S> nullsFirst()	返回对待null小于所有其他值，并使用此来比较非空值排序。
<S extends T> Ordering<S> nullsLast()	返回对待null作为大于所有其他值，并使用这个顺序来比较非空值排序。
<F> Ordering<F> onResultOf(Function<F,? extends T> function)	返回一个新的排序在F上，首先应用功能给它们，然后比较使用此这些结果的顺序元素。
<S extends T> Ordering<S> reverse()	返回相反顺序; 顺序相当于Collections.reverseOrder（Comparator）。
<E extends T> List<E> sortedCopy(Iterable<E> elements)	返回包含的元素排序此排序可变列表;使用这个只有在结果列表可能需要进一步修改，或可能包含null。
static Ordering<Object> usingToString()	返回由它们的字符串表示的自然顺序，toString()比较对象进行排序。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.google.common.collect.Ordering;

public class GuavaTester {
   public static void main(String args[]){
      List<Integer> numbers = new ArrayList<Integer>();
      numbers.add(new Integer(5));
      numbers.add(new Integer(2));
      numbers.add(new Integer(15));
      numbers.add(new Integer(51));
      numbers.add(new Integer(53));
      numbers.add(new Integer(35));
      numbers.add(new Integer(45));
      numbers.add(new Integer(32));
      numbers.add(new Integer(43));
      numbers.add(new Integer(16));

      Ordering ordering = Ordering.natural();
      System.out.println("Input List: ");
      System.out.println(numbers);
      Collections.sort(numbers,ordering );
      System.out.println("Sorted List: ");
      System.out.println(numbers);
      System.out.println("======================");
      System.out.println("List is sorted: " + ordering.isOrdered(numbers));
      System.out.println("Minimum: " + ordering.min(numbers));
      System.out.println("Maximum: " + ordering.max(numbers));
      Collections.sort(numbers,ordering.reverse());
      System.out.println("Reverse: " + numbers);

      numbers.add(null);
      System.out.println("Null added to Sorted List: ");
      System.out.println(numbers);

      Collections.sort(numbers,ordering.nullsFirst());
      System.out.println("Null first Sorted List: ");
      System.out.println(numbers);
      System.out.println("======================");

      List<String> names = new ArrayList<String>();
      names.add("Ram");
      names.add("Shyam");
      names.add("Mohan");
      names.add("Sohan");
      names.add("Ramesh");
      names.add("Suresh");
      names.add("Naresh");
      names.add("Mahesh");
      names.add(null);
      names.add("Vikas");
      names.add("Deepak");

      System.out.println("Another List: ");
      System.out.println(names);

  Collections.sort(names,ordering.nullsFirst().reverse());
      System.out.println("Null first then reverse sorted list: ");
      System.out.println(names);
   }
}

Stopwatch

返回顶部

计算中间代码的运行时间

Stopwatch stopwatch = Stopwatch.createStarted();
for(int i=0; i<100000; i++){
    int i = 1;
}
long nanos = stopwatch.elapsed(TimeUnit.MILLISECONDS);
System.out.println(nanos);

文件操作

返回顶部

以前我们写文件读取的时候要定义缓冲区，各种条件判断，各种$%#$@#

Files

缓存

返回顶部

Range

返回顶部

方法	说明
static <C extends Comparable<?>> Range<C> all()	返回包含C型的每一个值范围
boolean apply(C input)Deprecated.	只有提供满足谓词接口;使用包含(C)来代替。
static <C extends Comparable<?>> Range<C> atLeast(C endpoint)	返回包含大于或等于终点(endpoint)的所有值的范围内。
static <C extends Comparable<?>> Range<C> atMost(C endpoint)	返回包含的所有值小于或等于终点的范围内。
Range<C> canonical(DiscreteDomain<C> domain)	返回此范围内，在给定域中的规范形式。
static <C extends Comparable<?>> Range<C> closed(C lower, C upper)	lower<= <=upper。
static <C extends Comparable<?>> Range<C> closedOpen(C lower, C upper)	lower<= <upper。
boolean contains(C value)	返回true，如果值是这个范围的范围之内。
boolean containsAll(Iterable<? extends C> values)	如果值每一个元素都包含在这个范围内，则返回 true。
static <C extends Comparable<?>> Range<C> downTo(C endpoint, BoundType boundType)	返回的范围内的给定的端点，它可以是包容性（闭合）或专用（开），没有上限。
tatic <C extends Comparable<?>> Range<C> encloseAll(Iterable<C> values)	返回包含所有给定值的最小范围内。
boolean encloses(Range<C> other)	返回true，包含。
boolean equals(Object object)	返回true，如果对象是具有相同端点和绑定类型，这个范围内的范围。
static <C extends Comparable<?>> Range<C> greaterThan(C endpoint)	返回一个包含所有值严格大于端点的范围内。
int hashCode()	返回此范围内的哈希码。
boolean hasLowerBound()	如果此范围内具有更低的终点返回true。
boolean hasUpperBound()	如果此范围内有上端点返回true。
Range<C> intersection(Range<C> connectedRange)	返回由两者范围和connectedRange封闭，如果这样的范围存在的最大范围。
boolean isConnected(Range<C> other)	如果存在这是由两者此范围和其他封闭（可能为空）的范围，则返回true。
boolean isEmpty()	返回true，如果这个范围是形式 [v..v) 或 (v..v].
static <C extends Comparable<?>> Range<C> lessThan(C endpoint)	返回一个包含所有值严格小于端点的范围内。
BoundType lowerBoundType()	返回类型这个范围的下限：如果范围包括它的下端点BoundType.CLOSED，如果没有BoundType.OPEN。
C lowerEndpoint()	返回该范围的较低端点。
static <C extends Comparable<?>> Range<C> open(C lower, C upper)	lower< <upper。
static <C extends Comparable<?>> Range<C> openClosed(C lower, C upper)	返回包含所有值严格低于更大且小于或等于上限的范围内。
static <C extends Comparable<?>> Range<C> range(C lower, BoundType lowerType, C upper, BoundType upperType)	返回包含任何值由下到上，每个端点可以是包容性（关闭）或专用（开）的范围。
static <C extends Comparable<?>> Range<C> singleton(C value)	返回包含只在给定范围内的值。
Range<C> span(Range<C> other)	返回最小的范围包围两者这个范围和other等。
String toString()	返回该范围内的字符串表示，如“[3..5）”（其他实例列在类文档）。
BoundType upperBoundType()	返回类型此范围的上限：如果范围包括其上的端点返回BoundType.CLOSED，如果没有返回BoundType.OPEN。

C upperEndpoint()返回此范围的上限端点。 static <C extends Comparable<?>> Range<C> upTo(C endpoint, BoundType boundType)|返回一个范围，没有下限到给定的端点，它可以是包容性（闭合）或专用（开）。

Range<String> stringRange1 = Range.closed("a","f");
        Range<String> stringRange2 = Range.open("a","f");
        Range<String> stringRange3 = Range.openClosed("a","f");
        Range<String> stringRange4 = Range.closedOpen("a","f");
//        System.out.println("closed："+stringRange1.contains("a"));
//        System.out.println("closed："+stringRange1.contains("f"));
//        System.out.println("open："+stringRange2.contains("a"));
//        System.out.println("open："+stringRange2.contains("f"));
//        System.out.println("openClosed："+stringRange3.contains("a"));
//        System.out.println("openClosed："+stringRange3.contains("f"));
//        System.out.println("closedOpen："+stringRange4.contains("a"));
//        System.out.println("closedOpen："+stringRange4.contains("f"));

        System.out.println("closedOpen："+stringRange4.lowerEndpoint());
        System.out.println("closedOpen："+stringRange4.upperBoundType());
        System.out.println("closedOpen："+stringRange4.lowerBoundType());
        System.out.println(stringRange2.isConnected(stringRange1));//是否存在交集
        System.out.println(stringRange1.intersection(stringRange2));//交集
        System.out.println(stringRange1.span(stringRange2));//并集

Throwables

返回顶部

方法	说明
static List<Throwable> getCausalChain(Throwable throwable)	获取一个Throwable的原因链的列表。
static Throwable getRootCause(Throwable throwable)	返回抛出的最里面的原因。
static String getStackTraceAsString(Throwable throwable)	返回包含toString()的结果字符串，随后完整抛出，递归的堆栈跟踪。
static RuntimeException propagate(Throwable throwable)	传播抛出原样如果RuntimeException或Error是一个实例，否则作为最后的报告，把它包装在一个RuntimeException，然后传播。
static <X extends Throwable> void propagateIfInstanceOf(Throwable throwable, Class<X> declaredType)	传播抛出对象完全按原样，当且仅当它是declaredType的一个实例。
static void propagateIfPossible(Throwable throwable)	传播抛出对象完全按原样，当且仅当它是RuntimeException或Error的一个实例。
static <X extends Throwable> void propagateIfPossible(Throwable throwable, Class<X> declaredType)	传播抛出对象完全按原样，当且仅当它是RuntimeException，错误或的declaredType的一个实例。
static <X1 extends Throwable,X2 extends Throwable>void propagateIfPossible(Throwable throwable, Class<X1> declaredType1, Class<X2> declaredType2)	传播抛出对象完全按原样，当且仅当它是RuntimeException，Error，declaredType1或declaredType2的一个实例。

Optional

返回顶部

S.N.	方法及说明
static <T> Optional<T> absent()	返回没有包含的参考Optional的实例。
abstract Set<T> asSet()	返回一个不可变的单集的唯一元素所包含的实例(如果存在);否则为一个空的不可变的集合。
abstract boolean equals(Object object)	返回true如果对象是一个Optional实例，无论是包含引用彼此相等或两者都不存在。
static <T> Optional<T> fromNullable(T nullableReference)	如果nullableReference非空，返回一个包含引用Optional实例;否则返回absent()。
abstract T get()	返回所包含的实例，它必须存在。
abstract int hashCode()	返回此实例的哈希码。
abstract boolean isPresent()	返回true，如果这支架包含一个(非空)的实例。
static <T> Optional<T> of(T reference)	返回包含给定的非空引用Optional实例。
abstract Optional<T> or(Optional<? extends T> secondChoice)	返回此Optional，如果它有一个值存在; 否则返回secondChoice。
abstract T or(Supplier<? extends T> supplier)	返回所包含的实例(如果存在); 否则supplier.get()。
abstract T or(T defaultValue)	返回所包含的实例(如果存在);否则为默认值。
abstract T orNull()	返回所包含的实例(如果存在);否则返回null。
static <T> Iterable<T> presentInstances(Iterable<? extends Optional<? extends T>> optionals)	从提供的optionals返回每个实例的存在的值，从而跳过absent()。
abstract String toString()	返回此实例的字符串表示。
abstract <V> Optional<V> transform(Function<? super T,V> function)	如果实例存在，则它被转换给定的功能;否则absent()被返回。