Guava 简明教程
Guava - Overview
What is Guava?
Guava 是一个基于 Java 的开源库,封装了许多 Google 核心库,广泛用于 Google 旗下的许多项目。它促进了最佳编码实践,有助于减少编码错误。它提供了用于集合、缓存、原生支持、并发、常见注释、字符串处理、I/O 和验证的实用方法。
Benefits of Guava
-
Standardized − Guava 库由 Google 管理。
-
Efficient − 它是对 Java 标准库的一个可靠、快速且高效的扩展。
-
Optimized − 该库经过高度优化。
-
Functional Programming − 它为 Java 添加了功能处理能力。
-
Utilities − 它提供了许多实用类,这些类在编程应用程序开发中经常需要。
-
Validation − 它提供了一个标准的故障保护验证机制。
-
Best Practices − 它强调最佳实践。
考虑以下代码片段。
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() 并未对要作为空值传递的任何参数进行处理。
-
call 函数也不担心意外地将一个空值传递给 sum() 方法。
-
程序运行时,会发生 NullPointerException。
为了避免上述问题,必须在存在此类问题的每一个地方进行空值检查。
让我们看看如何使用 Guava 提供的实用程序类 Optional 来以标准化的方式解决上述问题。
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 − 一个实用程序类,用于让代码正确使用空值。
-
Optional.of − 它返回 Optional 类的实例,以用作参数。它检查传递的值,以判断它是否是“null”。
-
Optional.get − 它获取存储在 Optional 类中的输入值。
使用 Optional 类,您可以检查调用方法是否传递了适当的参数。
Guava - Environment Setup
Local Environment Setup
如果您仍然愿意为 Java 编程语言设置您的环境,则本节指导您如何在您的机器上下载并设置 Java。请按照下面提到的步骤设置环境。
Java SE 可以从链接 Download Java 中免费获取。因此,您可以根据自己的操作系统下载版本。
按照说明下载 Java 并运行 .exe 以在您的计算机上安装 Java。安装计算机上的 Java 后,您需要设置环境变量以指向正确的安装目录 −
Setting up the Path for Windows 2000/XP
我们假设您已将 Java 安装在 c:\Program Files\java\jdk 目录中 −
-
右键单击“我的电脑”,然后选择“属性”。
-
单击“高级”选项卡下的“环境变量”按钮。
-
现在,更改“路径”变量,使其也包含指向 Java 可执行文件的路径。例如,如果路径目前设置为“C:\WINDOWS\SYSTEM32”,那么将您的路径更改为“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。
Setting up the Path for Windows 95/98/ME
我们假设您已将 Java 安装在 c:\Program Files\java\jdk 目录中 −
-
编辑 ‘C:\autoexec.bat’ 文件并在末尾添加以下行 − ‘SET PATH=%PATH%;C:\Program Files\java\jdk\bin’
Setting up the Path for Linux, UNIX, Solaris, FreeBSD
环境变量 PATH 应设置为指向已安装 Java 二进制文件的位置。如果你在这方面遇到问题,请参阅 shell 文档。
例如,如果您用 bash 作为您的 shell,则您将向您 '.bashrc: export PATH=/path/to/java:$PATH' 的末尾添加以下行
Popular Java Editors
要编写 Java 程序,您需要一个文本编辑器。市场中有许多高级集成开发环境可用。但目前,您可以考虑以下选项之一 −
-
Notepad − 在 Windows 计算机上,您可以使用任何简单的文本编辑器,例如记事本(推荐用于本教程)、TextPad。
-
Netbeans - 它是一款开源的免费 Java IDE,可以从 https://www.netbeans.org/index.html 下载。
-
Eclipse - 它也是一款由 Eclipse 开源社区开发的 Java IDE,可以从 https://www.eclipse.org/ 下载。
Download Guava Archive
从 guava-18.0.jar 下载 Guava jar 文件的最新版本。编写本教程时,我们已经下载了 guava-18.0.jar,并将它复制到了 C:\>Guava 文件夹。
OS |
Archive name |
Windows |
guava-18.0.jar |
Linux |
guava-18.0.jar |
Mac |
guava-18.0.jar |
Set Guava Environment
将 Guava_HOME 环境变量设置为你计算机上储存 Guava jar 的基础目录位置。假设我们已经将 guava-18.0.jar 提取到各个操作系统上的 Guava 文件夹中,如下所示:
OS |
Output |
Windows |
将环境变量 Guava_HOME 设置为 C:\Guava |
Linux |
export Guava_HOME=/usr/local/Guava |
Mac |
export Guava_HOME=/Library/Guava |
Set CLASSPATH Variable
将 CLASSPATH 环境变量设置为你计算机上储存 Guava jar 的位置。假设我们已经将 guava-18.0.jar 存储到各个操作系统上的 Guava 文件夹中,如下所示:
OS |
Output |
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 Class
Optional 是用来存储非空对象的不可变对象。Optional 对象用来表示空值和缺失值。此类具有各种辅助方法,便于代码处理存在的或不存在的值,而不是检查空值。
Class Declaration
以下是有关 com.google.common.base.Optional<T> 类的声明 −
@GwtCompatible(serializable = true)
public abstract class Optional<T>
extends Object
implements Serializable
Class Methods
Sr.No |
Method & Description |
1 |
static <T> Optional<T> absent() 返回不包含任何引用的 Optional 实例。 |
2 |
abstract Set<T> asSet() 如果存在,则返回一个包含包含实例的不可变单例 Set(如果不存在,则返回一个不可变的空 Set)。 |
3 |
abstract boolean equals(Object object) 如果对象为 Optional 实例,并且包含的引用彼此相等,或者均不存在,则返回 true。 |
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 具有存在的值,则返回此 Optional;否则返回 secondChoice。 |
10 |
abstract T or(Supplier<? extends T> supplier) 如果存在,则返回包含的实例;否则返回 supplier.get()。 |
11 |
abstract T or(T defaultValue) 如果存在,则返回包含的实例;否则返回 defaultValue。 |
12 |
abstract T orNull() 如果存在,则返回包含的实例;否则返回 null。 |
13 |
static <T> Iterable<T> presentInstances(Iterable<? extends Optional<? extends T>> optionals) 按顺序返回所提供的可选项中每个存在实例的值,跳过 absent() 的出现。 |
14 |
abstract String toString() 返回此实例的字符串表示形式。 |
15 |
abstract <V> Optional<V> transform(Function<? super T,V> function) 如果存在该实例,则使用给定的 Function 对它进行转换;否则,返回 absent()。 |
Example of Optional Class
使用任意你选择的编辑器在 C:/> Guava. 中创建以下 Java 程序
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;
}
}
Guava - Preconditions Class
Precondition 提供静态方法来检查方法或构造函数是否使用正确的参数调用。它检查前提条件。其方法在失败时抛出 IllegalArgumentException。
Class Declaration
以下是 com.google.common.base.Preconditions 类的声明:
@GwtCompatible
public final class Preconditions
extends Object
Class Methods
Sr.No |
Method & Description |
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) 确保 index 指定数组、列表或大小字符串中的有效元素。 |
5 |
static int checkElementIndex(int index, int size, String desc) 确保 index 指定数组、列表或大小字符串中的有效元素。 |
6 |
static <T> T checkNotNull(T reference) 确保作为参数传递给调用方法的对象引用不为 null。 |
7 |
static <T> T checkNotNull(T reference, Object errorMessage) 确保作为参数传递给调用方法的对象引用不为 null。 |
8 |
static <T> T checkNotNull(T reference, String errorMessageTemplate, Object…​ errorMessageArgs) 确保作为参数传递给调用方法的对象引用不为 null。 |
9 |
static int checkPositionIndex(int index, int size) 确保 index 指定数组、列表或大小字符串中的有效位置。 |
10 |
static int checkPositionIndex(int index, int size, String desc) 确保 index 指定数组、列表或大小字符串中的有效位置。 |
11 |
static void checkPositionIndexes(int start, int end, int size) 确保 start 和 end 指定数组、列表或大小字符串中的有效位置,并且按顺序排列。 |
12 |
static void checkState(boolean expression) 确保涉及调用实例状态但没有涉及调用方法的任何参数的表达式的真实性。 |
13 |
static void checkState(boolean expression, Object errorMessage) 确保涉及调用实例状态但没有涉及调用方法的任何参数的表达式的真实性。 |
14 |
static void checkState(boolean expression, String errorMessageTemplate, Object…​ errorMessageArgs) 确保涉及调用实例状态但没有涉及调用方法的任何参数的表达式的真实性。 |
Example of Preconditions Class
使用任意你选择的编辑器在 C:/> Guava. 中创建以下 Java 程序
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;
}
}
Guava - Ordering Class
排序可以看作是具有增强的链式功能、多种实用方法、多类型排序功能等的增强型比较器。
Class Declaration
以下是 com.google.common.collect.Ordering<T> 类的声明 −
@GwtCompatible
public abstract class Ordering<T>
extends Object
implements Comparator<T>
Class Methods
Sr.No |
Method & Description |
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) 使用二分查找算法在 sortedList 中搜索 key。 |
4 |
abstract int compare(T left, T right) 比较其两个参数的顺序。 |
5 |
<U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator) 返回首先使用排序器 this,但在“相同”的情况下,然后委托给 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) 等效的 Ordering。 |
31 |
<E extends T> List<E> sortedCopy(Iterable<E> elements) 返回包含按此排序规则排序的元素的可变列表;仅在可能需要进一步修改结果列表或可能包含 null 时使用此列表。 |
32 |
static Ordering<Object> usingToString() 返回通过 toString() 返回的字符串表示的自然排序顺序比较对象的排序规则。 |
Example of Ordering Class
使用任意你选择的编辑器在 C:/> Guava. 中创建以下 Java 程序
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);
}
}
Verify the Result
按照如下方式使用 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 Class
Objects 类提供了适用于所有对象的辅助函数,例如 equals、hashCode 等。
Class Declaration
以下是 com.google.common.base.Objects 类的声明 -
@GwtCompatible
public final class Objects
extends Object
Class Methods
Sr.No |
Method & Description |
1 |
static boolean equal(Object a, Object b) 确定两个可能为 null 的对象是否相等。 |
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 月移除。 |
Example of Objects Class
使用任意你选择的编辑器在 C:/> Guava. 中创建以下 Java 程序
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;
}
}
Guava - Range Class
Range 表示一个区间或序列。它用于获取处在特定范围内的数字/字符串的集合。
Class Declaration
以下是 com.google.common.collect.Range<C> 类的声明 −
@GwtCompatible
public final class Range<C extends Comparable>
extends Object
implements Predicate<C>, Serializable
Methods
Sr.No |
Method & Description |
1 |
static <C extends Comparable<?>> Range<C> all() 返回包含 C 类型的所有值的范围。 |
2 |
boolean apply(C input)Deprecated. 仅提供以满足 Predicate 接口;改为使用 contains©。 |
3 |
static <C extends Comparable<?>> Range<C> atLeast(C endpoint) 返回包含大于或等于 endPoint 的所有值的范围。 |
4 |
static <C extends Comparable<?>> Range<C> atMost(C endpoint) 返回包含小于或等于 endPoint 的所有值的范围。 |
5 |
Range<C> canonical(DiscreteDomain<C> domain) 返回给定域中此范围的规范形式。 |
6 |
static <C extends Comparable<?>> Range<C> closed(C lower, C upper) 返回包含大于或等于 lower、且小于或等于 upper 的所有值的范围。 |
7 |
static <C extends Comparable<?>> Range<C> closedOpen(C lower, C upper) 返回包含大于或等于 lower、且严格小于 upper 的所有值的范围。 |
8 |
boolean contains(C value) 如果 value 在此范围的界限内,则返回 true。 |
9 |
boolean containsAll(Iterable<? extends C> values) 如果 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() 为该范围返回 hash 代码。 |
16 |
boolean hasLowerBound() 如果此范围具有较低端点,则返回 true。 |
17 |
boolean hasUpperBound() 如果此范围具有较高端点,则返回 true。 |
18 |
Range<C> intersection(Range<C> connectedRange) 如果存在这样的范围,则返回此范围和 connectedRange 共同包含的最大范围。 |
19 |
boolean isConnected(Range<C> other) 如果存在一个(可能为空)的范围同时包含在此范围和 other 范围内,则返回 true。 |
20 |
boolean isEmpty() 如果此范围处于 [v..v) 或 (v..v] 形式,则返回 true。 |
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) 返回一个到给定端点的无上限范围,它可以包含(CLOSED)或不包含(OPEN)上限。 |
Example of Range Class
使用任意你选择的编辑器在 C:/> Guava. 中创建以下 Java 程序
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("]");
}
}
Verify the Result
按照如下方式使用 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 Class
Throwable 类提供了与 Throwable 接口相关的实用方法。
Class Declaration
以下是 com.google.common.base.Throwables 类的声明 -
public final class Throwables
extends Object
Class Methods
Sr.No |
Method & Description |
1 |
static List<Throwable> getCausalChain(Throwable throwable) 获取 Throwable 原因链作为列表。 |
2 |
static Throwable getRootCause(Throwable throwable) 返回 Throwable 的最里层原因。 |
3 |
static String getStackTraceAsString(Throwable throwable) 返回一个字符串,其中包含 toString() 的结果,后跟 Throwable 的完整递归堆栈跟踪。 |
4 |
static RuntimeException propagate(Throwable throwable) 如果 Throwable 是 RuntimeException 或 Error 的实例,则按原样传播它,否则作为最后的手段,用 RuntimeException 包装它,然后传播它。 |
5 |
static <X extends Throwable> void propagateIfInstanceOf(Throwable throwable, Class<X> declaredType) 当且仅当 Throwable 是 declaredType 的实例时,才按原样传播 Throwable。 |
6 |
static void propagateIfPossible(Throwable throwable) 当且仅当 Throwable 是 RuntimeException 或 Error 的实例时,才按原样传播 Throwable。 |
7 |
static <X extends Throwable> void propagateIfPossible(Throwable throwable, Class<X> declaredType) 当且仅当 Throwable 是 RuntimeException、Error 或 declaredType 的实例时,才按原样传播 Throwable。 |
8 |
static <X1 extends Throwable,X2 extends Throwable>void propagateIfPossible(Throwable throwable, Class<X1> declaredType1, Class<X2> declaredType2) 当且仅当 Throwable 是 RuntimeException、Error、declaredType1 或 declaredType2 的实例时,才按原样传播 Throwable。 |
Example of Throwables Class
使用任意你选择的编辑器在 C:/> Guava. 中创建以下 Java 程序
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 {
}
Verify the Result
按照如下方式使用 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 - Caching Utilities
Guava 通过一个 LoadingCache<K,V> 接口提供了非常强大的基于内存的缓存机制。值会自动加载到缓存中,它提供了许多对缓存需求有用的实用方法。
Interface Declaration
以下是 com.google.common.cache.LoadingCache<K,V> 接口的声明:
@Beta
@GwtCompatible
public interface LoadingCache<K,V>
extends Cache<K,V>, Function<K,V>
Interface Methods
Sr.No |
Method & Description |
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) 加载键的新值,可能异步。 |
Example of LoadingCache
使用任意你选择的编辑器在 C:/> Guava. 中创建以下 Java 程序
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> 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>() { // 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> database = new HashMap<String, Employee>();
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();
}
}
Verify the Result
按照如下方式使用 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 - String Utilities
基于开发人员在应用开发中的经验,Guava 引入了许多高级字符串工具。下面列出了一些有用的基于字符串的工具:
Sr.No |
Utility name & Description |
1 |
Joiner 用于连接对象、字符串等的工具。 |
2 |
SplitterUtility to split string. |
3 |
CharMatcherUtility for character operations. |
4 |
CaseFormat 用于更改字符串格式的工具。 |
Guava - Primitive Utilities
由于 Java 的基本类型不能用在泛型或集合的输入中,Guava 提供了很多包装工具类来将基本类型处理成对象。以下列出一些有用的基本处理工具:
Sr.No |
Utility name & Description |
1 |
BytesUtility for primitive byte. |
2 |
ShortsUtility for primitive short. |
3 |
IntsUtility for primitive int. |
4 |
LongsUtility for primitive long. |
5 |
FloatsUtility for primitive float. |
6 |
DoublesUtility for primitive double. |
7 |
CharsUtility for primitive char. |
8 |
BooleansUtility for primitive boolean. |
Guava - Math Utilities
Guava 提供与数学相关的实用程序类,用于处理 int、long 和 BigInteger。以下是有用的实用程序列表 -
Sr.No |
Utility name & Description |
1 |
IntMathMath utility for int. |
2 |
LongMathMath utility for long. |
3 |
BigIntegerMathMath utility for BigInteger. |