Guava库是一组来自Google的核心Java库，其设计目的是为了简化Java开发过程，提高开发效率。这个库包含了大量实用的API，可以帮助开发者解决日常开发中遇到的各种问题。
提升编程效率的利器: 解析Google Guava库之集合篇Immutable（一）
提升编程效率的利器: 解析Google Guava库之集合篇Multimap（二）
提升编程效率的利器: 解析Google Guava库之集合篇BitMap（三）
提升编程效率的利器: 解析Google Guava库之集合篇Table二维映射（四)
提升编程效率的利器: 解析Google Guava库之集合篇RangeSet范围集合（五）
提升编程效率的利器: 解析Google Guava库之集合篇RangeMap范围映射（六）
一、源码包的分布
Guava库的源码包分布非常广泛，覆盖了多个不同的功能领域。以下是一些主要的源码包及其功能：
com.google.common.base：这个包包含了基本工具类库和接口，提供了一些通用的功能，如Preconditions（用于参数校验）、Optional（用于处理可能为null的值）等。
com.google.common.collect：这个包提供了带泛型的集合接口扩展和实现，以及工具类。它增加了一些Java标准库中没有的集合类型，如Multimap（多映射）、Multiset（多集）等，还提供了一些用于操作集合的实用方法。
com.google.common.eventbus：这个包实现了一个发布-订阅风格的事件总线，允许在不同组件之间发布和订阅事件，实现松耦合的通信。
com.google.common.hash：这个包提供了哈希工具类，用于计算哈希值和处理哈希相关的操作。
com.google.common.io：这个包包含了I/O工具类，提供了一些简化I/O操作的实用方法，如文件读写、字节流处理等。
com.google.common.math：这个包提供了原始算术类型和超大数的运算工具类，用于进行数学计算和处理大数字。
com.google.common.net：这个包包含了网络工具类，提供了一些与网络相关的实用功能，如URL处理、网络地址解析等。
com.google.common.primitives：这个包提供了对八种原始类型和无符号类型的静态工具类，包括一些基本类型的操作、转换和比较。
com.google.common.reflect：这个包包含了反射工具类，提供了一些用于反射操作的实用方法，如获取类信息、调用方法等。
com.google.common.util.concurrent：这个包提供了多线程工具类，包括一些并发编程的实用功能，如异步计算、线程池管理等。
这些源码包构成了Guava库的核心，提供了丰富的功能和工具类，方便开发者进行Java开发。通过使用Guava库，开发者可以更加高效地处理集合、缓存、并发编程、字符串处理、I/O操作等各种常见的开发任务。
二、字符处理工具
import com.google.common.base.CharMatcher; import com.google.common.base.Joiner; import com.google.common.base.Splitter; import com.google.common.base.Strings; import com.google.common.io.CharStreams; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.nio.charset.Charset; public class GuavaDemo { public static void main(String[] args) throws IOException { // 1.使用Joiner拼接字符串 String joinedString = Joiner.on(", ").join("apple", "banana", "cherry"); System.out.println(joinedString); // 输出: apple, banana, cherry // 2.使用Splitter拆分字符串 Iterable<String> splitStrings = Splitter.on(",").trimResults().split(joinedString); for (String s : splitStrings) { System.out.println(s); // 输出: apple, banana, cherry（每行一个） } // 3.使用Strings处理字符串 String nullString = null; String emptyString = ""; String whitespaceString = " "; System.out.println(Strings.nullToEmpty(nullString)); // 输出: （空字符串） System.out.println(Strings.isNullOrEmpty(emptyString)); // 输出: true System.out.println(Strings.isNullOrEmpty(whitespaceString)); // 输出: false System.out.println(CharMatcher.whitespace().removeFrom(whitespaceString)); // 输出: （空字符串） // 4.使用Charsets指定字符集 Charset utf8 = Charsets.UTF_8; try (InputStream inputStream = GuavaDemo.class.getResourceAsStream("/test.txt"); InputStreamReader reader = new InputStreamReader(inputStream, utf8)) { String content = CharStreams.toString(reader); System.out.println(content); // 输出: test.txt文件的内容（假设文件存在且为UTF-8编码） } // 5.原始字符串，采用驼峰式命名 String camelCaseString = "ExampleClassName"; // 转换为下划线式命名 String lowerUnderscoreString = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, camelCaseString); // 打印转换后的字符串 System.out.println(lowerUnderscoreString); // 输出：example_class_name // 如果要将下划线式命名转回驼峰式命名，可以这样做： String backToCamelCaseString = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, lowerUnderscoreString); // 打印转回驼峰式命名后的字符串 System.out.println(backToCamelCaseString); // 输出：ExampleClassName // 6. 使用CharMatcher String input = "Hello, World! This is a test string."; // 使用CharMatcher移除指定字符 String resultWithoutVowels = CharMatcher.is('a', 'e', 'i', 'o', 'u').removeFrom(input); // 打印结果: "Hll, Wrld! Ths s s tst strng." System.out.println(resultWithoutVowels); // 使用CharMatcher替换指定字符 String resultReplaceVowels = CharMatcher.is('a', 'e', 'i', 'o', 'u').replaceFrom(input, '*'); // 打印结果: "H*ll*, W*rld! Th*s *s * t*st str*ng." System.out.println(resultReplaceVowels); // 使用CharMatcher保留指定字符 String resultKeepVowels = CharMatcher.is('a', 'e', 'i', 'o', 'u').retainFrom(input); // 打印结果: "eiooeiae" System.out.println(resultKeepVowels); // 7.使用CharSequences查找子序列的索引 int indexOfTest = CharSequences.indexOf(input, "test"); // 打印结果: 索引位置 21 System.out.println("索引位置: " + indexOfTest); // 使用CharSequences比较两个CharSequence boolean areEqual = CharSequences.equals("Hello", "Hello"); // 打印结果: true System.out.println("两个序列是否相等: " + areEqual); // 使用CharSequences拼接CharSequence String concatenated = CharSequences.concat("Guava ", "is ", "awesome!").toString(); // 打印结果: "Guava is awesome!" System.out.println(concatenated); } }
Joiner 被用来将一个字符串列表以逗号加空格为分隔符合并成一个字符串。
Splitter 被用来根据逗号拆分合并后的字符串，并移除了结果字符串两端的空白字符。
Strings 类中的方法被用来处理空字符串和空白字符。nullToEmpty 方法将 null 转换为空字符串，isNullOrEmpty 方法检查字符串是否为 null 或空，CharMatcher 的 whitespace().removeFrom 方法移除了字符串中的所有空白字符。
Charsets 被用来获取 UTF-8 字符集，并通过 InputStreamReader 和 CharStreams 来读取和转换文件内容。
三、原始类型工具
Ints, Longs, Doubles, Floats, Booleans, Bytes, Shorts, Chars, 和 PrimitiveArrays 是 Guava 库中提供的一组用于操作原始类型数据的实用工具类。以下是一些使用这些类的示例：
import com.google.common.primitives.Booleans; import com.google.common.primitives.Bytes; import com.google.common.primitives.Chars; import com.google.common.primitives.Doubles; import com.google.common.primitives.Floats; import com.google.common.primitives.Ints; import com.google.common.primitives.Longs; import com.google.common.primitives.Shorts; import java.util.Arrays; public class GuavaPrimitivesExample { public static void main(String[] args) { // Ints 示例 int[] intArray = {1, 2, 3, 4, 5}; int sumOfInts = Ints.sum(intArray); // 打印结果: 15 System.out.println("Sum of ints: " + sumOfInts); // Longs 示例 long[] longArray = {1L, 2L, 3L, 4L, 5L}; long sumOfLongs = Longs.sum(longArray); // 打印结果: 15 System.out.println("Sum of longs: " + sumOfLongs); // Doubles 示例 double[] doubleArray = {1.1, 2.2, 3.3, 4.4, 5.5}; double sumOfDoubles = Doubles.sum(doubleArray); // 打印结果: 16.5 System.out.println("Sum of doubles: " + sumOfDoubles); // Floats 示例 float[] floatArray = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f}; float sumOfFloats = Floats.sum(floatArray); // 打印结果: 16.5 System.out.println("Sum of floats: " + sumOfFloats); // Booleans 示例 boolean[] booleanArray = {true, false, true}; boolean anyTrue = Booleans.contains(booleanArray, true); // 打印结果: true System.out.println("Array contains true: " + anyTrue); // Bytes 示例 byte[] byteArray = {1, 2, 3, 4, 5}; byte minByte = Bytes.min(byteArray); // 打印结果: 1 System.out.println("Min byte: " + minByte); // Shorts 示例 short[] shortArray = {1, 2, 3, 4, 5}; short maxShort = Shorts.max(shortArray); // 打印结果: 5 System.out.println("Max short: " + maxShort); // Chars 示例 char[] charArray = {'a', 'b', 'c', 'd', 'e'}; int charCount = Chars.count(charArray, 'c'); // 打印结果: 1 System.out.println("Count of 'c': " + charCount); // 排序示例（使用Java标准库的Arrays.sort而不是Guava） int[] unsortedIntArray = {5, 3, 1, 4, 2}; Arrays.sort(unsortedIntArray); // 打印结果: [1, 2, 3, 4, 5] System.out.println("Sorted int array: " + Arrays.toString(unsortedIntArray)); } }
四、IO工具类
包括 InputSupplier, OutputSupplier, Resources, ByteStreams, 和 CharStreams，它们主要用于简化输入/输出操作和流处理。以下是如何使用这些工具类的示例：
import com.google.common.base.Charsets; import com.google.common.base.Supplier; import com.google.common.io.ByteStreams; import com.google.common.io.CharStreams; import com.google.common.io.InputSupplier; import com.google.common.io.OutputSupplier; import com.google.common.io.Resources; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.Reader; import java.io.StringReader; import java.io.StringWriter; import java.net.URL; public class GuavaIoExample { public static void main(String[] args) throws IOException { // InputSupplier 示例 InputSupplier<InputStream> inputSupplier = new InputSupplier<InputStream>() { @Override public InputStream getInput() throws IOException { return new ByteArrayInputStream("Hello, Guava!".getBytes(Charsets.UTF_8)); } }; // 读取 InputSupplier 并转换为字符串 String fromInputSupplier = new String(ByteStreams.toByteArray(inputSupplier.getInput()), Charsets.UTF_8); // 打印结果: Hello, Guava! System.out.println("From InputSupplier: " + fromInputSupplier); // OutputSupplier 示例 OutputSupplier<OutputStream> outputSupplier = new OutputSupplier<OutputStream>() { @Override public OutputStream getOutput() throws IOException { return new ByteArrayOutputStream(); } }; // 写入数据到 OutputSupplier 并获取结果 OutputStream outputStream = outputSupplier.getOutput(); outputStream.write("Hello, from OutputSupplier!".getBytes(Charsets.UTF_8)); ((ByteArrayOutputStream) outputStream).close(); // 对于 ByteArrayOutputStream，需要手动关闭以完成写入 // 注意：上面的代码片段实际上是有问题的，因为我们在外部关闭了流，但OutputSupplier的使用者通常期望自己关闭它。 // 正确的做法是，如果你控制了流的生命周期，不要让OutputSupplier返回它直到你准备好让调用者关闭它。 // 我们只是为了演示，实际上应该避免这样做。 // Resources 示例：从URL读取内容 URL url = Resources.getResource("somefile.txt"); // 假设 somefile.txt 在类路径上 String fromResources = Resources.toString(url, Charsets.UTF_8); // 打印文件内容（取决于 somefile.txt 的实际内容） System.out.println("From Resources: " + fromResources); // ByteStreams 示例：从输入流复制到输出流 InputStream inputStream = new ByteArrayInputStream("Data to copy".getBytes(Charsets.UTF_8)); OutputStream copyOutputStream = new ByteArrayOutputStream(); ByteStreams.copy(inputStream, copyOutputStream); String copiedData = new String(((ByteArrayOutputStream) copyOutputStream).toByteArray(), Charsets.UTF_8); // 打印结果: Data to copy System.out.println("Copied Data: " + copiedData); // CharStreams 示例：从 Reader 读取所有字符 Reader reader = new StringReader("Characters to read"); String fromCharStreams = CharStreams.toString(reader); // 打印结果: Characters to read System.out.println("From CharStreams: " + fromCharStreams); // 使用 try-with-resources 确保流正确关闭 try (StringWriter stringWriter = new StringWriter()) { // 写入数据到 StringWriter stringWriter.write("Hello, try-with-resources!"); // 从 StringWriter 获取数据 String writtenData = stringWriter.toString(); // 打印结果: Hello, try-with-resources! System.out.println("Written Data: " + writtenData); } // 在这里，StringWriter 会自动关闭，因为我们在 try-with-resources 语句中使用了它 } }
注意：在实际中应该避免像上面示例中那样手动关闭流，特别是当使用像 OutputSupplier 这样的构造时。通常，流的关闭应该由最终使用它的代码来处理，或者使用 try-with-resources 语句来自动管理资源。
五、其他常用的工具类
下面是 Guava 中 Stopwatch, ClassPath, BaseEncoding, Throwables, 和 HashCode 的使用示例：
import com.google.common.base.Charsets; import com.google.common.base.Throwables; import com.google.common.hash.HashCode; import com.google.common.hash.Hashing; import com.google.common.io.BaseEncoding; import com.google.common.io.ClassPath; import com.google.common.primitives.Bytes; import com.google.common.util.concurrent.Uninterruptibles; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.util.concurrent.TimeUnit; public class GuavaUtilitiesExample { public static void main(String[] args) { // Stopwatch 示例：测量代码执行时间 Stopwatch stopwatch = Stopwatch.createStarted(); Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); // 模拟耗时操作 long elapsedMillis = stopwatch.elapsed(TimeUnit.MILLISECONDS); // 打印结果：耗时约 1000 毫秒 System.out.println("Elapsed time: " + elapsedMillis + " ms"); // ClassPath 示例：遍历类路径上的资源 try { ClassPath classPath = ClassPath.from(GuavaUtilitiesExample.class.getClassLoader()); for (ClassPath.ClassInfo classInfo : classPath.getAllClasses()) { if (classInfo.getName().contains("Guava")) { // 打印结果：包含 "Guava" 的类名 System.out.println("Class found: " + classInfo.getName()); } } } catch (IOException e) { Throwables.throwIfUnchecked(e); // 传播未检查的异常 } // BaseEncoding 示例：编码和解码 String originalText = "Hello, Guava!"; String encodedText = BaseEncoding.base64().encode(originalText.getBytes(Charsets.UTF_8)); byte[] decodedBytes = BaseEncoding.base64().decode(encodedText); String decodedText = new String(decodedBytes, Charsets.UTF_8); // 打印结果：编码后的文本和解码后的文本应该与原始文本匹配 System.out.println("Original text: " + originalText); System.out.println("Encoded text: " + encodedText); System.out.println("Decoded text: " + decodedText); // Throwables 示例：获取异常的根因 try { throw new RuntimeException("Outer exception", new IOException("Inner exception")); } catch (Exception e) { Throwable rootCause = Throwables.getRootCause(e); // 打印结果：Inner exception System.out.println("Root cause: " + rootCause.getMessage()); } // HashCode 示例：计算哈希值 String textToHash = "This is some text to hash"; HashCode hashCode = Hashing.sha256().hashString(textToHash, Charsets.UTF_8); // 打印结果：SHA-256 哈希值 System.out.println("SHA-256 hash: " + hashCode); } }
请注意以下几点：
- Stopwatch 用于测量代码段的执行时间。
- ClassPath 用于遍历类加载器加载的所有类资源。由于这可能会加载大量的类，因此在实际应用中要谨慎使用，避免性能问题。
- BaseEncoding 提供了一种便捷的方式来进行 Base64 等编码方式的编码和解码操作。
- Throwables 提供了一些实用方法来处理异常，例如获取根因。
- HashCode 是 Guava 中表示哈希值的类，它与 java.util.Objects.hash() 不同，主要用于计算特定哈希算法（如 SHA-256）的哈希值。
- ninterruptibles.sleepUninterruptibly() 是为了演示目的而使用的，它在实际应用中可能不是一个好的选择，因为它会无条件地忽略中断。在生产代码中，你应该更仔细地处理中断。
