番石榴 - 快速指南


番石榴 - 概述

什么是番石榴?

Guava 是一个基于 Java 的开源库,包含 Google 的许多核心库,这些库正在他们的许多项目中使用。它促进最佳编码实践并有助于减少编码错误。它提供了用于集合、缓存、原语支持、并发、通用注释、字符串处理、I/O 和验证的实用方法。

番石榴的好处

  • 标准化- Guava 库由 Google 管理。

  • 高效- 它是 Java 标准库的可靠、快速且高效的扩展。

  • 优化- 该库经过高度优化。

  • 函数式编程- 它为 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。

为了避免上述问题的发生,需要对每一个存在问题的地方进行无效检查。

我们来看看如何使用Guava提供的Utility类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)

让我们了解一下上面程序的重要概念。

  • 可选- 实用程序类,使代码正确使用 null。

  • Optional.of - 它返回用作参数的Optional类的实例。它检查传递的值,而不是“null”。

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

使用Optional类,您可以检查调用者方法是否传递了正确的参数。

Guava - 环境设置

本地环境设置

如果您仍然愿意为 Java 编程语言设置环境,那么本节将指导您如何在计算机上下载和设置 Java。请按照以下步骤设置环境。

Java SE 可以通过下载 Java链接免费获得。因此,您可以根据您的操作系统下载一个版本。

按照说明下载 Java 并运行 .exe在您的计算机上安装 Java。在计算机上安装 Java 后,您需要设置环境变量以指向正确的安装目录 -

设置 Windows 2000/XP 的路径

我们假设您已将 Java 安装在c:\Program Files\java\jdk目录中 -

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

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

  • 现在,更改“Path”变量,使其也包含 Java 可执行文件的路径。例如,如果路径当前设置为“C:\WINDOWS\SYSTEM32”,则将路径更改为“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。

设置 Windows 95/98/ME 的路径

我们假设您已将 Java 安装在c:\Program Files\java\jdk目录中 -

  • 编辑 '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 编辑器

要编写 Java 程序,您需要一个文本编辑器。市场上有许多复杂的 IDE。但现在,您可以考虑以下其中一项 -

  • 记事本- 在 Windows 计算机上,您可以使用任何简单的文本编辑器,例如记事本(本教程推荐)、TextPad。

  • Netbeans - 它是一个开源且免费的 Java IDE,可以从https://www.netbeans.org/index.html下载。

  • Eclipse - 它也是由 eclipse 开源社区开发的 Java IDE,可以从https://www.eclipse.org/下载。

下载番石榴档案

从guava-18.0.jar下载最新版本的 Guava jar 文件。在编写本教程时,我们已经下载了guava-18.0.jar并将其复制到 C:\>Guava 文件夹中。

操作系统 档案名称
Windows 番石榴-18.0.jar
Linux 番石榴-18.0.jar
苹果 番石榴-18.0.jar

设置Guava环境

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

操作系统 输出
Windows 设置环境变量 Guava_HOME 为 C:\Guava
Linux 导出 Guava_HOME=/usr/local/Guava
苹果 导出 Guava_HOME=/Library/Guava

设置 CLASSPATH 变量

设置CLASSPATH环境变量以指向 Guava jar 位置。假设您已将 guava-18.0.jar 存储在各种操作系统上的 Guava 文件夹中,如下所示。

操作系统 输出
Windows 设置环境变量CLASSPATH为%CLASSPATH%;%Guava_HOME%\guava-18.0.jar;.;
Linux 导出 CLASSPATH=$CLASSPATH:$Guava_HOME/guava-18.0.jar:.
苹果 导出 CLASSPATH=$CLASSPATH:$Guava_HOME/guava-18.0.jar:.

番石榴 - 可选课程

Optional 是一个不可变对象,用于包含非空对象。可选对象用于表示缺少值的 null。此类具有各种实用方法,可帮助代码将值处理为可用或不可用,而不是检查空值。

类别声明

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

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

类方法

先生编号 方法及说明
1

静态 <T> 可选 <T> 缺席()

返回一个不包含引用的可选实例。

2

抽象 Set<T> asSet()

返回一个不可变的单例 Set,其唯一元素是包含的实例(如果存在);否则是一个空的不可变 Set。

3

抽象布尔等于(对象对象)

如果 object 是可选实例,并且所包含的引用彼此相等或两者都不存在,则返回 true。

4

static <T> 可选 <T> fromNullable(T nullableReference)

如果 nullableReference 不为 null,则返回包含该引用的可选实例;否则返回absent()。

5

抽象 T get()

返回包含的实例,该实例必须存在。

6

抽象 int hashCode()

返回此实例的哈希码。

7

抽象布尔值 isPresent()

如果此持有者包含一个(非空)实例,则返回 true。

8

static <T> 可选<T> of(T 引用)

返回包含给定非空引用的可选实例。

9

抽象可选<T>或(可选<?扩展T>第二个选择)

如果存在值,则返回此可选;否则第二个选择。

10

抽象 T 或(供应商 <? 扩展 T> 供应商)

如果存在则返回包含的实例;否则供应商.get()。

11

抽象 T 或(T 默认值)

如果存在则返回包含的实例;否则为默认值。

12

抽象 T 或 Null()

如果存在则返回包含的实例;否则为 null。

13

static <T> Iterable<T>presentInstances(Iterable<?extendsOptional<?extendsT>>可选)

按顺序从提供的选项中返回每个存在实例的值,跳过出现的absent()。

14

抽象字符串 toString()

返回此实例的字符串表示形式。

15

抽象 <V> 可选 <V> 转换(函数 <? super T,V> 函数)

如果实例存在,则使用给定的 Function 对其进行转换;否则,返回absent()。

继承的方法

该类继承了以下类的方法 -

  • java.lang.Object

可选类示例

使用您选择的任何编辑器(例如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;
   }	
}

验证结果

使用javac编译器编译该类,如下所示 -

C:\Guava>javac GuavaTester.java

现在运行 GuavaTester 查看结果。

C:\Guava>java GuavaTester

查看结果。

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

Guava - 先决条件类

前置条件提供静态方法来检查是否使用正确的参数调用方法或构造函数。它检查先决条件。它的方法在失败时抛出 IllegalArgumentException。

类别声明

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

@GwtCompatible
public final class Preconditions
   extends Object

类方法

先生编号 方法及说明
1

static void checkArgument(布尔表达式)

确保涉及调用方法的一个或多个参数的表达式的真实性。

2

static void checkArgument(布尔表达式,对象错误消息)

确保涉及调用方法的一个或多个参数的表达式的真实性。

3

static void checkArgument(布尔表达式, String errorMessageTemplate, Object.errorMessageArgs)

确保涉及调用方法的一个或多个参数的表达式的真实性。

4

静态 int checkElementIndex(int 索引, int 大小)

确保索引指定数组、列表或大小字符串中的有效元素。

5

static int checkElementIndex(int 索引, int 大小, String desc)

确保索引指定数组、列表或大小字符串中的有效元素。

6

静态 <T> T checkNotNull(T 引用)

确保作为参数传递给调用方法的对象引用不为 null。

7

static <T> T checkNotNull(T 引用,对象 errorMessage)

确保作为参数传递给调用方法的对象引用不为 null。

8

static <T> T checkNotNull(T 引用,字符串 errorMessageTemplate,对象... errorMessageArgs)

确保作为参数传递给调用方法的对象引用不为 null。

9

静态 int checkPositionIndex(int 索引, int 大小)

确保索引指定数组、列表或大小字符串中的有效位置。

10

static int checkPositionIndex(int 索引, int 大小, String desc)

确保索引指定数组、列表或大小字符串中的有效位置。

11

静态无效 checkPositionIndexes(int 开始,int 结束,int 大小)

确保 start 和 end 指定数组、列表或大小字符串中的有效位置,并且按顺序排列。

12

静态无效 checkState(布尔表达式)

确保涉及调用实例状态的表达式的真实性,但不涉及调用方法的任何参数。

13

static void checkState(布尔表达式, 对象错误消息)

确保涉及调用实例状态的表达式的真实性,但不涉及调用方法的任何参数。

14

static void checkState(布尔表达式,字符串 errorMessageTemplate,对象... errorMessageArgs)

确保涉及调用实例状态的表达式的真实性,但不涉及调用方法的任何参数。

继承的方法

该类继承了以下类的方法 -

  • java.lang.Object

先决条件类示例

使用您选择的任何编辑器(例如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;
   }
}

验证结果

使用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)

番石榴 - 订购类

排序可以看作是一个丰富的比较器,具有增强的链接功能、多种实用方法、多类型排序能力等。

类别声明

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

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

类方法

先生编号 方法及说明
1

静态排序<Object> allEqual()

返回将所有值视为相等的排序,表示“无排序”。将此排序传递给任何稳定的排序算法不会导致元素顺序发生变化。

2

静态排序<Object>任意()

返回所有对象的任意顺序,其中compare(a, b) == 0 意味着a == b(身份相等)。

3

int binarySearch(List<?extendsT>sortedList,Tkey)

使用二分搜索算法在排序列表中搜索键。

4

抽象 int 比较(T 左,T 右)

比较其两个参数的顺序。

5

<U extends T> 排序<U> 复合(Comparator<? super U> secondaryComparator)

返回一个排序,它首先使用排序 this,但如果出现“平局”,则委托给 secondaryComparator。

6

static <T> Ordering<T> 复合(Iterable<? extends Comparator<? super T>> 比较器)

返回一个排序,该排序按顺序尝试每个给定的比较器,直到找到非零结果,返回该结果,并且仅当所有比较器返回零时才返回零。

7

静态 <T> 排序 <T> 显式(List<T> valueInOrder)

返回一个排序,该排序根据对象在给定列表中出现的顺序进行比较。

8

静态 <T> 排序 <T> 显式(T 最小值,T...剩余值InOrder)

返回一个排序,该排序根据对象提供给此方法的顺序进行比较。

9

static <T> Ordering<T> from(Comparator<T> 比较器)

返回基于现有比较器实例的排序。

10

<E 扩展 T> List<E> GreatOf(Iterable<E> iterable, int k)

根据此排序,按从最大到最小的顺序返回给定可迭代的 k 个最大元素。

11

<E 扩展 T> List<E> GreatOf(Iterator<E> 迭代器, int k)

根据此排序,按从最大到最小的顺序返回给定迭代器中的 k 个最大元素。

12

<E 扩展 T> ImmutableList<E> immutableSortedCopy(Iterable<E> 元素)

返回一个不可变列表,其中包含按此顺序排序的元素。

13

boolean isOrdered(Iterable<? extends T> iterable)

根据此顺序,如果 iterable 中第一个元素之后的每个元素都大于或等于它前面的元素,则返回 true。

14

boolean isStrictlyOrdered(Iterable<? extends T> iterable)

如果 iterable 中第一个元素之后的每个元素严格大于其前面的元素(根据此顺序),则返回 true

15

<E 扩展 T> List<E> lessOf(Iterable<E> iterable, int k)

根据此排序(从最小到最大的顺序)返回给定可迭代的 k 个最小元素。

16

<E 扩展 T> List<E> lessOf(Iterator<E> elements, int k)

根据此顺序,按从最小到最大的顺序返回给定迭代器中的 k 个最小元素。

17 号

<S 扩展 T> 排序 <Iterable<S>> 字典序()

返回一个新的排序,它通过成对比较相应的元素来对可迭代对象进行排序,直到找到非零结果;强加“字典顺序”。

18

<E 扩展 T> E max(E a, E b)

根据此顺序返回两个值中较大的一个。

19

<E 扩展 T> E max(E a, E b, E c, E... 其余)

根据此顺序返回指定值中的最大值。

20

<E 扩展 T> E max(Iterable<E> 可迭代)

根据此顺序返回指定值中的最大值。

21

<E 扩展 T> E max(Iterator<E> 迭代器)

根据此顺序返回指定值中的最大值。

22

<E 扩展 T> E min(E a, E b)

根据此顺序返回两个值中较小的一个。

23

<E 扩展 T> E min(E a, E b, E c, E... 其余)

根据此顺序返回指定值中的最小值。

24

<E 扩展 T> E min(Iterable<E> 可迭代)

根据此顺序返回指定值中的最小值。

25

<E 扩展 T> E min(Iterator<E> 迭代器)

根据此顺序返回指定值中的最小值。

26

static <C extends Comparable> Ordering<C> natural()

返回使用值的自然顺序的可序列化顺序。

27

<S 扩展 T> 排序 <S> nullsFirst()

返回一个排序,该排序将 null 视为小于所有其他值,并使用它来比较非 null 值。

28

<S 扩展 T> 排序 <S> nullsLast()

返回将 null 视为大于所有其他值的排序,并使用此排序来比较非 null 值。

29

<F> Ordering<F> onResultOf(Function<F,? extends T> function)

返回 F 上的新排序,它通过首先对元素应用函数来对元素进行排序,然后使用它比较这些结果。

30

<S 扩展 T> 排序 <S> 反向()

返回此顺序的相反顺序;Ordering 相当于 Collections.reverseOrder(Comparator)。

31

<E 扩展 T> List<E>sortedCopy(Iterable<E> 元素)

返回一个可变列表,其中包含按此顺序排序的元素;仅当结果列表可能需要进一步修改或可能包含 null 时才使用此选项。

32

静态排序 <Object> usingToString()

返回一个排序,该排序按照 toString() 返回的字符串表示形式的自然顺序来比较对象。

继承的方法

该类继承了以下类的方法 -

  • java.lang.Object

订购类别示例

使用您选择的任何编辑器(例如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);
   }
}

验证结果

使用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 类提供了适用于所有对象的辅助函数,例如 equals、hashCode 等。

类别声明

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

@GwtCompatible
public final class Objects
   extends Object

类方法

先生编号 方法及说明
1

静态布尔等于(对象a,对象b)

确定两个可能为 null 的对象是否相等。

2

static <T> T firstNonNull(T 第一, T 第二)

已弃用。请改用 MoreObjects.firstNonNull(T, T)。此方法计划于 2016 年 6 月删除。

3

静态 int hashCode(对象...对象)

为多个值生成哈希码。

4

静态 Objects.ToStringHelper toStringHelper(Class<?> clazz)

已弃用。请改用 MoreObjects.toStringHelper(Class)。此方法计划于 2016 年 6 月删除

5

静态 Objects.ToStringHelper toStringHelper(Object self)

已弃用。请改用 MoreObjects.toStringHelper(Object)。此方法计划于 2016 年 6 月删除。

6

静态 Objects.ToStringHelper toStringHelper(String className)

已弃用。请改用 MoreObjects.toStringHelper(String)。此方法计划于 2016 年 6 月删除。

继承的方法

该类继承了以下类的方法 -

  • java.lang.Object

对象类示例

使用您选择的任何编辑器(例如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;
   }
}

验证结果

使用javac编译器编译该类,如下所示 -

C:\Guava>javac GuavaTester.java

现在运行 GuavaTester 查看结果。

C:\Guava>java GuavaTester

查看结果。

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

番石榴 - 范围级

范围表示一个区间或一个序列。它用于获取位于特定范围内的一组数字/字符串。

类别声明

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

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

方法

先生编号 方法及说明
1

static <C extends Comparable<?>> Range<C> all()

返回包含 C 类型的每个值的范围。

2

boolean apply(C input) 已弃用。

仅为满足 Predicate 接口而提供;使用 contains(C) 代替。

3

static <C extends Comparable<?>> Range<C> atLeast(C 端点)

返回包含大于或等于端点的所有值的范围。

4

static <C extends Comparable<?>> Range<C> atMost(C 端点)

返回包含小于或等于端点的所有值的范围。

5

范围<C>规范(DiscreteDomain<C>域)

返回给定域中该范围的规范形式。

6

static <C extends Comparable<?>> Range<C> close(C lower, C upper)

返回一个范围,其中包含大于或等于 lower 且小于或等于 upper 的所有值。

7

static <C extends Comparable<?>> Range<C> closeOpen(C lower, C upper)

返回一个范围,其中包含大于或等于 lower 且严格小于 upper 的所有值。

8

布尔值包含(C 值)

如果值在此范围内,则返回 true。

9

boolean containsAll(Iterable<? extends C> 值)

如果 value 中的每个元素都包含在此范围内,则返回 true。

10

static <C extends Comparable<?>> Range<C> downTo(C 端点,BoundTypeboundType)

返回给定端点的范围,该范围可以是包含(封闭)或排除(开放)的,没有上限。

11

static <C extends Comparable<?>> Range<C> encloseAll(Iterable<C> 值)

返回包含所有给定值的最小范围。

12

布尔值包含(范围 <C> 其他)

如果 other 的边界未超出此范围的边界,则返回 true。

13

布尔值等于(对象对象)

如果 object 是与此范围具有相同端点和绑定类型的范围,则返回 true。

14

static <C extends Comparable<?>> Range<C>greaterThan(C 端点)

返回一个范围,其中包含严格大于端点的所有值。

15

int 哈希码()

返回此范围的哈希码。

16

布尔值 h​​asLowerBound()

如果此范围有下端点,则返回 true。

17 号

布尔值 h​​asUpperBound()

如果此范围有上限,则返回 true。

18

范围<C>交集(范围<C>连接范围)

返回此范围和connectedRange 所包围的最大范围(如果存在这样的范围)。

19

布尔 isConnected(范围 <C> 其他)

如果存在一个(可能为空)范围被此范围和其他范围包围,则返回 true。

20

布尔值 isEmpty()

如果此范围的形式为 [v..v) 或 (v..v],则返回 true。

21

static <C extends Comparable<?>> Range<C> lessThan(C 端点)

返回一个范围,其中包含严格小于端点的所有值。

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)

返回包含从下到上的任何值的范围,其中每个端点可以是包含(封闭)或排除(开放)的。

27

static <C extends Comparable<?>> Range<C> 单例(C 值)

返回仅包含给定值的范围。

28

范围<C>跨度(范围<C>其他)

返回包含此范围和其他范围的最小范围。

29

字符串转字符串()

返回此范围的字符串表示形式,例如“[3..5)”(其他示例在类文档中列出)。

30

BoundType upperBoundType()

返回此范围上限的类型:如果范围包含其上端点,则返回 BoundType.CLOSED;如果不包含,则返回 BoundType.OPEN。

31

C 上端点()

返回此范围的上端点。

32

static <C extends Comparable<?>> Range<C> upTo(C 端点,BoundTypeboundType)

返回一个范围,直到给定端点为止没有下限,该端点可以是包含(封闭)或排除(开放)的。

继承的方法

该类继承了以下类的方法 -

  • java.lang.Object

范围类示例

使用您选择的任何编辑器(例如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("]");
   }
}

验证结果

使用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 类

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

类别声明

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

public final class Throwables
   extends Object

类方法

先生编号 方法及说明
1

static List<Throwable> getCausalChain(Throwable throwable)

获取 Throwable 原因链作为列表。

2

静态 Throwable getRootCause(Throwable throwable)

返回 throwable 的最内部原因。

3

静态字符串 getStackTraceAsString(Throwable throwable)

返回一个包含 toString() 结果的字符串,后跟 throwable 的完整递归堆栈跟踪。

4

静态 RuntimeException 传播(Throwable 抛出)

如果 throwable 是 RuntimeException 或 Error 的实例,则按原样传播,否则作为最后的手段,将其包装在 RuntimeException 中然后传播。

5

static <X extends Throwable> void spreadIfInstanceOf(Throwable throwable, Class<X>clarifiedType)

当且仅当它是声明类型的实例时,才按原样传播 throwable。

6

静态无效传播IfPossible(Throwable throwable)

当且仅当它是 RuntimeException 或 Error 的实例时,才按原样传播 throwable。

7

static <X extends Throwable> void spreadIfPossible(Throwable throwable, Class<X>clarifiedType)

当且仅当它是 RuntimeException、Error 或 declaredType 的实例时,才按原样传播 throwable。

8

static <X1 扩展 Throwable,X2 扩展 Throwable>voidpropagateIfPossible(Throwable throwable,Class<X1> 声明类型 1,Class<X2> 声明类型 2)

当且仅当它是 RuntimeException、Error、declaredType1 或 declaredType2 的实例时,才按原样传播 throwable。

继承的方法

该类继承了以下类的方法 -

  • java.lang.Object

Throwables 类的示例

使用您选择的任何编辑器(例如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 {
}

验证结果

使用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根据开发者在应用程序开发工作中的经验推出了许多高级集合。下面给出了有用集合的列表 -

先生编号 集合名称和描述
1 多集

Set 接口的扩展以允许重复元素。

2 多图

Map 接口的扩展,以便其键可以一次映射到多个值。

3 双图

Map 接口的扩展,支持逆运算。

4 桌子

表表示一个特殊的映射,其中可以以组合方式指定两个键来引用单个值。

Guava - 缓存实用程序

Guava 通过接口 LoadingCache<K,V> 提供了非常强大的基于内存的缓存机制。值会自动加载到缓存中,并且它提供了许多可满足缓存需求的实用方法。

接口声明

以下是com.google.common.cache.LoadingCache<K,V>接口的声明-

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

接口方法

先生编号 方法及说明
1

V 应用(K 键)

已弃用。提供以满足Function接口;请改用 get(K) 或 getUnchecked(K)。

2

ConcurrentMap<K,V> asMap()

以线程安全映射的形式返回存储在此缓存中的条目的视图。

3

V 获取(K 键)

返回与此缓存中的键关联的值,如有必要,首先加载该值。

4

ImmutableMap<K,V> getAll(Iterable<? 扩展 K> 键)

返回与键关联的值的映射,并在必要时创建或检索这些值。

5

V getUnchecked(K 键)

返回与此缓存中的键关联的值,如有必要,首先加载该值。

6

无效刷新(K键)

为键加载新值,可能是异步的。

加载缓存示例

使用您选择的任何编辑器(例如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();
   }	
}

验证结果

使用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 根据开发人员在应用程序开发工作中的经验引入了许多高级字符串实用程序。以下是有用的基于字符串的实用程序的列表 -

先生编号 实用程序名称和说明
1 细木工

连接对象、字符串等的实用程序。

2 分路器

分割字符串的实用程序。

3 字符匹配器

用于字符操作的实用程序。

4 案例格式

用于更改字符串格式的实用程序。

Guava - 原始实用程序

由于 Java 的原始类型不能用于传入泛型或集合作为输入,Guava 提供了许多 Wrapper Utilities 类来将原始类型作为对象处理。以下是有用的原始处理实用程序的列表 -

先生编号 实用程序名称和说明
1 字节

原始字节的实用程序。

2 短裤

原始短的实用程序。

3 整数

原始 int 的实用程序。

4 长头

原始长的实用程序。

5 花车

原始浮动的实用程序。

6 双打

原始双精度的实用程序。

7 字符

原始字符的实用程序。

8 布尔值

原始布尔值的实用程序。

Guava - 数学实用工具

Guava 提供了数学相关的实用程序类来处理 int、long 和 BigInteger。以下是有用的实用程序列表 -

先生编号 实用程序名称和说明
1 综合数学

int 的数学实用程序。

2 长算术

数学实用性很长。

3 大整数数学

BigInteger 的数学实用程序。