/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of {@code fromCollection}. * The returned collection is a live view of {@code fromCollection}; changes to one affect the * other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods throw an {@link * UnsupportedOperationException}. All other collection methods are supported, as long as {@code * fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the transformed collection * and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider {@link * Lists#transform}. If only an {@code Iterable} is available, use {@link Iterables#transform}. * * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#map Stream.map}. */ public static <F, T> Collection<T> transform( Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of {@code fromCollection}. * The returned collection is a live view of {@code fromCollection}; changes to one affect the * other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods throw an {@link * UnsupportedOperationException}. All other collection methods are supported, as long as {@code * fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the transformed collection * and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider {@link * Lists#transform}. If only an {@code Iterable} is available, use {@link Iterables#transform}. * * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#map Stream.map}. */ public static <F, T> Collection<T> transform( Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform( Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of * {@code fromCollection}. The returned collection is a live view of {@code * fromCollection}; changes to one affect the other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods * throw an {@link UnsupportedOperationException}. All other collection * methods are supported, as long as {@code fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if * {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the * transformed collection and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider * {@link Lists#transform}. If only an {@code Iterable} is available, use * {@link Iterables#transform}. */ public static <F, T> Collection<T> transform(Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<F, T>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of {@code fromCollection}. * The returned collection is a live view of {@code fromCollection}; changes to one affect the * other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods throw an {@link * UnsupportedOperationException}. All other collection methods are supported, as long as {@code * fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the transformed collection * and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider {@link * Lists#transform}. If only an {@code Iterable} is available, use {@link Iterables#transform}. * * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#map Stream.map}. */ public static <F, T> Collection<T> transform( Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of {@code fromCollection}. * The returned collection is a live view of {@code fromCollection}; changes to one affect the * other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods throw an {@link * UnsupportedOperationException}. All other collection methods are supported, as long as {@code * fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the transformed collection * and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider {@link * Lists#transform}. If only an {@code Iterable} is available, use {@link Iterables#transform}. * * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#map Stream.map}. */ public static <F, T> Collection<T> transform( Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<>(fromCollection, function); }
/** * Returns a collection that applies {@code function} to each element of {@code fromCollection}. * The returned collection is a live view of {@code fromCollection}; changes to one affect the * other. * * <p>The returned collection's {@code add()} and {@code addAll()} methods throw an {@link * UnsupportedOperationException}. All other collection methods are supported, as long as {@code * fromCollection} supports them. * * <p>The returned collection isn't threadsafe or serializable, even if {@code fromCollection} is. * * <p>When a live view is <i>not</i> needed, it may be faster to copy the transformed collection * and use the copy. * * <p>If the input {@code Collection} is known to be a {@code List}, consider {@link * Lists#transform}. If only an {@code Iterable} is available, use {@link Iterables#transform}. * * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#map Stream.map}. */ public static <F, T> Collection<T> transform( Collection<F> fromCollection, Function<? super F, T> function) { return new TransformedCollection<>(fromCollection, function); }