JAVA面试题分享五百零一：深入盘点一下Guava的核心功能特性

目录

关于Guava

Guava有哪些核心功能？

如何开始使用这个类库呢？

Guava的集合工具梳理

Guava的字符处理工具

Guava的IO操作工具

Guava的并发编程工具

关于Guava的并发工具

Guava的并发工具盘点

Guava的并发工具如何使用

ListenableFuture

CountDownLatch

CyclicBarrier

---

关于Guava

Guava是一套开源的Java核心类库，由Google团队开发和维护。它提供了许多实用的工具和扩展类，旨在简化Java开发过程，并提高代码的可读性、可维护性和性能。Guava类库涵盖了各个领域，包括集合框架（如不可变集合、新的集合类型）、函数式编程支持、缓存、并发工具、字符串处理、IO操作等等。它的设计理念注重简洁、高效和易用性，提供了许多方便的工具方法和功能，可以帮助开发人员更轻松地完成各类任务。无论是在大规模分布式系统还是小型应用程序中，Guava类库都展现了强大的实用性和可靠性。如果你想寻找一个功能全面、可靠稳定的Java类库，Guava绝对是一个很好的选择。

Guava有哪些核心功能？

Guava类库提供了许多核心功能，下面是其中一些主要的功能：

1. 集合工具（Collections Utilities）：Guava提供了一系列强大的集合工具类，包括不可变集合、新的集合类型（如Multiset、Multimap等）、集合操作（如交集、差集、并集等）、集合过滤和转换等。

2. 字符串处理（String Utilities）：Guava提供了丰富的字符串操作工具，包括字符集处理、字符串分割、连接、填充、匹配器和拆分器等。同时还提供了针对URL、Base64编码等常见场景的工具方法。

3. IO操作（IO Utilities）：Guava提供了简化的IO操作工具，包括文件读写、流处理、字节处理、压缩解压缩等功能。它还提供了更高效的IO操作方式，如ByteStreams、CharStreams等。

4. 并发工具（Concurrency Utilities）：Guava提供了许多并发编程工具，例如ListenableFuture、RateLimiter、Monitor等。这些工具简化了并发编程的复杂性，提供了更安全、更高效的并发操作方式。

上述仅是Guava类库的一小部分核心功能，它还包含了许多其他实用工具和类。无论是在集合处理、字符串操作、IO操作还是并发编程等方面，Guava类库都提供了丰富、高效的功能，可以极大地简化Java开发过程。

如何开始使用这个类库呢？

在Maven工程中使用Guava类库，您需要引入以下依赖项：

<dependency>    <groupId>com.google.guava</groupId>    <artifactId>guava</artifactId>    <version>32.1.3-jre</version></dependency>

Guava的集合工具梳理

1. Collections2：对Collection对象进行操作的工具方法。

2. Iterables：对Iterable对象进行操作的工具方法。

3. Lists：对List对象进行操作的工具方法。

4. Maps：对Map对象进行操作的工具方法。

5. Sets：对Set对象进行操作的工具方法。

6. ImmutableList：不可变列表。

7. ImmutableSet：不可变集合。

8. ImmutableMap：不可变映射表。

9. Multiset：可重复元素的集合。

10. Multimap：一对多映射关系的数据结构。

11. BiMap：双向映射的数据结构。

12. Table：二维表格的数据结构。

13. RangeSet：连续区间的数据结构。

14. Iterators：对Iterator对象进行操作的工具方法。

15. Ordering：排序器，用于对集合进行排序。

16. Forwarding*：各种Forwarding类，用于扩展和包装其他集合类。

17. ClassToInstanceMap：将类与其实例关联起来的数据结构。

18. com.google.common.reflect.TypeToken：处理泛型类型擦除的工具类。

19. EvictingQueue：有限容量的队列，当超过容量限制时自动移除最老的元素。

20. ImmutableRangeSet：不可变的RangeSet，用于表示一段连续的数值范围。

21. RangeMap：将不相交的、不可数的连续区间映射到一个非空的值域的数据结构。

Guava的字符处理工具

1. Strings：包含了一些常用的字符串工具方法，例如判空、空字符串处理、填充字符串等。

2. Joiner：用于将多个字符串拼接成一个字符串，可以指定分隔符、前缀、后缀等。

3. Splitter：用于将字符串拆分为多个子串，支持指定分隔符、正则表达式、固定长度等方式。

4. CharMatcher：用于对字符进行匹配和操作的工具类，例如判断字符是否是字母、数字、空白字符等。

5. CaseFormat：用于不同命名风格之间的转换，例如驼峰式、下划线式、大写风格等。

6. Chars：提供了一些对char类型的操作方法，例如将char数组转换为字符串、判断字符是否在指定范围内等。

7. HtmlEscapers：用于对HTML字符串进行转义，防止XSS攻击。

8. Escaper：用于定义自定义的字符串转义规则，可以用于各种场景下的字符串转义。

9. CaseFormat：用于不同命名风格之间的转换，例如驼峰式、下划线式、大写风格等。

10. Ascii：提供了一些针对ASCII字符的常用操作方法，如大小写转换、字符判断等。

Guava的IO操作工具

1. ByteStreams：提供了操作字节流的工具方法，例如复制流、读取到字节数组、将字节数组写入流等。

2. CharStreams：提供了操作字符流的工具方法，例如将字符流转换为字符串、按行读取字符流等。

3. Files：提供了对文件进行操作的工具方法，例如复制文件、移动文件、删除文件等。

4. Resources：提供了加载资源文件的工具方法，例如加载类路径下的文件、URL资源等。

5. InputSupplier 和 OutputSupplier：提供了对输入流和输出流的封装，支持延迟创建流对象，方便资源管理。

6. LineProcessor：提供了处理文本行的接口，可以逐行处理大文本文件。

7. Closer：提供了关闭Closeable对象的工具类，用于确保资源的正确关闭。

8. FileWriteMode 和 FileReadMode：提供了文件写入和读取的模式设置，例如追加写入、覆盖写入等。

Guava的并发编程工具

1. ListenableFuture：是对Java原生Future的扩展，添加了异步回调的功能，可以在任务完成时触发回调操作。

2. Futures：提供了一系列静态方法，用于创建和组合ListenableFuture，例如转换、组合、异常处理等。

3. FutureCallback：定义了异步任务完成时的回调接口，可以自定义任务完成后的操作。

4. ThreadFactoryBuilder：用于创建线程工厂的构建器，可以设置线程名称、优先级、守护状态等属性。

5. MoreExecutors：提供了一些Executor的实现类，例如ListeningExecutorService、ScheduledExecutorService，以及一些便捷的工具方法。

6. RateLimiter：提供了限流的功能，可以控制任务执行的速率。

7. AtomicDouble：提供了原子操作的double类型，可以在多线程环境下安全地进行操作。

8. Monitor：提供了简单的监视器锁，可以用于多线程环境下的同步操作。

关于Guava的并发工具

Guava提供了一些丰富的并发工具，帮助开发者更好地处理并发编程中的问题。例如，Guava提供了ListenableFuture、CountDownLatch、CyclicBarrier等工具。这些工具对Java并发包（java.util.concurrent）进行了扩展，使其功能更强大，使用更方便。

具体来说，其中ListenableFuture是Guava对Java Future的扩展，它允许你注册回调函数，当Future的计算结果可用时，这个回调函数会被执行。CountDownLatch和CyclicBarrier则是用于同步的工具类，它们可以让一组线程等待彼此，然后再一起执行。

Guava的并发工具盘点

Guava提供的并发工具当然不仅仅只有ListenableFuture、CountDownLatch、CyclicBarrier等，还有很多其他的，博主这里算是抛砖引玉吧，把我用过的，我认为比较好用的，在这里给大家梳理总结一下，如果大家用到了其他更好用的，欢迎在评论区告诉，一起深入交流。那么本篇文章的主角就是ListenableFuture、CountDownLatch和CyclicBarrier，那么下面先简单的盘一下这几个类的功能特性：

• ListenableFuture：它是Guava对JDK的Future接口的扩展。相比于传统的Future，ListenableFuture允许你注册一个回调函数，一旦计算完成，这个回调函数就会被执行。这使得ListenableFuture在处理异步计算的结果时提供了更大的灵活性。

• CountDownLatch：这是Java中的一个并发工具类，用于协调多个线程之间的同步。CountDownLatch能够使一个线程等待其他线程完成各自的工作后再执行。例如，你可以使用CountDownLatch来确保在继续执行主线程之前，一组工作线程已经完成了它们的初始化工作。

• CyclicBarrier：这是Java中的一个同步工具类。CyclicBarrier可以让一组线程互相等待，直到所有线程都达到某个状态后再一起执行。这在并行计算中特别有用，例如，你可能想要在所有线程都完成了它们的一部分计算后，再进行一次汇总操作。CyclicBarrier可以确保所有线程都在同一时间点进行这个汇总操作。

环境配置

目前maven中央仓库的最新版本是32.1.3-jre，本篇文章的所有示例也是基于这个版本：

<dependency>    <groupId>com.google.guava</groupId>    <artifactId>guava</artifactId>    <version>32.1.3-jre</version></dependency>

Guava的并发工具如何使用

ListenableFuture

Guava类库的ListenableFuture是一个强大的工具，它扩展了Java的Future接口，增加了注册回调函数的功能。下面是一个使用Guava的ListenableFuture的示例：

public class ListenableFutureExample {    public static void main(String[] args) {        ExecutorService executorService = Executors.newSingleThreadExecutor();        ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(executorService);        ListenableFuture<String> future = listeningExecutorService.submit(new Callable<String>() {            @Override            public String call() throws Exception {                // 模拟异步任务                Thread.sleep(2000);                System.out.println(Thread.currentThread().getName() + ":异步任务执行完毕");                return "异步任务执行成功：success";            }        });        Futures.addCallback(future, new FutureCallback<String>() {            @Override            public void onSuccess(String result) {                // 异步任务执行成功后的回调方法                System.out.println(Thread.currentThread().getName() + ":异步任务执行成功，结果是：" + result);                listeningExecutorService.shutdown();//收到回调结果后，建议关注线程池，否则监听回调程序会一直阻塞，不会结束；            }            @Override            public void onFailure(Throwable t) {                // 异步任务执行失败后的回调方法                System.out.println("异步任务执行失败");                t.printStackTrace();            }        }, executorService);        System.out.println(Thread.currentThread().getName() + ":主线程继续执行其他任务...");    }}

在上面这个示例中，我们使用了Guava的ListeningExecutorService来创建一个线程池，并通过submit方法提交了一个异步任务。该异步任务模拟了一个耗时操作，等待2秒后返回结果。然后，我们使用Futures.addCallback方法为ListenableFuture对象注册了一个回调函数。当异步任务执行成功时，会调用onSuccess方法，并打印出异步任务的结果；当异步任务执行失败时，会调用onFailure方法，并打印出异常信息。最后，主线程继续执行其他任务。需要注意的是：在这里我关闭了线程池，否则监听回调程序会一直阻塞，不会结束；

CountDownLatch

在下面这个示例中，我们使用了Guava类库的Uninterruptibles.awaitUninterruptibly()方法来等待CountDownLatch的计数器变为0。这与使用Java标准库中的latch.await()方法类似，但Guava提供的方法能够更优雅地处理中断。其余部分与之前的示例相同，创建了多个工作线程，并使用CountDownLatch来协调它们的执行。当所有工作线程都调用latch.countDown()方法后，计数器将变为0，然后主线程通过Uninterruptibles.awaitUninterruptibly(latch)等待所有工作线程执行完毕，并输出"All worker threads have finished."。

public class GuavaCountDownLatchExample {    public static void main(String[] args) {        int numberOfThreads = 3;        CountDownLatch latch = new CountDownLatch(numberOfThreads);        for (int i = 0; i < numberOfThreads; i++) {            new Thread(new Worker(latch), "Thread" + i).start();        }        Uninterruptibles.awaitUninterruptibly(latch); // 使用Guava的Uninterruptibles类等待所有工作线程执行完毕        System.out.println("All worker threads have finished.");    }}
class Worker implements Runnable {    private final CountDownLatch latch;
    Worker(CountDownLatch latch) {        this.latch = latch;    }    @Override    public void run() {        try {            System.out.println(Thread.currentThread().getName() + " is working.");            Thread.sleep((long) (Math.random() * 1000)); // 模拟工作线程执行的任务            System.out.println(Thread.currentThread().getName() + " has finished.");        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            latch.countDown(); // 工作线程完成任务后，计数器减一        }    }}

CyclicBarrier

在 Guava 类库中，没有直接提供 CyclicBarrier 类。CyclicBarrier 是 Java 标准库中的一个类，它可以用于多线程间的同步。这里也简单梳理一下他的用法，因为在做多线程间同步协调的相关业务时，CountDownLatch和CyclicBarrier，是两个绕不过去的选项，这里放在一起也好作个对比。

在下面这个示例中，创建了10个工作线程，每个线程都执行相同的任务。这些线程通过CyclicBarrier进行同步，确保所有线程都达到屏障点（即调用cyclicBarrier.await()方法）后再一起继续执行。当所有线程都调用cyclicBarrier.await()方法后，屏障会被打破，所有线程可以继续执行后续的任务。在这个示例中，后续的任务是输出线程名称和"is running"的消息。

public class CyclicBarrierExample {    public static void main(String[] args) {        final int totalThread = 10;        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
        for (int i = 0; i < totalThread; i++) {            new Thread(new Task(cyclicBarrier), "Thread" + i).start();        }    }}
class Task implements Runnable {    private CyclicBarrier cyclicBarrier;
    public Task(CyclicBarrier cyclicBarrier) {        this.cyclicBarrier = cyclicBarrier;    }
    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + " is ready");        try {            cyclicBarrier.await(); //等待其他线程到达屏障点        } catch (Exception e) {            e.printStackTrace();        }        System.out.println(Thread.currentThread().getName() + " is running");    }}