TutorialsPoint Guava 教程

来源：易百教程

Guava教程

Guava 是什么?

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

Guava的好处

标准化 - Guava库是由谷歌托管。

高效 - 可靠，快速和有效的扩展JAVA标准库

优化 -Guava库经过高度的优化。

函数式编程 -增加JAVA功能和处理能力。

实用程序 - 提供了经常需要在应用程序开发的许多实用程序类。

验证 -提供标准的故障安全验证机制。

最佳实践 - 强调最佳的做法。

考虑下面的代码片段。

public class GuavaTester {
   public static void main(String args[]){
      GuavaTester guavaTester = new GuavaTester();
      Integer a =  null;
      Integer b =  new Integer(10);
      System.out.println(guavaTester.sum(a,b));
   }

   public Integer sum(Integer a, Integer b){
      return a + b;
   }
}

运行程序，看到如下结果。

Exception in thread "main" java.lang.NullPointerException
    at GuavaTester.sum(GuavaTester.java:13)
    at GuavaTester.main(GuavaTester.java:9)

以下是该代码的问题。

sum() 不采取任何的保护传递的参数为null。

调用函数也并不担心传递一个null 到sum（）方法而产生意外。

当程序运行时，NullPointerException异常发生。

为了避免上述问题，null检查要在每个这样存在问题地方。

让我们来看看使用Optional，Guava 提供实用工具类来标准化方式解决上述问题。

import com.google.common.base.Optional;

public class GuavaTester {
   public static void main(String args[]){
      GuavaTester guavaTester = new GuavaTester();

      Integer invalidInput = null;
      Optional<Integer> a =  Optional.of(invalidInput);
      Optional<Integer> b =  Optional.of(new Integer(10));
      System.out.println(guavaTester.sum(a,b));
   }

   public Integer sum(Optional<Integer> a, Optional<Integer> b){
      return a.get() + b.get();
   }
}

运行程序，看到结果如下。

Exception in thread "main" java.lang.NullPointerException
    at com.google.common.base.Preconditions.checkNotNull(Preconditions.java:210)
    at com.google.common.base.Optional.of(Optional.java:85)
    at GuavaTester.main(GuavaTester.java:8)

让我们来了解上述程序的一些重要概念。

Optional - 实用类，使代码使用null能够正常。

Optional.of - 返回要用作参数Optional类的实例。检查传递的值是否为null。

Optional.get - 获取输入存储在Optional 类的值。

使用Optional类，可以方便地查看调用者方法来传递参数正确与否。

Guava环境设置 - Guava教程

Guava本地环境设置

这部分指导如何下载和设置Java在机器上。请按照以下步骤来设置环境。

Java SE免费提供链接：下载Java。所以，根据操作系统下载对应版本。

按照说明下载java和运行.exe 在机器上，并按说明安装Java。一旦机器上安装了Java，还需要设置环境变量指向正确的JAVA安装目录：

Windows 2000/XP设置的路径：

假设你已经安装JAVA在 c:Program Filesjavajdk目录下：

在“我的电脑”右键单击并选择“属性”。

在“高级”选项卡下单击“环境变量”按钮。

现在，改变“Path”变量，因此，它也包含了路径Java可执行文件。例如，路径当前默认设置为'C:WINDOWSSYSTEM32',然后改变路径修改后就是这样：'C:WINDOWSSYSTEM32;c:Program Filesjavajdkin'.

Windows95/98/ME设置路径：

假设你已经安装JAVA在 c:Program Filesjavajdk目录下：

编辑文件 'C:autoexec.bat' 并添加以下行到文件的结尾： 'SET PATH=%PATH%;C:Program Filesjavajdkin'

Linux，UNIX，Solaris和FreeBSD设置路径：

环境变量PATH应设置为指向已安装的Java二进制文件的位置。请参考您的shell文件，如果有麻烦可以这样做。

例如，如果使用的是bash shell，那么将下面的行添加到未尾'.bashrc: export PATH=/path/to/java:$PATH'

流行的Java编辑器：

写Java程序，需要一个文本编辑器。在市场上有很多可用的更复杂的IDE。可以考虑下列之一：

Notepad: 在Windows机器上，可以使用像记事本的简单的文本编辑器（本教程推荐），TextPad。

Netbeans:是一个Java IDE，它是开源和免费的，可从以下地址下载 http://www.netbeans.org/index.html.

Eclipse: 也是一个Java IDE由Eclipse开源社区开发，可以下载 http://www.eclipse.org/.

下载Guava存档

从guava-18.0.jar下载Guava jar文件的最新版本。在写这篇教程的时候，下载最新的版本是 guava-18.0.jar 并拷贝到 C:>Guava 目录。

OS | 归档名称
Windows | guava-18.0.jar
Linux | guava-18.0.jar
Mac | guava-18.0.jar

设置Guava环境

设置Guava_HOME环境变量指向Guava jar 存储在计算机上的目录位置。假设，我们已经提取guava-18.0.jar在各种操作系统的Guava文件夹，如下所示。

OS | 输出
Windows | 设置环境变量 Guava_HOME 到 C:Guava
Linux | export Guava_HOME=/usr/local/Guava
Mac | export Guava_HOME=/Library/Guava

设置CLASSPATH变量

设置CLASSPATH环境变量指向Guava jar位置。假设，我们已经存储guava-18.0.jar的Guava文件夹在不同的操作系统如下。

OS | 输出
Windows | 设置环境变量 CLASSPATH 到 %CLASSPATH%;%Guava_HOME%guava-18.0.jar;.;
Linux | export CLASSPATH=$CLASSPATH:$Guava_HOME/guava-18.0.jar:.
Mac | export CLASSPATH=$CLASSPATH:$Guava_HOME/guava-18.0.jar:.

Guava Optional类 - Guava教程

Optional用于包含非空对象的不可变对象。 Optional对象，用于不存在值表示null。这个类有各种实用的方法，以方便代码来处理为可用或不可用，而不是检查null值。

类声明

以下是com.google.common.base.Optional<T>类的声明：

@GwtCompatible(serializable=true)
public abstract class Optional<T>
   extends Object
      implements Serializable

类方法

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

继承的方法

这个类继承了以下类的方法：

java.lang.Object

Optional示例：

使用所选择的编辑器，创建下面的java程序，比如 C:/> Guava

GuavaTester.java

import com.google.common.base.Optional;

public class GuavaTester {
   public static void main(String args[]){
      GuavaTester guavaTester = new GuavaTester();

      Integer value1 =  null;
      Integer value2 =  new Integer(10);
      //Optional.fromNullable - allows passed parameter to be null.
      Optional<Integer> a = Optional.fromNullable(value1);
      //Optional.of - throws NullPointerException if passed parameter is null
      Optional<Integer> b = Optional.of(value2);

      System.out.println(guavaTester.sum(a,b));
   }

   public Integer sum(Optional<Integer> a, Optional<Integer> b){
      //Optional.isPresent - checks the value is present or not
      System.out.println("First parameter is present: " + a.isPresent());

      System.out.println("Second parameter is present: " + b.isPresent());

      //Optional.or - returns the value if present otherwise returns
      //the default value passed.
      Integer value1 = a.or(new Integer(0));

      //Optional.get - gets the value, value should be present
      Integer value2 = b.get();

      return value1 + value2;
   }
}

验证结果

使用javac编译器编译如下类

C:\Guava>javac GuavaTester.java

现在运行GuavaTester看到的结果

C:\Guava>java GuavaTester

看到结果。

First parameter is present: false
Second parameter is present: true
10

Guava Preconditions类 - Guava教程

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

类声明

以下是com.google.common.base.Preconditions类的声明：

@GwtCompatible
public final class Preconditions
   extends Object

类方法

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) 确保涉及调用实例的状态，但不涉及任何参数来调用方法表达式的真相。

继承的方法

这个类继承了以下类方法：

java.lang.Object

Preconditions 示例

使用所选择的编辑器，创建下面的java程序比如 C:/> Guava

GuavaTester.java

import com.google.common.base.Preconditions;

public class GuavaTester {

   public static void main(String args[]){
      GuavaTester guavaTester = new GuavaTester();
      try {
         System.out.println(guavaTester.sqrt(-3.0));
      }catch(IllegalArgumentException e){
         System.out.println(e.getMessage());
      }
      try {
         System.out.println(guavaTester.sum(null,3));
      }catch(NullPointerException e){
         System.out.println(e.getMessage());
      }
      try {
         System.out.println(guavaTester.getValue(6));
      }catch(IndexOutOfBoundsException e){
         System.out.println(e.getMessage());
      }
   }

   public double sqrt(double input) throws IllegalArgumentException {
      Preconditions.checkArgument(input > 0.0,
         "Illegal Argument passed: Negative value %s.", input);
      return Math.sqrt(input);
   }

   public int sum(Integer a, Integer b){
      a = Preconditions.checkNotNull(a,
         "Illegal Argument passed: First parameter is Null.");
      b = Preconditions.checkNotNull(b,
         "Illegal Argument passed: Second parameter is Null.");
      return a+b;
   }

   public int getValue(int input){
      int[] data = {1,2,3,4,5};
      Preconditions.checkElementIndex(input,data.length,
         "Illegal Argument passed: Invalid index.");
      return 0;
   }
}

验证结果

使用javac编译器编译如下类

C:\Guava>javac GuavaTester.java

现在运行GuavaTester看到的结果

C:\Guava>java GuavaTester

看到结果。

Illegal Argument passed: Negative value -3.0.
Illegal Argument passed: First parameter is Null.
Illegal Argument passed: Invalid index. (6) must be less than size (5)

Guava Ordering类 - Guava教程

Ordering(排序)可以被看作是一个丰富的比较具有增强功能的链接，多个实用方法，多类型排序功能等。

类声明

以下是com.google.common.collect.Ordering<T>类的声明：

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

类方法

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

方法继承

这个类从以下类继承的方法：

java.lang.Object

Ordering 示例

使用所选择的编辑器，创建下面的java程序比如 C:/> Guava

GuavaTester.java

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);
   }
}

验证结果

使用javac编译器编译如下类

C:\Guava>javac GuavaTester.java

现在运行GuavaTester看到的结果

C:\Guava>java GuavaTester

看到结果。

Input List:
[5, 2, 15, 51, 53, 35, 45, 32, 43, 16]
Sorted List:
[2, 5, 15, 16, 32, 35, 43, 45, 51, 53]
======================
List is sorted: true
Minimum: 2
Maximum: 53
Reverse: [53, 51, 45, 43, 35, 32, 16, 15, 5, 2]
Null added to Sorted List:
[53, 51, 45, 43, 35, 32, 16, 15, 5, 2, null]
Null first Sorted List:
[null, 2, 5, 15, 16, 32, 35, 43, 45, 51, 53]
======================
Another List:
[Ram, Shyam, Mohan, Sohan, Ramesh, Suresh, Naresh, Mahesh, null, Vikas, Deepak]
Null first then reverse sorted list:
[Vikas, Suresh, Sohan, Shyam, Ramesh, Ram, Naresh, Mohan, Mahesh, Deepak, null]

Guava Objects类 - Guava教程

Objects类提供适用于所有对象，如equals, hashCode等辅助函数

类声明

以下是com.google.common.base.Objects类的声明：

@GwtCompatible
public final class Objects
   extends Object

类方法

S.N. | 方法及说明
1 | static boolean equal(Object a, Object b) 确定两个可能是空的对象是否相等。
2 | static <T> T firstNonNull(T first, T second) 不推荐使用。使用MoreObjects.firstNonNull（T，T）来代替。定于2016年6月去除该方法。
3 | static int hashCode(Object... objects) 生成多个值的哈希码。
4 | static Objects.ToStringHelper toStringHelper(Class<?> clazz) 不推荐使用。使用MoreObjects.toStringHelper（Class）来代替。定于2016年6月去除该方法。
5 | static Objects.ToStringHelper toStringHelper(Object self) 不推荐使用。使用MoreObjects.toStringHelper（Object）来代替。定于2016年6月去除该方法。
6 | static Objects.ToStringHelper toStringHelper(String className) 不推荐使用。使用MoreObjects.toStringHelper（String）来代替。定于2016年6月去除该方法。

方法继承

这个类从以下类继承的方法：

java.lang.Object

Objects 示例

使用所选择的编辑器，创建下面的java程序比如 C:/> Guava

GuavaTester.java

import com.google.common.base.Objects;

public class GuavaTester {
   public static void main(String args[]){
      Student s1 = new Student("Mahesh", "Parashar", 1, "VI");
      Student s2 = new Student("Suresh", null, 3, null);

      System.out.println(s1.equals(s2));
      System.out.println(s1.hashCode());
      System.out.println(
      Objects.toStringHelper(s1)
         .add("Name",s1.getFirstName()+" " + s1.getLastName())
         .add("Class", s1.getClassName())
         .add("Roll No", s1.getRollNo())
         .toString());
   }
}

class Student {
   private String firstName;
   private String lastName;
   private int rollNo;
   private String className;

   public Student(String firstName, String lastName, int rollNo, String className){
      this.firstName = firstName;
      this.lastName = lastName;
      this.rollNo = rollNo;
      this.className = className;
   }

   @Override
   public boolean equals(Object object){
      if(!(object instanceof Student) || object == null){
         return false;
      }
      Student student = (Student)object;
      // no need to handle null here
      // Objects.equal("test", "test") == true
      // Objects.equal("test", null) == false
      // Objects.equal(null, "test") == false
      // Objects.equal(null, null) == true
      return Objects.equal(firstName, student.firstName) // first name can be null
         && Objects.equal(lastName, student.lastName) // last name can be null
         && Objects.equal(rollNo, student.rollNo)
         && Objects.equal(className, student.className);// class name can be null
   }

   @Override
   public int hashCode(){
      //no need to compute hashCode by self
      return Objects.hashCode(className,rollNo);
   }
   public String getFirstName() {
      return firstName;
   }
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
   public String getLastName() {
      return lastName;
   }
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }
   public int getRollNo() {
      return rollNo;
   }
   public void setRollNo(int rollNo) {
      this.rollNo = rollNo;
   }
   public String getClassName() {
      return className;
   }
   public void setClassName(String className) {
      this.className = className;
   }
}

验证结果

使用javac编译器编译如下类

C:\Guava>javac GuavaTester.java

现在运行GuavaTester看到的结果

C:\Guava>java GuavaTester

看到结果。

false
85871
Student{Name=Mahesh Parashar, Class=VI, Roll No=1}

Guava Range类 - Guava教程

Range 表示一个间隔或一个序列。它被用于获取一组数字/串在一个特定范围之内。

类声明

以下是com.google.common.collect.Range<C>类的声明：

@GwtCompatible
public final class Range<C extends Comparable>
   extends Object
      implements Predicate<C>, Serializable

方法

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

方法继承

这个类从以下类继承的方法：

java.lang.Object

Range 例子

选择使用任何编辑器创建以下java程序在 C:/> Guava

GuavaTester.java

import com.google.common.collect.ContiguousSet;
import com.google.common.collect.DiscreteDomain;
import com.google.common.collect.Range;
import com.google.common.primitives.Ints;

public class GuavaTester {

   public static void main(String args[]){
      GuavaTester tester = new GuavaTester();
      tester.testRange();
   }

   private void testRange(){

      //create a range [a,b] = { x | a <= x <= b}
      Range<Integer> range1 = Range.closed(0, 9);
      System.out.print("[0,9] : ");
      printRange(range1);
      System.out.println("5 is present: " + range1.contains(5));
      System.out.println("(1,2,3) is present: " + range1.containsAll(Ints.asList(1, 2, 3)));
      System.out.println("Lower Bound: " + range1.lowerEndpoint());
      System.out.println("Upper Bound: " + range1.upperEndpoint());

      //create a range (a,b) = { x | a < x < b}
      Range<Integer> range2 = Range.open(0, 9);
      System.out.print("(0,9) : ");
      printRange(range2);

      //create a range (a,b] = { x | a < x <= b}
      Range<Integer> range3 = Range.openClosed(0, 9);
      System.out.print("(0,9] : ");
      printRange(range3);

      //create a range [a,b) = { x | a <= x < b}
      Range<Integer> range4 = Range.closedOpen(0, 9);
      System.out.print("[0,9) : ");
      printRange(range4);

      //create an open ended range (9, infinity
      Range<Integer> range5 = Range.greaterThan(9);
      System.out.println("(9,infinity) : ");
      System.out.println("Lower Bound: " + range5.lowerEndpoint());
      System.out.println("Upper Bound present: " + range5.hasUpperBound());

      Range<Integer> range6 = Range.closed(3, 5);
      printRange(range6);

      //check a subrange [3,5] in [0,9]
      System.out.println("[0,9] encloses [3,5]:" + range1.encloses(range6));

      Range<Integer> range7 = Range.closed(9, 20);
      printRange(range7);
      //check ranges to be connected
      System.out.println("[0,9] is connected [9,20]:" + range1.isConnected(range7));

      Range<Integer> range8 = Range.closed(5, 15);

      //intersection
      printRange(range1.intersection(range8));

      //span
      printRange(range1.span(range8));
   }

   private void printRange(Range<Integer> range){
      System.out.print("[ ");
      for(int grade : ContiguousSet.create(range, DiscreteDomain.integers())) {
         System.out.print(grade +" ");
      }
      System.out.println("]");
   }
}

验证结果

使用javac编译器编译如下类

C:\Guava>javac GuavaTester.java

现在运行GuavaTester看到的结果

C:\Guava>java GuavaTester

看到结果。

[0,9] : [ 0 1 2 3 4 5 6 7 8 9 ]
5 is present: true
(1,2,3) is present: true
Lower Bound: 0
Upper Bound: 9
(0,9) : [ 1 2 3 4 5 6 7 8 ]
(0,9] : [ 1 2 3 4 5 6 7 8 9 ]
[0,9) : [ 0 1 2 3 4 5 6 7 8 ]
(9,infinity) :
Lower Bound: 9
Upper Bound present: false
[ 3 4 5 ]
[0,9] encloses [3,5]:true
[ 9 10 11 12 13 14 15 16 17 18 19 20 ]
[0,9] is connected [9,20]:true
[ 5 6 7 8 9 ]
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ]

Guava Throwables类 - Guava教程

Throwable类提供了相关的Throwable接口的实用方法。

类声明

以下是com.google.common.base.Throwables类的声明：

public final class Throwables
   extends Object

类方法

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

继承的方法

这个类继承了以下类方法：

java.lang.Object

Throwables示例

创建使用所选择的任何编辑器下面的java程序，比如 C:/> Guava

GuavaTester.java

import java.io.IOException;

import com.google.common.base.Objects;
import com.google.common.base.Throwables;

public class GuavaTester {
   public static void main(String args[]){
      GuavaTester tester = new GuavaTester();
      try {
         tester.showcaseThrowables();
      } catch (InvalidInputException e) {
         //get the root cause
         System.out.println(Throwables.getRootCause(e));
      }catch (Exception e) {
         //get the stack trace in string format
         System.out.println(Throwables.getStackTraceAsString(e));
      }

      try {
         tester.showcaseThrowables1();
      }catch (Exception e) {
         System.out.println(Throwables.getStackTraceAsString(e));
      }
   }

   public void showcaseThrowables() throws InvalidInputException{
      try {
         sqrt(-3.0);
      } catch (Throwable e) {
         //check the type of exception and throw it
         Throwables.propagateIfInstanceOf(e, InvalidInputException.class);
         Throwables.propagate(e);
      }
   }

   public void showcaseThrowables1(){
      try {
         int[] data = {1,2,3};
         getValue(data, 4);
      } catch (Throwable e) {
         Throwables.propagateIfInstanceOf(e, IndexOutOfBoundsException.class);
         Throwables.propagate(e);
      }
   }

   public double sqrt(double input) throws InvalidInputException{
      if(input < 0) throw new InvalidInputException();
      return Math.sqrt(input);
   }

   public double getValue(int[] list, int index) throws IndexOutOfBoundsException {
      return list[index];
   }

   public void dummyIO() throws IOException {
      throw new IOException();
   }
}

class InvalidInputException extends Exception {
}

验证结果

使用javac编译器编译如下类

C:\Guava>javac GuavaTester.java

现在运行GuavaTester看到的结果

C:\Guava>java GuavaTester

看到结果。

InvalidInputException
java.lang.ArrayIndexOutOfBoundsException: 4
    at GuavaTester.getValue(GuavaTester.java:52)
    at GuavaTester.showcaseThrowables1(GuavaTester.java:38)
    at GuavaTester.main(GuavaTester.java:19)

Guava集合工具 - Guava教程

Guava介绍了基于开发者的应用开发经验，许多先进的集合。以下是有用的集合列表：

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

Guava缓存工具 - Guava教程

Guava通过接口LoadingCache提供了一个非常强大的基于内存的LoadingCache<K，V>。在缓存中自动加载值，它提供了许多实用的方法，在有缓存需求时非常有用。

接口声明

以下是forcom.google.common.cache.LoadingCache<K，V>接口的声明：

@Beta
@GwtCompatible
public interface LoadingCache<K,V>
   extends Cache<K,V>, Function<K,V>

接口方法

S.N. | 方法及说明
1 | V apply(K key) 不推荐使用。提供满足功能接口;使用get(K)或getUnchecked(K)代替。
2 | ConcurrentMap<K,V> asMap() 返回存储在该缓存作为一个线程安全的映射条目的视图。
3 | V get(K key) 返回一个键在这个高速缓存中，首先装载如果需要该值相关联的值。
4 | ImmutableMap<K,V> getAll(Iterable<? extends K> keys) 返回一个键相关联的值的映射，创建或必要时检索这些值。
5 | V getUnchecked(K key) 返回一个键在这个高速缓存中，首先装载如果需要该值相关联的值。
6 | void refresh(K key) 加载键key，可能是异步的一个新值。

LoadingCache 示例

使用所选择的编辑器创建下面的java程序 C:/> Guava

GuavaTester.java

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import com.google.common.base.MoreObjects;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

public class GuavaTester {
   public static void main(String args[]){
      //create a cache for employees based on their employee id
      LoadingCache <string, employee="" style="box-sizing: border-box;">employeeCache =
         CacheBuilder.newBuilder()
            .maximumSize(100) // maximum 100 records can be cached
            .expireAfterAccess(30, TimeUnit.MINUTES) // cache will expire after 30 minutes of access
            .build(new CacheLoader<string, employee="" style="box-sizing: border-box;">(){ // build the cacheloader
               @Override
               public Employee load(String empId) throws Exception {
                  //make the expensive call
                  return getFromDatabase(empId);
               }
            });

      try {
         //on first invocation, cache will be populated with corresponding
         //employee record
         System.out.println("Invocation #1");
         System.out.println(employeeCache.get("100"));
         System.out.println(employeeCache.get("103"));
         System.out.println(employeeCache.get("110"));
         //second invocation, data will be returned from cache
         System.out.println("Invocation #2");
         System.out.println(employeeCache.get("100"));
         System.out.println(employeeCache.get("103"));
         System.out.println(employeeCache.get("110"));

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

   private static Employee getFromDatabase(String empId){
      Employee e1 = new Employee("Mahesh", "Finance", "100");
      Employee e2 = new Employee("Rohan", "IT", "103");
      Employee e3 = new Employee("Sohan", "Admin", "110");

      Map <string, employee="" style="box-sizing: border-box;">database = new HashMap<string, employee="" style="box-sizing: border-box;">();
      database.put("100", e1);
      database.put("103", e2);
      database.put("110", e3);
      System.out.println("Database hit for" + empId);
      return database.get(empId);
   }
}

class Employee {
   String name;
   String dept;
   String emplD;

   public Employee(String name, String dept, String empID){
      this.name = name;
      this.dept = dept;
      this.emplD = empID;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getDept() {
      return dept;
   }
   public void setDept(String dept) {
      this.dept = dept;
   }
   public String getEmplD() {
      return emplD;
   }
   public void setEmplD(String emplD) {
      this.emplD = emplD;
   }

   @Override
   public String toString() {
      return MoreObjects.toStringHelper(Employee.class)
      .add("Name", name)
      .add("Department", dept)
      .add("Emp Id", emplD).toString();
   }
}</string,></string,></string,></string,>

验证结果

使用javac编译器如下编译类

C:\Guava>javac GuavaTester.java

现在运行GuavaTester看到的结果

C:\Guava>java GuavaTester

看看结果：

Invocation #1
Database hit for100
Employee{Name=Mahesh, Department=Finance, Emp Id=100}
Database hit for103
Employee{Name=Rohan, Department=IT, Emp Id=103}
Database hit for110
Employee{Name=Sohan, Department=Admin, Emp Id=110}
Invocation #2
Employee{Name=Mahesh, Department=Finance, Emp Id=100}
Employee{Name=Rohan, Department=IT, Emp Id=103}
Employee{Name=Sohan, Department=Admin, Emp Id=110}

Guava字符串工具 - Guava教程

Guava介绍基于开发者的应用开发经验，许多先进的字符串工具。以下是有用的基于字符串的实用程序列表：

S.N. | 程序名称和说明
1 | Joiner 实用加入对象，字符串等。
2 | Spilter 实用程序用来分割字符串。
3 | CharMatcher 实用的字符操作。
4 | CaseFormat 实用程序，用于改变字符串格式。

Guava原语工具 - Guava教程

作为Java的原语类型，不能用来传递在泛型或于类别作为输入。Guava提供大量包装工具类来处理原始类型的对象。以下是有用的原始处理工具的列表：

S.N. | 程序名称和说明
1 | Bytes 实用程序的原始字节。
2 | Shorts 实用的原始short。
3 | Ints 实用为基本整型。
4 | Longs 实用的原始长整型。
5 | Floats 实用为基本float。
6 | Doubles 实用为基本的double。
7 | Chars 实用的原始字符。
8 | Booleans 实用为基本布尔。

Guava数学工具 - Guava教程

提供Guava数学相关的实用工具类来处理int，long及BigInteger。以下是有用的工具列表：

S.N. | 程序名称和说明
1 | IntMath 数学工具为int类型。
2 | LongMath 数学工具为long类型。
3 | BigIntegerMath 数学实用程序处理BigInteger。