org.eclipse.collections.api.collection.MutableCollection Maven / Gradle / Ivy
/*
* Copyright (c) 2016 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.api.collection;
import java.util.Collection;
import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.block.function.Function;
import org.eclipse.collections.api.block.function.Function0;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.function.Function3;
import org.eclipse.collections.api.block.function.primitive.BooleanFunction;
import org.eclipse.collections.api.block.function.primitive.ByteFunction;
import org.eclipse.collections.api.block.function.primitive.CharFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleFunction;
import org.eclipse.collections.api.block.function.primitive.FloatFunction;
import org.eclipse.collections.api.block.function.primitive.IntFunction;
import org.eclipse.collections.api.block.function.primitive.LongFunction;
import org.eclipse.collections.api.block.function.primitive.ShortFunction;
import org.eclipse.collections.api.block.predicate.Predicate;
import org.eclipse.collections.api.block.predicate.Predicate2;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.block.procedure.Procedure2;
import org.eclipse.collections.api.collection.primitive.MutableBooleanCollection;
import org.eclipse.collections.api.collection.primitive.MutableByteCollection;
import org.eclipse.collections.api.collection.primitive.MutableCharCollection;
import org.eclipse.collections.api.collection.primitive.MutableDoubleCollection;
import org.eclipse.collections.api.collection.primitive.MutableFloatCollection;
import org.eclipse.collections.api.collection.primitive.MutableIntCollection;
import org.eclipse.collections.api.collection.primitive.MutableLongCollection;
import org.eclipse.collections.api.collection.primitive.MutableShortCollection;
import org.eclipse.collections.api.list.MutableList;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.map.primitive.MutableObjectDoubleMap;
import org.eclipse.collections.api.map.primitive.MutableObjectLongMap;
import org.eclipse.collections.api.multimap.MutableMultimap;
import org.eclipse.collections.api.ordered.OrderedIterable;
import org.eclipse.collections.api.partition.PartitionMutableCollection;
import org.eclipse.collections.api.tuple.Pair;
import org.eclipse.collections.api.tuple.Twin;
/**
* MutableCollection is an interface which extends the base java.util.Collection interface and adds several internal
* iterator methods, from the Smalltalk Collection protocol. These include variations of forEach, select, reject,
* detect, collect, injectInto, anySatisfy, allSatisfy. These include count, remove, partition, collectIf. The API also
* includes converter methods to convert a MutableCollection to a List (toList), to a sorted List (toSortedList), to a
* Set (toSet), and to a Map (toMap).
*
* There are several extensions to MutableCollection, including MutableList, MutableSet, and MutableBag.
*/
public interface MutableCollection
extends Collection, RichIterable
{
/**
* This method allows mutable and fixed size collections the ability to add elements to their existing elements.
* In order to support fixed size a new instance of a collection would have to be returned taking the elements of
* the original collection and appending the new element to form the new collection. In the case of mutable
* collections, the original collection is modified, and is returned. In order to use this method properly with
* mutable and fixed size collections the following approach must be taken:
*
*
* MutableCollection list;
* list = list.with("1");
* list = list.with("2");
* return list;
*
* In the case of {@link FixedSizeCollection} a new instance of MutableCollection will be returned by with, and any
* variables that previously referenced the original collection will need to be redirected to reference the
* new instance. For other MutableCollection types you will replace the reference to collection with the same
* collection, since the instance will return "this" after calling add on itself.
*
* @see #add(Object)
*/
MutableCollection with(T element);
/**
* This method allows mutable and fixed size collections the ability to remove elements from their existing elements.
* In order to support fixed size a new instance of a collection would have to be returned contaning the elements
* that would be left from the original collection after calling remove. In the case of mutable collections, the
* original collection is modified, and is returned. In order to use this method properly with mutable and fixed
* size collections the following approach must be taken:
*
*
* MutableCollection list;
* list = list.without("1");
* list = list.without("2");
* return list;
*
* In the case of {@link FixedSizeCollection} a new instance of MutableCollection will be returned by without, and
* any variables that previously referenced the original collection will need to be redirected to reference the
* new instance. For other MutableCollection types you will replace the reference to collection with the same
* collection, since the instance will return "this" after calling remove on itself.
*
* @see #remove(Object)
*/
MutableCollection without(T element);
/**
* This method allows mutable and fixed size collections the ability to add multiple elements to their existing
* elements. In order to support fixed size a new instance of a collection would have to be returned taking the
* elements of the original collection and appending the new elements to form the new collection. In the case of
* mutable collections, the original collection is modified, and is returned. In order to use this method properly
* with mutable and fixed size collections the following approach must be taken:
*
*
* MutableCollection list;
* list = list.withAll(FastList.newListWith("1", "2"));
* return list;
*
* In the case of {@link FixedSizeCollection} a new instance of MutableCollection will be returned by withAll, and
* any variables that previously referenced the original collection will need to be redirected to reference the
* new instance. For other MutableCollection types you will replace the reference to collection with the same
* collection, since the instance will return "this" after calling addAll on itself.
*
* @see #addAll(Collection)
*/
MutableCollection withAll(Iterable elements);
/**
* This method allows mutable and fixed size collections the ability to remove multiple elements from their existing
* elements. In order to support fixed size a new instance of a collection would have to be returned contaning the
* elements that would be left from the original collection after calling removeAll. In the case of mutable
* collections, the original collection is modified, and is returned. In order to use this method properly with
* mutable and fixed size collections the following approach must be taken:
*
*
* MutableCollection list;
* list = list.withoutAll(FastList.newListWith("1", "2"));
* return list;
*
* In the case of {@link FixedSizeCollection} a new instance of MutableCollection will be returned by withoutAll,
* and any variables that previously referenced the original collection will need to be redirected to reference the
* new instance. For other MutableCollection types you will replace the reference to collection with the same
* collection, since the instance will return "this" after calling removeAll on itself.
*
* @see #removeAll(Collection)
*/
MutableCollection withoutAll(Iterable elements);
/**
* Creates a new empty mutable version of the same collection type. For example, if this instance is a FastList,
* this method will return a new empty FastList. If the class of this instance is immutable or fixed size (i.e.
* SingletonList) then a mutable alternative to the class will be provided.
*/
MutableCollection newEmpty();
@Override
MutableCollection tap(Procedure procedure);
/**
* Returns a MutableCollection with all elements that evaluate to true for the specified predicate.
*
*
e.g.
* return people.select(new Predicate<Person>()
* {
* public boolean value(Person person)
* {
* return person.getAddress().getCity().equals("Metuchen");
* }
* });
*
*/
@Override
MutableCollection select(Predicate predicate);
/**
* Returns a MutableCollection with all elements that evaluate to true for the specified predicate2 and parameter.
*
*
e.g.
* return integers.selectWith(PredicatesLite.equal(), Integer.valueOf(5));
*
*/
@Override
MutableCollection selectWith(Predicate2 predicate, P parameter);
/**
* Returns a MutableCollection with all elements that evaluate to false for the specified predicate.
*
*
e.g.
* return people.reject(new Predicate<Person>()
* {
* public boolean value(Person person)
* {
* return person.person.getLastName().equals("Smith");
* }
* });
*
*
*
e.g.
* return people.reject(Predicates.attributeEqual("lastName", "Smith"));
*
*/
@Override
MutableCollection reject(Predicate predicate);
/**
* Returns a MutableCollection with all elements that evaluate to false for the specified predicate2 and parameter.
*
*
e.g.
* return integers.rejectWith(PredicatesLite.equal(), Integer.valueOf(5));
*
*/
@Override
MutableCollection rejectWith(
Predicate2 predicate,
P parameter);
/**
* Filters a collection into two separate collections based on a predicate returned via a Pair.
*
*
e.g.
* return lastNames.selectAndRejectWith(PredicatesLite.lessThan(), "Mason");
*
*
* @deprecated since 6.0 use {@link RichIterable#partitionWith(Predicate2, Object)} instead.
*/
@Deprecated
Twin> selectAndRejectWith(
Predicate2 predicate,
P parameter);
@Override
PartitionMutableCollection partition(Predicate predicate);
@Override
PartitionMutableCollection partitionWith(Predicate2 predicate, P parameter);
@Override
MutableCollection selectInstancesOf(Class clazz);
/**
* Removes all elements in the collection that evaluate to true for the specified predicate.
*
*
e.g.
* return lastNames.removeIf(Predicates.isNull());
*
*/
boolean removeIf(Predicate predicate);
/**
* Removes all elements in the collection that evaluate to true for the specified predicate2 and parameter.
*
*
e.g.
* return lastNames.removeIfWith(PredicatesLite.isNull(), null);
*
*/
boolean removeIfWith(Predicate2 predicate, P parameter);
/**
* Returns a new MutableCollection with the results of applying the specified function to each element of the source
* collection.
*
*
e.g.
* return people.collect(new Function<Person, String>()
* {
* public String value(Person person)
* {
* return person.getFirstName() + " " + person.getLastName();
* }
* });
*
*/
@Override
MutableCollection collect(Function function);
@Override
MutableBooleanCollection collectBoolean(BooleanFunction booleanFunction);
@Override
MutableByteCollection collectByte(ByteFunction byteFunction);
@Override
MutableCharCollection collectChar(CharFunction charFunction);
@Override
MutableDoubleCollection collectDouble(DoubleFunction doubleFunction);
@Override
MutableFloatCollection collectFloat(FloatFunction floatFunction);
@Override
MutableIntCollection collectInt(IntFunction intFunction);
@Override
MutableLongCollection collectLong(LongFunction longFunction);
@Override
MutableShortCollection collectShort(ShortFunction shortFunction);
@Override
MutableCollection collectWith(Function2 function, P parameter);
/**
* Returns a new MutableCollection with the results of applying the specified function to each element of the source
* collection, but only for elements that evaluate to true for the specified predicate.
*
*
e.g.
* Lists.mutable.of().with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString())
*
*/
@Override
MutableCollection collectIf(Predicate predicate, Function function);
@Override
MutableCollection flatCollect(Function> function);
IV injectIntoWith(
IV injectValue,
Function3 function,
P parameter);
/**
* Returns an unmodifiable view of this collection. This method allows modules to provide users with "read-only"
* access to internal collections. Query operations on the returned collection "read through" to this collection,
* and attempts to modify the returned collection, whether direct or via its iterator, result in an
* UnsupportedOperationException.
*
* The returned collection does not pass the hashCode and equals operations through to the backing
* collection, but relies on Object's equals and hashCode methods. This is necessary to
* preserve the contracts of these operations in the case that the backing collection is a set or a list.
*
* The returned collection will be serializable if this collection is serializable.
*
* @return an unmodifiable view of this collection.
* @since 1.0
*/
MutableCollection asUnmodifiable();
/**
* Returns a synchronized (thread-safe) collection backed by this collection. In order to guarantee serial access,
* it is critical that all access to the backing collection is accomplished through the returned
* collection.
*
* It is imperative that the user manually synchronize on the returned collection when iterating over it using the
* standard JDK iterator or JDK 5 for loop.
*
* MutableCollection collection = myCollection.asSynchronized();
* ...
* synchronized(collection)
* {
* Iterator i = c.iterator(); // Must be in the synchronized block
* while (i.hasNext())
* foo(i.next());
* }
*
* Failure to follow this advice may result in non-deterministic behavior.
*
* The preferred way of iterating over a synchronized collection is to use the collection.forEach() method which is
* properly synchronized internally.
*
* MutableCollection collection = myCollection.asSynchronized();
* ...
* collection.forEach(new Procedure()
* {
* public void value(Object each)
* {
* ...
* }
* });
*
*
* The returned collection does not pass the hashCode and equals operations through to the
* backing collection, but relies on Object's equals and hashCode methods. This is necessary to preserve
* the contracts of these operations in the case that the backing collection is a set or a list.
*
* The returned collection will be serializable if this collection is serializable.
*
* @return a synchronized view of this collection.
* @since 1.0
*/
MutableCollection asSynchronized();
/**
* Converts this MutableCollection to an ImmutableCollection.
*
* @since 1.0
*/
ImmutableCollection toImmutable();
@Override
MutableObjectLongMap sumByInt(Function groupBy, IntFunction function);
@Override
MutableObjectDoubleMap sumByFloat(Function groupBy, FloatFunction function);
@Override
MutableObjectLongMap sumByLong(Function groupBy, LongFunction function);
@Override
MutableObjectDoubleMap sumByDouble(Function groupBy, DoubleFunction function);
@Override
MutableMultimap groupBy(Function function);
@Override
MutableMultimap groupByEach(Function> function);
@Override
MutableMap groupByUniqueKey(Function function);
/**
* @deprecated in 6.0. Use {@link OrderedIterable#zip(Iterable)} instead.
*/
@Override
@Deprecated
MutableCollection> zip(Iterable that);
/**
* @deprecated in 6.0. Use {@link OrderedIterable#zipWithIndex()} instead.
*/
@Override
@Deprecated
MutableCollection> zipWithIndex();
/**
* @see #addAll(Collection)
* @since 1.0
*/
boolean addAllIterable(Iterable iterable);
/**
* @see #removeAll(Collection)
* @since 1.0
*/
boolean removeAllIterable(Iterable iterable);
/**
* @see #retainAll(Collection)
* @since 1.0
*/
boolean retainAllIterable(Iterable iterable);
@Override
MutableMap aggregateInPlaceBy(
Function groupBy,
Function0 zeroValueFactory,
Procedure2 mutatingAggregator);
@Override
MutableMap aggregateBy(
Function groupBy,
Function0 zeroValueFactory,
Function2 nonMutatingAggregator);
}