Guava is a set of core libraries that includes new collection types (such as multimap and multiset), immutable collections, a graph library, functional types, an in-memory cache, and APIs/utilities for concurrency, I/O, hashing, primitives, reflection, string processing, and much more!html
Guava comes in two flavors.java
android
directory.Guava's Maven group ID is com.google.guava
and its artifact ID is guava
. Guava provides two different "flavors": one for use on a (Java 8+) JRE and one for use on Android or Java 7 or by any library that wants to be compatible with either of those. These flavors are specified in the Maven version field as either 27.0.1-jre
or 27.0.1-android
. For more about depending on Guava, see using Guava in your build.android
To add a dependency on Guava using Maven, use the following:git
<dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>27.0.1-jre</version> <!-- or, for Android: --> <version>27.0.1-android</version> </dependency>
To add a dependency using Gradle:github
dependencies {
compile 'com.google.guava:guava:27.0.1-jre' // or, for Android: api 'com.google.guava:guava:27.0.1-android' }
public static final ImmutableSet<String> COLOR_NAMES = ImmutableSet.of( "red", "orange", "yellow", "green", "blue", "purple"); class Foo { final ImmutableSet<Bar> bars; Foo(Set<Bar> bars) { this.bars = ImmutableSet.copyOf(bars); // defensive copy! } }
Immutable objects have many advantages, including:api
Making immutable copies of objects is a good defensive programming technique. Guava provides simple, easy-to-use immutable versions of each standard Collection
type, including Guava's own Collection
variations.ide
The JDK provides Collections.unmodifiableXXX
methods, but in our opinion, these can begradle
When you don't expect to modify a collection, or expect a collection to remain constant, it's a good practice to defensively copy it into an immutable collection.ui
Important: Each of the Guava immutable collection implementations rejects null values. We did an exhaustive study on Google's internal code base that indicated that null
elements were allowed in collections about 5% of the time, and the other 95% of cases were best served by failing fast on nulls. If you need to use null values, consider using Collections.unmodifiableList
and its friends on a collection implementation that permits null. More detailed suggestions can be found here.this
An ImmutableXXX
collection can be created in several ways:
copyOf
method, for example, ImmutableSet.copyOf(set)
of
method, for example, ImmutableSet.of("a", "b", "c")
or ImmutableMap.of("a", 1, "b", 2)
Builder
, for example,
public static final ImmutableSet<Color> GOOGLE_COLORS = ImmutableSet.<Color>builder() .addAll(WEBSAFE_COLORS) .add(new Color(0, 191, 255)) .build();
Except for sorted collections, order is preserved from construction time. For example,
ImmutableSet.of("a", "b", "c", "a", "d", "b")
will iterate over its elements in the order "a", "b", "c", "d".
copyOf
is smarter than you thinkIt is useful to remember that ImmutableXXX.copyOf
attempts to avoid copying the data when it is safe to do so -- the exact details are unspecified, but the implementation is typically "smart". For example,
ImmutableSet<String> foobar = ImmutableSet.of("foo", "bar", "baz"); thingamajig(foobar); void thingamajig(Collection<String> collection) { ImmutableList<String> defensiveCopy = ImmutableList.copyOf(collection); ... }
In this code, ImmutableList.copyOf(foobar)
will be smart enough to just return foobar.asList()
, which is a constant-time view of the ImmutableSet
.
As a general heuristic, ImmutableXXX.copyOf(ImmutableCollection)
tries to avoid a linear-time copy if
ImmutableSet.copyOf(ImmutableList)
can't be done in constant time.ImmutableList<String> hugeList
, and you do ImmutableList.copyOf(hugeList.subList(0, 10))
, an explicit copy is performed, so as to avoid accidentally holding on to references in hugeList
that aren't needed.ImmutableSet.copyOf(myImmutableSortedSet)
will perform an explicit copy, because the hashCode()
and equals
used by ImmutableSet
have different semantics from the comparator-based behavior of ImmutableSortedSet
.This helps minimize the performance overhead of good defensive programming style.
asList
All immutable collections provide an ImmutableList
view via asList()
, so -- for example -- even if you have data stored as an ImmutableSortedSet
, you can get the k
th smallest element with sortedSet.asList().get(k)
.
The returned ImmutableList
is frequently -- not always, but frequently -- a constant-overhead view, rather than an explicit copy. That said, it's often smarter than your average List
-- for example, it'll use the efficient contains
methods of the backing collection.
Interface | JDK or Guava? | Immutable Version |
---|---|---|
Collection |
JDK | ImmutableCollection |
List |
JDK | ImmutableList |
Set |
JDK | ImmutableSet |
SortedSet /NavigableSet |
JDK | ImmutableSortedSet |
Map |
JDK | ImmutableMap |
SortedMap |
JDK | ImmutableSortedMap |
Multiset |
Guava | ImmutableMultiset |
SortedMultiset |
Guava | ImmutableSortedMultiset |
Multimap |
Guava | ImmutableMultimap |
ListMultimap |
Guava | ImmutableListMultimap |
SetMultimap |
Guava | ImmutableSetMultimap |
BiMap |
Guava | ImmutableBiMap |
ClassToInstanceMap |
Guava | ImmutableClassToInstanceMap |
Table |
Guava | ImmutableTable |
Google Guava官方教程(中文版)
Google Guava官方教程(英文版)