| Package | Description |
|---|---|
| com.google.common.base |
Basic utility libraries and interfaces.
|
| com.google.common.cache |
This package contains caching utilities.
|
| com.google.common.collect |
This package contains generic collection interfaces and implementations, and
other utilities for working with collections.
|
| com.google.common.escape |
Interfaces, utilities, and simple implementations of escapers and encoders.
|
| com.google.common.util.concurrent |
Concurrency utilities.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Converter<A,B>
A function from
A to B with an associated reverse function from B
to A; used for converting back and forth between different representations of the same
information. |
| Modifier and Type | Method and Description |
|---|---|
static <A,B,C> Function<A,C> |
Functions.compose(Function<B,C> g,
Function<A,? extends B> f)
Returns the composition of two functions.
|
static <E> Function<Object,E> |
Functions.constant(E value)
Creates a function that returns
value for any input. |
static <K,V> Function<K,V> |
Functions.forMap(Map<K,? extends V> map,
V defaultValue)
Returns a function which performs a map lookup with a default value.
|
static <K,V> Function<K,V> |
Functions.forMap(Map<K,V> map)
Returns a function which performs a map lookup.
|
static <T> Function<T,Boolean> |
Functions.forPredicate(Predicate<T> predicate)
Creates a function that returns the same boolean output as the given predicate for all inputs.
|
static <T> Function<Object,T> |
Functions.forSupplier(Supplier<T> supplier)
Returns a function that always returns the result of invoking
Supplier.get() on supplier, regardless of its input. |
static <E> Function<E,E> |
Functions.identity()
Returns the identity function.
|
static <T> Function<Supplier<T>,T> |
Suppliers.supplierFunction()
Returns a function that accepts a supplier and returns the result of
invoking
Supplier.get() on that supplier. |
static Function<Object,String> |
Functions.toStringFunction()
Returns a function that calls
toString() on its argument. |
| Modifier and Type | Method and Description |
|---|---|
static <F,T> Supplier<T> |
Suppliers.compose(Function<? super F,T> function,
Supplier<F> supplier)
Returns a new supplier which is the composition of the provided function
and supplier.
|
static <A,B,C> Function<A,C> |
Functions.compose(Function<B,C> g,
Function<A,? extends B> f)
Returns the composition of two functions.
|
static <A,B,C> Function<A,C> |
Functions.compose(Function<B,C> g,
Function<A,? extends B> f)
Returns the composition of two functions.
|
static <A,B> Predicate<A> |
Predicates.compose(Predicate<B> predicate,
Function<A,? extends B> function)
Returns the composition of a function and a predicate.
|
static <A,B> Converter<A,B> |
Converter.from(Function<? super A,? extends B> forwardFunction,
Function<? super B,? extends A> backwardFunction)
Returns a converter based on existing forward and backward functions.
|
static <A,B> Converter<A,B> |
Converter.from(Function<? super A,? extends B> forwardFunction,
Function<? super B,? extends A> backwardFunction)
Returns a converter based on existing forward and backward functions.
|
<F> Equivalence<F> |
Equivalence.onResultOf(Function<F,? extends T> function)
Returns a new equivalence relation for
F which evaluates equivalence by first applying
function to the argument, then evaluating using this. |
abstract <V> Optional<V> |
Optional.transform(Function<? super T,V> function)
If the instance is present, it is transformed with the given
Function; otherwise,
Optional.absent() is returned. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
LoadingCache<K,V>
A semi-persistent mapping from keys to values.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractLoadingCache<K,V>
This class provides a skeletal implementation of the
Cache interface to minimize the
effort required to implement this interface. |
class |
ForwardingLoadingCache<K,V>
A cache which forwards all its method calls to another cache.
|
static class |
ForwardingLoadingCache.SimpleForwardingLoadingCache<K,V>
A simplified version of
ForwardingLoadingCache where subclasses can pass in an already
constructed LoadingCache as the delegate. |
| Modifier and Type | Method and Description |
|---|---|
static <K,V> CacheLoader<K,V> |
CacheLoader.from(Function<K,V> function)
Returns a cache loader based on an existing function instance.
|
| Modifier and Type | Method and Description |
|---|---|
static <E> Function<E,E> |
Interners.asFunction(Interner<E> interner)
Returns a function that delegates to the
Interner.intern(E) method of the given interner. |
| Modifier and Type | Method and Description |
|---|---|
static <K,V> NavigableMap<K,V> |
Maps.asMap(NavigableSet<K> set,
Function<? super K,V> function)
Returns a view of the navigable set as a map, mapping keys from the set
according to the specified function.
|
static <K,V> Map<K,V> |
Maps.asMap(Set<K> set,
Function<? super K,V> function)
Returns a live
Map view whose keys are the contents of set
and whose values are computed on demand using function. |
static <K,V> SortedMap<K,V> |
Maps.asMap(SortedSet<K> set,
Function<? super K,V> function)
Returns a view of the sorted set as a map, mapping keys from the set
according to the specified function.
|
<K> ImmutableListMultimap<K,E> |
FluentIterable.index(Function<? super E,K> keyFunction)
Creates an index
ImmutableListMultimap that contains the results of applying a
specified function to each item in this FluentIterable of values. |
static <K,V> ImmutableListMultimap<K,V> |
Multimaps.index(Iterable<V> values,
Function<? super V,K> keyFunction)
Creates an index
ImmutableListMultimap that contains the results of
applying a specified function to each item in an Iterable of
values. |
static <K,V> ImmutableListMultimap<K,V> |
Multimaps.index(Iterator<V> values,
Function<? super V,K> keyFunction)
Creates an index
ImmutableListMultimap that contains the results of
applying a specified function to each item in an Iterator of
values. |
<F> Ordering<F> |
Ordering.onResultOf(Function<F,? extends T> function)
Returns a new ordering on
F which orders elements by first applying
a function to them, then comparing those results using this. |
<V> ImmutableMap<E,V> |
FluentIterable.toMap(Function<? super E,V> valueFunction)
Returns an immutable map whose keys are the distinct elements of this
FluentIterable
and whose value for each key was computed by valueFunction. |
static <K,V> ImmutableMap<K,V> |
Maps.toMap(Iterable<K> keys,
Function<? super K,V> valueFunction)
Returns an immutable map whose keys are the distinct elements of
keys and whose value for each key was computed by valueFunction. |
static <K,V> ImmutableMap<K,V> |
Maps.toMap(Iterator<K> keys,
Function<? super K,V> valueFunction)
Returns an immutable map whose keys are the distinct elements of
keys and whose value for each key was computed by valueFunction. |
static <F,T> Collection<T> |
Collections2.transform(Collection<F> fromCollection,
Function<? super F,T> function)
Returns a collection that applies
function to each element of
fromCollection. |
<T> FluentIterable<T> |
FluentIterable.transform(Function<? super E,T> function)
Returns a fluent iterable that applies
function to each element of this
fluent iterable. |
static <F,T> Iterable<T> |
Iterables.transform(Iterable<F> fromIterable,
Function<? super F,? extends T> function)
Returns an iterable that applies
function to each element of fromIterable. |
static <F,T> Iterator<T> |
Iterators.transform(Iterator<F> fromIterator,
Function<? super F,? extends T> function)
Returns an iterator that applies
function to each element of fromIterator. |
static <F,T> List<T> |
Lists.transform(List<F> fromList,
Function<? super F,? extends T> function)
Returns a list that applies
function to each element of fromList. |
<T> FluentIterable<T> |
FluentIterable.transformAndConcat(Function<? super E,? extends Iterable<? extends T>> function)
Applies
function to each element of this fluent iterable and returns
a fluent iterable with the concatenated combination of results. |
static <K,V1,V2> ListMultimap<K,V2> |
Multimaps.transformValues(ListMultimap<K,V1> fromMultimap,
Function<? super V1,V2> function)
Returns a view of a
ListMultimap where each value is transformed by
a function. |
static <K,V1,V2> Map<K,V2> |
Maps.transformValues(Map<K,V1> fromMap,
Function<? super V1,V2> function)
Returns a view of a map where each value is transformed by a function.
|
static <K,V1,V2> Multimap<K,V2> |
Multimaps.transformValues(Multimap<K,V1> fromMultimap,
Function<? super V1,V2> function)
Returns a view of a multimap where each value is transformed by a function.
|
static <K,V1,V2> NavigableMap<K,V2> |
Maps.transformValues(NavigableMap<K,V1> fromMap,
Function<? super V1,V2> function)
Returns a view of a navigable map where each value is transformed by a
function.
|
static <K,V1,V2> SortedMap<K,V2> |
Maps.transformValues(SortedMap<K,V1> fromMap,
Function<? super V1,V2> function)
Returns a view of a sorted map where each value is transformed by a
function.
|
static <R,C,V1,V2> |
Tables.transformValues(Table<R,C,V1> fromTable,
Function<? super V1,V2> function)
Returns a view of a table where each value is transformed by a function.
|
<K> ImmutableMap<K,E> |
FluentIterable.uniqueIndex(Function<? super E,K> keyFunction)
Returns a map with the contents of this
FluentIterable as its values, indexed
by keys derived from those values. |
static <K,V> ImmutableMap<K,V> |
Maps.uniqueIndex(Iterable<V> values,
Function<? super V,K> keyFunction)
Returns a map with the given
values, indexed by keys derived from
those values. |
static <K,V> ImmutableMap<K,V> |
Maps.uniqueIndex(Iterator<V> values,
Function<? super V,K> keyFunction)
Returns a map with the given
values, indexed by keys derived from
those values. |
| Modifier and Type | Method and Description |
|---|---|
Function<String,String> |
Escaper.asFunction()
Returns a
Function that invokes Escaper.escape(String) on this escaper. |
| Modifier and Type | Method and Description |
|---|---|
static <V,X extends Throwable> |
Futures.catching(ListenableFuture<? extends V> input,
Class<X> exceptionType,
Function<? super X,? extends V> fallback)
Returns a
Future whose result is taken from the given primary input or, if the
primary input fails with the given exceptionType, from the result provided by the
fallback. |
static <V,X extends Throwable> |
Futures.catching(ListenableFuture<? extends V> input,
Class<X> exceptionType,
Function<? super X,? extends V> fallback,
Executor executor)
Returns a
Future whose result is taken from the given primary input or, if the
primary input fails with the given exceptionType, from the result provided by the
fallback. |
static <I,O> Future<O> |
Futures.lazyTransform(Future<I> input,
Function<? super I,? extends O> function)
Like
Futures.transform(ListenableFuture, Function) except that the
transformation function is invoked on each call to
get() on the returned future. |
static <V,X extends Exception> |
Futures.makeChecked(ListenableFuture<V> future,
Function<? super Exception,X> mapper)
Creates a
CheckedFuture out of a normal ListenableFuture and a Function
that maps from Exception instances into the appropriate checked type. |
static <I,O> ListenableFuture<O> |
Futures.transform(ListenableFuture<I> input,
Function<? super I,? extends O> function)
Returns a new
ListenableFuture whose result is the product of
applying the given Function to the result of the given Future. |
static <I,O> ListenableFuture<O> |
Futures.transform(ListenableFuture<I> input,
Function<? super I,? extends O> function,
Executor executor)
Returns a new
ListenableFuture whose result is the product of
applying the given Function to the result of the given Future. |
Copyright © 2010-2015. All Rights Reserved.