Example
public static void testImmutableCollect(){
final ImmutableSet<String> COLOR_NAMES = ImmutableSet.of(
"1", "2", "3", "4", "5", "6");
System.out.println("COLOR_NAMES = " + COLOR_NAMES);
final ImmutableSet<String> immutableSet2 = ImmutableSet.copyOf(COLOR_NAMES);
System.out.println("immutableSet2 = " + immutableSet2);
}
Why?
Immutable objects have many advantages, including:
- Safe for use by untrusted libraries.
- Thread-safe: can be used by many threads with no risk of race conditions.
- Doesn't need to support mutation, and can make time and space savings with that assumption. All immutable collection implementations are more memory-efficient than their mutable siblings.
- Can be used as a constant, with the expectation that it will remain fixed.
The JDK provides Collections.unmodifiableXXX methods, but in our opinion, these can be
- unwieldy and verbose; unpleasant to use everywhere you want to make defensive copies
- unsafe: the returned collections are only truly immutable if nobody holds a reference to the original collection
- inefficient: the data structures still have all the overhead of mutable collections, including concurrent modification checks, extra space in hash tables, etc.
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.
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
How?
// use of
final ImmutableSet<String> COLOR_NAMES = ImmutableSet.of(
"1", "2", "3", "4", "5", "6");
System.out.println("COLOR_NAMES = " + COLOR_NAMES);
// use copyOf
final ImmutableSet<String> immutableSet2 = ImmutableSet.copyOf(COLOR_NAMES);
System.out.println("immutableSet2 = " + immutableSet2);
// use builder
final ImmutableSet<String> immutableSet3 = ImmutableSet.<String>builder()
.addAll(COLOR_NAMES)
.add("a", "b", "c").build();
System.out.println("immutableSet3 = " + immutableSet3);
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 kth 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.
网友评论