【Guava】IO工具

弁言

Guava 利用术语 流来表现可关闭的，并且在底层资源中有位置状态的 I/O 数据流。字节省对应的工具类为 ByteSterams，字符流对应的工具类为 CharStreams。
Guava 中为了制止和流直接打交道，抽象出可读的 源 source 和可写的 汇 sink 两个概念，指可以从中打开流的资源，比如 File、URL，同样也分别有字节和字符对应的源和汇，界说了一系列读写的方法。
Guava IO 极大简化了文件和流的操纵。比如说，读写文件这种看似简单的操纵，在Java原生代码中可能要写好几行，还不包罗错误处置惩罚。Guava则可以用一两行搞定，简洁到让人惊叹。其次，它还提供了更丰富的功能，比如对不同字符集的处置惩罚，还有资源的高效管理。这些都是在开发过程中经常碰到的题目，Guava给了我们优雅的办理方案。
来看个简单的例子，比如说读取一个文本文件的内容。在Java原生代码中，可能得这么写：

1. try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
2.     String line;
3.     while ((line = br.readLine()) != null) {
4.         System.out.println(line);
5.     }
6. } catch (IOException e) {
7.     e.printStackTrace();
8. }

复制代码

但是用Guava，就可以变得超级简单：

1. List<String> lines = Files.asCharSource(new File("example.txt"), Charsets.UTF_8).readLines();
2. lines.forEach(System.out::println);

复制代码

看到区别了吧？Guava的代码不但更短，而且可读性也强很多。而且，Guava还考虑了很多细节，比如字符集处置惩罚，在这里用的是Charsets.UTF_8，这在处置惩罚有不同编码的文件时特殊有用。
文件操纵简化

在Java的天下里，文件操纵是个老生常谈的话题。传统的Java I/O操纵，虽然功能强大，但代码写起来每每既长又复杂，但是，有了Guava，这统统都变得轻松多了。
读取文件

读取文件场景中，在Java原生方法里，可能需要创建FileReader，然后再包装成BufferedReader，末了一行一行地读。但在Guava中，只需要几行代码，就能搞定。
看这个例子：

1. // 使用Guava读取文件
2. File file = new File("example.txt");
3. List<String> lines = Files.asCharSource(file, Charsets.UTF_8).readLines();
4. for (String line : lines) {
5.     System.out.println(line);
6. }

复制代码

在这段代码里，Files.asCharSource方法创建了一个字符源（CharSource），这样就可以直接读取文件中的内容了。再也不用担心FileNotFoundException和IOException这些让人头疼的非常了，Guava都处置惩罚好了统统。
写入文件

在传统的Java I/O中，写文件也是一大堆代码，需要处置惩罚流的打开和关闭，还得小心处置惩罚非常。但在Guava中，这也变得超级简单：

1. // 使用Guava写入文件
2. List<String> content = Arrays.asList("Line 1", "Line 2", "Line 3");
3. File file = new File("example-write.txt");
4. Files.asCharSink(file, Charsets.UTF_8).writeLines(content);

复制代码

在这里，Files.asCharSink创建了一个字符汇（CharSink），它能轻松写入数据到文件中。这些代码不但简洁，而且易于明白和维护。
复制和移动文件

但Guava的魔法不止于此。想要复制大概移动文件？也是分分钟的事变。看看这个：

1. // 复制文件
2. File original = new File("source.txt");
3. File copy = new File("destination.txt");
4. Files.copy(original, copy);
6. // 移动文件
7. File toMove = new File("toMove.txt");
8. File destination = new File("moved.txt");
9. Files.move(toMove, destination);

复制代码

流处置惩罚与转换

在Java中，流（Streams）是处置惩罚数据的核心，不论是文件I/O还是网络通讯，流都扮演着至关紧张的角色。但有时候，处置惩罚Java原生的InputStream和OutputStream会让人觉得有点小复杂。幸好，Guava在这方面提供了非常便捷的工具，让流处置惩罚变得既简单又高效。
简化的流读取

在传统的Java I/O中，从InputStream读取数据通常需要创建一个buffer，然后一点点读取。但用Guava，整个过程就变得非常简单：

1. // 使用Guava从InputStream读取字符串
2. InputStream input = new FileInputStream("example.txt");
3. String text = CharStreams.toString(new InputStreamReader(input, Charsets.UTF_8));
4. input.close();

复制代码

在这里，CharStreams.toString方法直接将整个InputStream转换为字符串。再也不需要手动创建buffer和循环读取了，一行代码就搞定。
流的转换和处置惩罚

有时候，需要对流中的数据举行某种形式的处置惩罚或转换。Guava在这方面也提供了很大的帮助。看看这个例子：

1. // 使用Guava对InputStream进行转换
2. InputStream input = new FileInputStream("example.txt");
3. FluentIterable<String> lines =
4.     CharStreams.readLines(new InputStreamReader(input, Charsets.UTF_8))
5.                .transform(line -> line.toUpperCase()); // 将每一行都转换为大写
6. input.close();

复制代码

在这个例子中，CharStreams.readLines方法读取了所有行，并且通过transform方法对每一行举行了转换，这里是将其转换为大写。Guava的流式处置惩罚风格让这种转换变得非常优雅。
高效的流拷贝

在Java中，从一个流拷贝数据到另一个流通常需要手动创建buffer，并循环举行读写。但在Guava中，这也变得简单多了：

1. // 使用Guava进行流拷贝
2. InputStream input = new FileInputStream("source.txt");
3. OutputStream output = new FileOutputStream("dest.txt");
4. ByteStreams.copy(input, output); // 将数据从input流拷贝到output流
5. input.close();
6. output.close();

复制代码

在这个例子中，ByteStreams.copy方法就直接完成了从一个流到另一个流的数据拷贝。Guava把复杂的操纵隐藏在了简洁的API背后，大大低落了编码的复杂性。
字符集与编码处置惩罚

在Java天下里，字符集和编码经常会让人头疼，特殊是当处置惩罚不同来源的数据时，比如从不同的文件或网络。字符编码题目能让一个简单的任务变得非常复杂。但别担心，Guava来帮助了！
字符编码的挑战

在Java中，处置惩罚不同编码的文本，尤其是在I/O操纵中，经常会碰到UnsupportedEncodingException。这是因为不同的系统和文本文件可能利用不同的字符编码。比如，Windows可能默认利用CP1252，而Linux可能利用UTF-8。如果不正确处置惩罚这些编码，就会导致乱码大概错误。
Guava的Charsets

Guava提供了一套字符集（Charsets）工具，让处置惩罚这些题目变得简单。Guava界说了所有标准的Java字符集，这样咱们就不必手动处置惩罚那些繁琐的字符串了。比如，当需要转换字节数据到字符串，大概相反的操纵时，Guava的Charsets就派上用场了。
看看下面这个例子：

1. // 使用Guava的Charsets处理字符串
2. String example = "这是一个测试字符串";
3. byte[] bytes = example.getBytes(Charsets.UTF_8); // 将字符串转换为UTF-8编码的字节
4. String decoded = new String(bytes, Charsets.UTF_8); // 再将字节解码回字符串
5. System.out.println(decoded);

复制代码

在这段代码里，利用Charsets.UTF_8来确保字符串正确地被编码和解码。Guava的Charsets处置惩罚起来既简单又不易堕落。
更多字符处置惩罚工具

除了Charsets，Guava还提供了更多字符处置惩罚工具。比如，有时咱们需要对字符串中的特定字符举行操纵，Guava的CharMatcher类就是专门为此计划的。
来看个例子，假设咱们要从字符串中移除所有数字：

1. // 使用Guava的CharMatcher移除字符串中的数字
2. String input = "abc123xyz456";
3. String result = CharMatcher.inRange('0', '9').removeFrom(input);
4. System.out.println(result); // 输出结果: "abcxyz"

复制代码

在这个例子中，CharMatcher.inRange('0', '9')创建了一个匹配所有数字的匹配器，然后removeFrom方法就将这些数字从字符串中移除了。这样的处置惩罚不但代码量少，而且逻辑清晰易懂。
详情可以看这篇文章 String&Ints
源（Source）和汇（Sink）模式

在处置惩罚文件和流的时候，常常需要读数据（Source）和写数据（Sink）。Guava在这方面提供了一套非常优雅的办理方案，让这些操纵变得既简单又直观。
在Guava中，Source代表一个数据的来源，可以是文件、URL大概任何其他数据源。而Sink则是数据的目的地，比如文件大概某个输出流。这种抽象的利益是，无论数据来源或去处如何变化，操纵逻辑都保持一致。
文件的Source和Sink

先来看看文件操纵。在传统的Java I/O中，需要创建FileInputStream或FileOutputStream，然后举行读写操纵。但用Guava的Source和Sink，整个过程变得更加清晰。
看这个读文件的例子：

1. // 使用Guava的FileSource读取文件
2. File file = new File("example.txt");
3. CharSource charSource = Files.asCharSource(file, Charsets.UTF_8);
4. String content = charSource.read();
5. System.out.println(content);

复制代码

在这段代码中，Files.asCharSource创建了一个CharSource实例，它代表了文件中的字符数据。charSource.read()方法就能读取整个文件的内容。这样的代码不但简洁，而且非常容易明白。
再来看看写文件的操纵：

1. // 使用Guava的FileSink写入文件
2. List<String> lines = Arrays.asList("第一行", "第二行", "第三行");
3. File file = new File("example-write.txt");
4. CharSink charSink = Files.asCharSink(file, Charsets.UTF_8);
5. charSink.writeLines(lines);

复制代码

这里Files.asCharSink创建了一个CharSink实例，它代表文件的写入点。charSink.writeLines方法可以轻松地将一个字符串列表写入文件。
URL的Source

除了文件，Source和Sink还可以用于其他范例的数据源。比如，可以从一个URL读取数据：

1. // 使用Guava的URLSource读取数据
2. URL url = new URL("http://example.com");
3. ByteSource byteSource = Resources.asByteSource(url);
4. byte[] data = byteSource.read();
5. System.out.println(new String(data, Charsets.UTF_8));

复制代码

在这个例子中，Resources.asByteSource创建了一个表现URL数据的ByteSource。然后就可以利用byteSource.read()来读取数据，非常方便。
非常处置惩罚与资源管理

在Java编程中，正确处置惩罚非常和资源黑白常紧张的，尤其是在举行I/O操纵大概处置惩罚外部资源时。如果处置惩罚不当，很容易造成资源走漏或程序崩溃。Guava在这方面提供了一些非常棒的工具，帮助咱们写出更安全、更可靠的代码。
快速失败：Preconditions

在开始处置惩罚数据之前，查抄输入黑白常紧张的。Guava提供了Preconditions类，帮助咱们快速校验条件，并在条件不满足时立即失败。这种“快速失败”机制有助于尽早发现题目，制止更深层次的错误。
看看这个例子：

1. // 使用Guava的Preconditions进行参数校验
2. public void processData(String data) {
3.     Preconditions.checkNotNull(data, "data不能为null");
4.     // 处理数据
5. }

复制代码

这段代码中，Preconditions.checkNotNull方法确保传入的data不是null。如果是null，它会抛出一个NullPointerException，并附带自界说的错误消息。这样的校验既直观又有用，有助于提高代码的结实性。
详情可以看这篇文章 String&Ints
资源管理：Closeables和FluentIterable

在Java中，正确管理资源，特殊是那些需要关闭的资源，如流或连接，黑白常紧张的。Guava的Closeables类提供了便捷的方法来关闭这些资源，而不必担心IOException。

1. // 使用Guava的Closeables安全关闭资源
2. InputStream in = null;
3. try {
4.     in = new FileInputStream("example.txt");
5.     // 使用流
6. } catch (IOException e) {
7.     // 异常处理
8. } finally {
9.     Closeables.closeQuietly(in); // 安静地关闭流，忽略IOException
10. }

复制代码

在这个例子中，无论在利用流的过程中是否发生非常，Closeables.closeQuietly都会在finally块中安全地关闭流。这样的处置惩罚方式不但简洁，而且可以制止因忘记关闭资源而导致的题目。
Guava的FluentIterable也是资源管理的好帮手。它提供了一种链式的方法来处置惩罚集合，使得操纵集合变得既简洁又优雅。

1. // 使用Guava的FluentIterable优雅地处理集合
2. List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
3. List<String> filtered = FluentIterable.from(names)
4.                                       .filter(name -> name.startsWith("A"))
5.                                       .toList();

复制代码

在这段代码中，FluentIterable.from创建了一个可迭代的集合视图，filter方法用于过滤，末了toList将结果转换为List。这样的链式调用，不但代码可读性高，而且易于维护。
Guava与Java NIO的结合

本章我们要聊聊Guava和Java NIO（非阻塞I/O）的结合。对于那些需要处置惩罚大量数据，大概对性能要求较高的应用来说，Java的NIO库是个非常强大的工具。但是，NIO的API有时候会显得有点复杂。这时候，Guava又一次展示了它的魔力，帮助我们更简单、更优雅地利用NIO。
Guava对NIO的增强

Guava对Java NIO做了一些增强，让它的利用变得更加友爱。Guava提供了类似于ByteSource和ByteSink这样的抽象，使得利用NIO举行文件操纵或网络操纵更加直观。
来看看这个读取文件内容的例子：

1. // 使用Guava的ByteSource读取文件内容
2. File file = new File("example.txt");
3. ByteSource byteSource = Files.asByteSource(file);
4. byte[] readBytes = byteSource.read();
5. System.out.println(new String(readBytes, Charsets.UTF_8));

复制代码

在这个例子中，Files.asByteSource方法创建了一个ByteSource实例，它代表文件中的字节数据。然后，可以利用byteSource.read()方法读取这些数据。这种方式比直接利用Java NIO的Channel和Buffer要简单得多。
NIO与流的转换

另一个强大的功能是Guava提供的NIO和流之间的转换。在某些环境下，可能需要在NIO的Channel和Java的InputStream/OutputStream之间举行转换。Guava在这方面提供了便利的工具。

1. // 使用Guava将InputStream转换为ReadableByteChannel
2. InputStream inputStream = new FileInputStream("example.txt");
3. ReadableByteChannel channel = Channels.newChannel(inputStream);
4. // 使用channel进行操作

复制代码

在这个例子中，Channels.newChannel方法将一个InputStream转换为一个ReadableByteChannel。这样的转换让我们能够在需要利用NIO时，更加灵活地处置惩罚流。
往期保举

• 《SpringBoot》EasyExcel实现百万数据的导入导出
  
• 《SpringBoot》史上最全SpringBoot干系注解介绍
  
• Spring框架IoC核心详解
  
• 万字长文带你窥探Spring中所有的扩展点
  
• 如何实现一个通用的接口限流、防重、防抖机制
  
• 万字长文带你深入Redis底层数据布局
  
• volatile关键字最全原理剖析
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。