Guava - 快速指南
Guava - Overview
什么是Guava？
Guava是一个基于Java的开源库，包含许多Google核心库，这些库正在许多项目中使用。 它有助于最佳编码实践，并有助于减少编码错误。 它为集合，缓存，基元支持，并发，通用注释，字符串处理，I/O和验证提供实用程序方法。
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（）不会处理任何要传递为null的参数。
调用函数也不担心无意中将null传递给sum（）方法。
程序运行时，会发生NullPointerException。
为了避免上述问题，应在存在这些问题的每个地方进行空检查。
让我们看看使用Prote，一个Guava提供的Utility类，以标准化的方式解决上述问题。
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 - Environment Setup
本地环境设置 (Local Environment Setup)
如果您仍然愿意为Java编程语言设置环境，那么本节将指导您如何在计算机上下载和设置Java。 请按照下面提到的步骤设置环境。
Java SE可从链接Download Java免费获得。 因此，您下载基于您的操作系统的版本。
按照说明下载Java并运行.exe以在您的计算机上安装Java。 在计算机上安装Java后，需要设置环境变量以指向正确的安装目录 -
设置Windows 2000/XP的路径
我们假设您已在c:\Program Files\java\jdk目录中安装了Java -
右键单击“我的电脑”，然后选择“属性”。
单击“高级”选项卡下的“环境变量”按钮。
现在，更改'Path'变量，使其也包含Java可执行文件的路径。 例如，如果路径当前设置为“C:\WINDOWS\SYSTEM32”，则将路径更改为“C:\WINDOWS\SYSTEM32; c:\Program Files\java\jdk\bin”。
设置Windows 95/98/ME的路径
我们假设您已在c:\Program Files\java\jdk目录中安装了Java -
编辑'C:\autoexec.bat'文件并在末尾添加以下行 - 'SET PATH =％PATH％; C:\Program Files\java\jdk\bin'
设置Linux，UNIX，Solaris，FreeBSD的路径
应将环境变量PATH设置为指向已安装Java二进制文件的位置。 如果您在执行此操作时遇到问题，请参阅您的shell文档。
例如，如果你使用bash作为shell，那么你可以将以下行添加到'.bashrc的末尾:export PATH =/path/to/java:$ PATH'
流行的Java编辑器 (Popular Java Editors)
要编写Java程序，需要一个文本编辑器。 市场上有许多复杂的IDE。 但就目前而言，您可以考虑以下其中一项 -
Notepad - 在Windows机器上，您可以使用任何简单的文本编辑器，如记事本（本教程推荐），TextPad。
Netbeans - 它是一个开源和免费的Java IDE，可以从https://www.netbeans.org/index.html下载。
Eclipse - 它也是由eclipse开源社区开发的Java IDE，可以从https://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文件夹中提取了guava-18.0.jar，如下所示。
| 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
可选是用于包含非null对象的不可变对象。 可选对象用于表示缺少值的null。 此类具有各种实用程序方法，以便于代码处理可用或不可用的值，而不是检查空值。
Class 声明 (Class Declaration)
以下是com.google.common.base.Optional《T》类的声明 -
@GwtCompatible(serializable = true)
public abstract class Optional<T>
extends Object
implements Serializable
Class Methods
| Sr.No | 方法和描述 |
|---|---|
| 1 | static 《T》 Optional《T》 absent() 返回没有包含引用的Optional实例。 |
| 2 | abstract Set《T》 asSet() 返回一个不可变的单例集，其唯一元素是包含的实例（如果存在）; 否则为空的不可变Set。 |
| 3 | abstract boolean equals(Object object) 如果object是Optional实例，并且包含的引用彼此相等或两者都不存在，则返回true。 |
| 4 | static 《T》 Optional《T》 fromNullable(T nullableReference) 如果nullableReference为非null，则返回包含该引用的Optional实例; 否则返回缺席（）。 |
| 5 | abstract T get() 返回必须存在的包含实例。 |
| 6 | abstract int hashCode() 返回此实例的哈希码。 |
| 7 | abstract boolean isPresent() 如果此holder包含（非null）实例，则返回true。 |
| 8 | static 《T》 Optional《T》 of(T reference) 返回包含给定非null引用的Optional实例。 |
| 9 | abstract Optional《T》 or(Optional《? extends T》 secondChoice) 如果存在值，则返回此Optional; 第二个选择。 |
| 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) 如果实例存在，则使用给定的函数进行转换; 否则，返回absent（）。 |
方法继承 (Methods Inherited)
该类继承以下类中的方法 -
- java.lang.Object
可选类的示例
使用您选择的任何编辑器在C:/》 Guava.创建以下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 Class
前提条件提供静态方法来检查是否使用适当的参数调用方法或构造函数。 它检查前提条件。 它的方法在失败时抛出IllegalArgumentException。
Class 声明 (Class Declaration)
以下是com.google.common.base.Preconditions类的声明 -
@GwtCompatible
public final class Preconditions
extends Object
Class Methods
| Sr.No | 方法和描述 |
|---|---|
| 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) 确保作为参数传递给调用方法的对象引用不为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) 确保索引指定数组，列表或大小字符串中的有效位置。 |
| 10 | static int checkPositionIndex(int index, int size, String desc) 确保索引指定数组，列表或大小字符串中的有效位置。 |
| 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) 确保涉及调用实例状态的表达式的真实性，但不涉及调用方法的任何参数。 |
方法继承 (Methods Inherited)
该类继承以下类中的方法 -
- java.lang.Object
前提条件类的示例
使用您选择的任何编辑器在C:/》 Guava.创建以下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 Class
订购可以看作是一个丰富的比较器，具有增强的链接功能，多种实用方法，多种类型的排序功能等。
Class 声明 (Class Declaration)
以下是com.google.common.collect.Ordering《T》类的声明 -
@GwtCompatible
public abstract class Ordering<T>
extends Object
implements Comparator<T>
Class Methods
| Sr.No | 方法和描述 |
|---|---|
| 1 | static Ordering《Object》 allEqual() 返回将所有值视为相等的排序，表示“无排序”。 将此排序传递给任何稳定排序算法都不会导致元素顺序发生变化。 |
| 2 | static Ordering《Object》 arbitrary() 返回所有对象的任意排序，比较（a，b）== 0表示== b（标识相等）。 |
| 3 | int binarySearch(List《? extends T》 sortedList, T key) 使用二进制搜索算法在sortedList中搜索密钥。 |
| 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) 根据此顺序返回给定iterable的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) 根据此顺序返回给定iterable的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（）返回的字符串表示的自然顺序来比较对象。 |
方法继承 (Methods Inherited)
该类继承以下类中的方法 -
- java.lang.Object
订购类示例
使用您选择的任何编辑器在C:/》 Guava.创建以下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 Class
Objects类提供适用于所有对象的辅助函数，例如equals，hashCode等。
Class 声明 (Class Declaration)
以下是com.google.common.base.Objects类的声明 -
@GwtCompatible
public final class Objects
extends Object
Class Methods
| Sr.No | 方法和描述 |
|---|---|
| 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月删除。 |
方法继承 (Methods Inherited)
该类继承以下类中的方法 -
- java.lang.Object
对象类的示例
使用您选择的任何编辑器在C:/》 Guava.创建以下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 Class
范围表示间隔或序列。 它用于获取位于特定范围内的一组数字/字符串。
Class 声明 (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 | 方法和描述 |
|---|---|
| 1 | static 《C extends Comparable《?》》 Range《C》 all() 返回包含C类型的每个值的范围。 |
| 2 | boolean apply(C input)Deprecated. 仅提供满足Predicate接口; 使用contains（C）代替。 |
| 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) 如果值中的每个元素都包含在此范围内，则返回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) 如果object是具有与此范围相同的端点和绑定类型的范围，则返回true。 |
| 14 | static 《C extends Comparable《?》》 Range《C》 greaterThan(C endpoint) 返回包含严格大于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() 如果此范围的格式为[v..v]或（v..v），则返回true。 |
| 21 | static 《C extends Comparable《?》》 Range《C》 lessThan(C endpoint) 返回包含严格小于endpoint的所有值的范围。 |
| 22 | BoundType lowerBoundType() 返回此范围下限的类型:BoundType.CLOSED如果范围包括其下端点，则为BoundType.OPEN（如果不包括）。 |
| 23 | C lowerEndpoint() 返回此范围的下端点。 |
| 24 | static 《C extends Comparable《?》》 Range《C》 open(C lower, C upper) 返回一个范围，其中包含严格大于lower且严格小于upper的所有值。 |
| 25 | static 《C extends Comparable《?》》 Range《C》 openClosed(C lower, C upper) 返回一个范围，其中包含严格大于lower且小于或等于upper的所有值。 |
| 26 | static 《C extends Comparable《?》》 Range《C》 range(C lower, BoundType lowerType, C upper, BoundType upperType) 返回包含从lower到upper的任何值的范围，其中每个端点可以是包含（闭合）或独占（打开）。 |
| 27 | static 《C extends Comparable《?》》 Range《C》 singleton(C value) 返回仅包含给定值的范围。 |
| 28 | Range《C》 span(Range《C》 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) 返回一个没有下限到达给定端点的范围，该范围可以是包含（闭合）或独占（打开）。 |
方法继承 (Methods Inherited)
该类继承以下类中的方法 -
- java.lang.Object
范围类的示例
使用您选择的任何编辑器在C:/》 Guava.创建以下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 Class
Throwables类提供与Throwable接口相关的实用程序方法。
Class 声明 (Class Declaration)
以下是com.google.common.base.Throwables类的声明 -
public final class Throwables
extends Object
Class Methods
| Sr.No | 方法和描述 |
|---|---|
| 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) 如果它是RuntimeException或Error的实例，则按原样传播throwable，或者作为最后的手段，将其包装在RuntimeException中然后传播。 |
| 5 | static 《X extends Throwable》 void propagateIfInstanceOf(Throwable throwable, Class《X》 declaredType) 当且仅当它是declaredType的实例时，传播完全按原样抛出。 |
| 6 | static void propagateIfPossible(Throwable throwable) 当且仅当它是RuntimeException或Error的实例时，才按原样传播throwable。 |
| 7 | static 《X extends Throwable》 void propagateIfPossible(Throwable throwable, Class《X》 declaredType) 当且仅当它是RuntimeException，Error或declaredType的实例时，才按原样传播throwable。 |
| 8 | static 《X1 extends Throwable,X2 extends Throwable》void propagateIfPossible(Throwable throwable, Class《X1》 declaredType1, Class《X2》 declaredType2) 当且仅当它是RuntimeException，Error，declaredType1或declaredType2的实例时，才按原样传播throwable。 |
方法继承 (Methods Inherited)
该类继承以下类中的方法 -
- java.lang.Object
Throwables类的例子
使用您选择的任何编辑器在C:/》 Guava.创建以下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 - Collections Utilities
Guava根据开发人员在应用程序开发工作中的经验介绍了许多高级集合。 下面给出了一个有用的集合列表 -
| Sr.No | 集合名称和描述 |
|---|---|
| 1 | Multiset Set接口的扩展，允许重复元素。 |
| 2 | Multimap Map接口的扩展，以便其键可以一次映射到多个值。 |
| 3 | BiMap Map接口的扩展，支持逆操作。 |
| 4 | Table 表表示一个特殊映射，其中可以以组合方式指定两个键以引用单个值。 |
Guava - Caching Utilities
Guava通过一个接口LoadingCache
接口声明 (Interface Declaration)
以下是com.google.common.cache.LoadingCache《K,V》界面的声明 -
@Beta
@GwtCompatible
public interface LoadingCache<K,V>
extends Cache<K,V>, Function<K,V>
接口方法
| Sr.No | 方法和描述 |
|---|---|
| 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示例
使用您选择的任何编辑器在C:/》 Guava.创建以下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> 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();
}
}
验证结果
使用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 | 实用程序名称和描述 |
|---|---|
| 1 | Joiner 连接对象，字符串等的实用程序 |
| 2 | Splitter 拆分字符串的实用程序 |
| 3 | CharMatcher 字符操作的实用程序。 |
| 4 | CaseFormat 更改字符串格式的实用程序 |
Guava - Primitive Utilities
由于原始类型的Java不能用于传递泛型或集合作为输入，因此Guava提供了许多Wrapper Utilities类来处理原始类型作为对象。 以下是有用的原始处理实用程序列表 -
| Sr.No | 实用程序名称和描述 |
|---|---|
| 1 | Bytes 原始字节的实用程序。 |
| 2 | Shorts 原始短期的效用。 |
| 3 | Ints 原始int的实用程序。 |
| 4 | Longs 原始长期的效用。 |
| 5 | Floats 原始浮动的效用。 |
| 6 | Doubles 原始双重的效用。 |
| 7 | Chars 原始字符的实用程序。 |
| 8 | Booleans 原始布尔值的实用程序。 |
Guava - Math Utilities
Guava提供数学相关的Utilities类来处理int，long和BigInteger。 以下是有用的实用程序列表 -
| Sr.No | 实用程序名称和描述 |
|---|---|
| 1 | IntMath int的数学实用程序。 |
| 2 | LongMath 数学实用程序很长。 |
| 3 | BigIntegerMath BigInteger的数学实用程序。 |
