Guava remains valuable for modern Java developers by providing immutable collections like ImmutableList and ImmutableSet, which ensure thread safety and prevent accidental modifications. 2. It offers practical utilities such as Preconditions for clean input validation, Objects.equal() for null-safe comparisons, and toStringHelper for readable toString() implementations. 3. Guava introduces advanced collection types including Multimap for one-to-many mappings, BiMap for bidirectional mappings, and Table for two-dimensional data storage. 4. While its functional programming support (Function, Predicate, Optional) is largely superseded by Java 8 features, legacy methods like Iterables.filter() remain useful in non-stream contexts. 5. CacheBuilder enables simple in-memory caching without external dependencies, suitable for lightweight use cases, though Caffeine is preferred for high-performance scenarios. Use Guava selectively for its superior collection utilities and avoid outdated components like Guava’s Optional in favor of standard Java equivalents to write cleaner, safer code.

If you're a modern Java developer working with JDK 8 or later, Google Guava isn’t just a nice-to-have—it’s a productivity booster that fills gaps in the standard Java library. While newer Java versions have absorbed some of Guava’s early innovations (like Optional), the library still offers powerful utilities and data structures that make code cleaner, safer, and more expressive.

Here’s a practical guide to the most valuable parts of Guava for today’s Java developers.

1. Immutable Collections: Safety and Clarity

One of Guava’s standout features is its support for immutable collections. These are collections that can’t be modified after creation—ideal for defensive programming, thread safety, and clear API contracts.

Instead of this:

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
// Then manually wrap or document that it shouldn't be modified

Use Guava:

ImmutableList<String> fruits = ImmutableList.of("apple", "banana", "orange");
ImmutableList<String> copy = ImmutableList.copyOf(fruits);

You can also build more complex ones:

ImmutableSet<String> unique = ImmutableSet.<String>builder()
    .add("a")
    .add("b")
    .addAll(otherCollection)
    .build();

Why it matters:

• Prevents accidental modifications
• Thread-safe by design
• Expresses intent clearly: “this won’t change”

Note: Java 9 has List.of() and similar, but Guava’s builders and flexibility (e.g., ImmutableSortedSet, ImmutableBiMap) still go further.

2. Common Utilities That Save Repetitive Code

Guava packs helpers that reduce boilerplate across common tasks.

Preconditions – Clean Input Validation

Replace null checks and validation clutter with Preconditions:

public void setUser(String name, Integer age) {
    checkNotNull(name, "Name cannot be null");
    checkArgument(age != null && age > 0, "Age must be positive");
    checkState(users.size() < MAX_USERS, "User limit reached");
    // Proceed safely
}

• checkNotNull → throws NullPointerException
• checkArgument → throws IllegalArgumentException
• checkState → throws IllegalStateException

Clean, readable, and consistent.

Objects.equal() and Objects.toStringHelper()

Even with Java 8 , these help before Objects class caught up:

if (Objects.equal(a, b)) { ... } // Handles nulls safely

And for quick toString():

@Override
public String toString() {
    return MoreObjects.toStringHelper(this)
        .add("name", name)
        .add("age", age)
        .toString();
}

Note: MoreObjects.toStringHelper is now deprecated in favor of Objects.toStringHelper in newer Guava versions—shows how Guava influenced the JDK.

3. Powerful Collection Types You Won’t Find in JDK

Guava adds high-level collection types that solve real-world modeling problems.

Multimap – One Key, Multiple Values

Instead of Map<String, List<String>>, use:

Multimap<String, String> favorites = ArrayListMultimap.create();
favorites.put("Ann", "pizza");
favorites.put("Ann", "pasta");
favorites.put("Bob", "sushi");

for (String food : favorites.get("Ann")) { // auto-list created
    System.out.println(food);
}

No more null checks or manual list creation.

BiMap – Bidirectional Mapping

Ensures both key and value are unique—so you can lookup by key or by value:

BiMap<String, String> countryCodeToName = HashBiMap.create();
countryCodeToName.put("US", "United States");
countryCodeToName.put("CA", "Canada");

// Reverse lookup
String code = countryCodeToName.inverse().get("Canada"); // → "CA"

Perfect for enums, config mappings, or language codes.

Table – Two-Dimensional Mapping

Need a matrix? Use Table:

Table<String, String, Integer> performance = HashBasedTable.create();
performance.put("Q1", "Mobile", 120);
performance.put("Q1", "Desktop", 200);

Integer value = performance.get("Q1", "Mobile"); // → 120

Think: rows, columns, and values—like a spreadsheet.

4. Functional Programming Support (Legacy, but Still Useful)

Guava predates Java 8 streams and lambdas, so it introduced Function, Predicate, and Optional. While you should prefer Java 8 constructs now, you’ll still see these in older codebases.

Instead of:

Function<String, Integer> strToInt = new Function<String, Integer>() {
    public Integer apply(String s) { return Integer.valueOf(s); }
};

Just use a lambda:

Function<String, Integer> strToInt = Integer::valueOf;

But Guava’s Optional was influential. Now use java.util.Optional instead—Guava’s version is discouraged to avoid confusion.

Still, Guava’s Iterables and Iterators have useful methods:

Iterable<String> filtered = Iterables.filter(names, name -> name.startsWith("A"));
String first = Iterables.getFirst(filtered, "default");

These work well with legacy collections or when streams aren’t available.

5. Caching: Simple In-Memory Caching (Without Spring)

For lightweight caching without pulling in Spring or Caffeine (which actually evolved from Guava!), use CacheBuilder:

LoadingCache<String, User> cache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(
        new CacheLoader<String, User>() {
            public User load(String key) throws Exception {
                return fetchUserFromDatabase(key);
            }
        });

User user = cache.get("alice123"); // Loads if not present

Note: Guava Cache is still solid for simple cases, but for heavy use, consider Caffeine—it’s faster and more actively developed.

Final Thoughts

Guava isn’t what it used to be—Java has caught up in many areas. But it’s far from obsolete.

Use Guava when you want:

• Immutable collections with rich builders
• Specialized data structures (Multimap, BiMap, Table)
• Clean utilities like Preconditions and Objects.equal
• Lightweight caching (or learning stepping stone to Caffeine)

Avoid:

• Guava’s Optional, Function, Predicate — prefer java.util and lambdas
• Overusing legacy functional types in new code

Add it to your project with Maven:

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

Keep it in your toolkit—not for everything, but for the gaps Java still leaves open.

Basically, use the right part of Guava, ignore the outdated bits, and write cleaner, safer Java.

The above is the detailed content of A Guide to Google Guava for Modern Java Developers. For more information, please follow other related articles on the PHP Chinese website!