番石榴 - 快速指南

---

番石榴 - 概述

什么是番石榴？

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 文件夹中。

设置Guava环境

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

设置 CLASSPATH 变量

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

番石榴 - 可选课程

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

类别声明

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

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

类方法

继承的方法

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

• 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

类方法

继承的方法

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

• 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>

类方法

继承的方法

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

• 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

类方法

继承的方法

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

• 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

方法

继承的方法

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

• 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

类方法

继承的方法

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

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

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>

接口方法

加载缓存示例

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

Guava - 原始实用程序

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

Guava - 数学实用工具

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