jaggregate
Class SortedCollection<E>

java.lang.Object
  jaggregate.AbstractCollection<E>
      jaggregate.AbstractExtensibleCollection<E>
          jaggregate.SortedCollection<E>

Type Parameters:

E - A restriction on the types of elements that may be included in the collection

All Implemented Interfaces:

Collection<E>, ContractibleSequence<E>, ExtensibleCollection<E>, ReadOnlySequence<E>, Serializable

Direct Known Subclasses:

NaturallySortedCollection

public class SortedCollection<E>
extends AbstractExtensibleCollection<E>
implements ContractibleSequence<E>, ReadOnlySequence<E>, Serializable

Represents a variable-sized collection of objects whose elements are ordered based on a sort order. The sort order is specified by a comparator. Elements may be added, removed, or inserted, and can be accessed using external integer keys.

Version:

$Id: SortedCollection.java,v 1.9 2008/10/03 19:01:23 pholser Exp $

Author:

Paul Holser

See Also:

Serialized Form

Constructor Summary

SortedCollection(Comparator<? super E> comparator)
Creates an empty sorted collection whose elements are sorted using the given comparator.

SortedCollection(Comparator<? super E> comparator, Collection<? extends E> newElements)
Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given collection.

SortedCollection(Comparator<? super E> comparator, E... newElements)
Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given array.

SortedCollection(Comparator<? super E> comparator, Iterable<? extends E> newElements)
Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given iterable.

Method Summary

void	add(E newElement) Adds a new element to this collection.
E	after(E target) Answers the object immediately following the first element which is equivalent to the given target in this sequence.
E	at(int index) Answers the element at the given position in this sequence.
E	before(E target) Answers the object immediately preceding the first element which is equivalent to the given target in this sequence.
<R> OrderedCollection<R>	collect(UnaryFunctor<? super E,? extends R> transformer) Evaluates the given transformer for each element of this collection, with the element as the parameter, and answers a new collection containing the results of these evaluations. The elements are traversed in the order specified by forEachDo for this collection. Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection.
Comparator<? super E>	comparator() Answers the comparator which is used to order this collection's elements.
SortedCollection<E>	concat(ReadOnlySequence<? extends E> otherSequence) Answers a new sequence containing all of this sequence's elements in their original order followed by all of the elements of the given sequence, in their original order. Since this collection sorts its elements, the result will also be sorted as defined by this collection's comparator.
SortedCollection<E>	copyRange(int start, int stop) Answers a new sequence containing the specified range of elements of this sequence in their original order.
SortedCollection<E>	copyWith(E newElement) Answers a new sequence with size one greater than the size of this sequence, containing the elements of this sequence and a given new element placed at the end.
SortedCollection<E>	copyWithout(E oldElement) Answers a new sequence with all of the elements of this sequence that are not equivalent to the given element, in their original order.
void	doWithIndex(BinaryFunctor<? super Integer,? super E,?> operation) Evaluates the given operation with the index of each element of this sequence, in order, together with the element itself.
<T> void	doWithOthers(ReadOnlySequence<? extends T> otherSequence, BinaryFunctor<? super E,? super T,?> operation) For each element of this sequence and the corresponding element of the given sequence, evaluates the given operation with this sequence's element as the first parameter, and the element of the other sequence as the second parameter.
static <T> SortedCollection<T>	emptySortedCollection(Comparator<? super T> comparator) Creates an empty sorted collection whose elements are sorted using the given comparator.
boolean	equals(Object that)
int	findFirst(UnaryCondition<? super E> discriminator) Answers the index of the first element which causes the given discriminator to answer true when the element is used as a parameter.
int	findLast(UnaryCondition<? super E> discriminator) Answers the index of the last element which causes the given discriminator to answer true when the element is used as a parameter.
E	first() Answers the element at index 0 in this sequence.
void	forEachDo(UnaryFunctor<? super E,?> operation) For each element of this collection, evaluates the given operation with the element as the parameter.
void	forEachInRangeDo(int start, int stop, UnaryFunctor<? super E,?> operation) For those elements of this sequence between two given positions, inclusive, evaluates the given operation with the element at that index as its argument.
void	forEachInRangeDoWithIndex(int start, int stop, BinaryFunctor<? super Integer,? super E,?> operation) For those elements of this sequence between two given positions, inclusive, evaluates the given operation with an element of this sequence as the first argument and the element's position (index) as the second.
void	forEachInReverseDo(UnaryFunctor<? super E,?> operation) Evaluates the given operation with each element of this sequence in the reverse of this sequence's standard traversal order.
int	hashCode()
int	indexOf(E target) Answers the index of the first element which is equivalent to the given target}.
int	indexOf(ReadOnlySequence<? extends E> targetSequence, int start) Answers the index of the first element of this sequence which is the start of a subsequence which matches a given target sequence.
E	last() Answers the last element of this sequence, the element at the index equal to this sequence's size minus 1.
SortedCollection<E>	reject(UnaryCondition<? super E> discriminator) Answers a new collection which contains only the elements in this collection which cause the given discriminator to answer false. For each element of this collection, discriminator is evaluated with the element as the parameter. Each element which causes discriminator to answer false is included in the new collection. The elements are traversed in the order specified by forEachDo for this collection. Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection. If both this collection and the result maintain an ordering of their elements, the elements of the result will be in the same relative order as the elements of this collection.
boolean	remove(E oldElement) Removes the first element of this collection which is equivalent to the given element.
E	removeAt(int index) Removes and answers the element at a given position in this sequence.
E	removeFirst() Removes and answers the first element of this sequence.
boolean	removeIf(UnaryCondition<? super E> discriminator) Removes each element of this collection which causes the given discriminator to answer true. The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.
E	removeLast() Removes and answers the last element of this sequence.
boolean	retainIf(UnaryCondition<? super E> discriminator) Removes each element of this collection which causes the given discriminator to answer false. The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.
ReadOnlySequence<E>	reverse() Answers a sequence with the elements of this sequence arranged in reverse order.
SortedCollection<E>	select(UnaryCondition<? super E> discriminator) Answers a new collection which contains only the elements in this collection which cause the given discriminator to answer true. For each element of this collection, discriminator is evaluated with the element as the parameter. Each element which causes discriminator to answer true is included in the new collection. The elements are traversed in order specified by forEachDo for this collection. Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection. If both this collection and the result maintain an ordering of their elements, the elements of the result will be in the same relative order as the elements of this collection.
int	size() Answers the number of elements in this collection.
static <T> SortedCollection<T>	sortedCollectionFrom(Comparator<? super T> comparator, Collection<? extends T> newElements) Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given collection.
static <T> SortedCollection<T>	sortedCollectionFrom(Comparator<? super T> comparator, Iterable<? extends T> newElements) Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given iterable.
static <T> SortedCollection<T>	sortedCollectionWith(Comparator<? super T> comparator, T... newElements) Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given array.
SortedCollection<E>	toSortedCollection() Answers a sorted collection with the same elements as this collection. If this collection has established an ordering on its elements, then that ordering is used in the answer. Otherwise, order of the elements is arbitrary--in such a case, one should probably use the overload of this method that accepts a comparator. Answers self.
String	toString()

Methods inherited from class jaggregate.AbstractExtensibleCollection

addAll, addAll, addAll, addAll, removeAll, removeAll, removeAll, removeAll, retainAll, retainAll, retainAll, retainAll

Methods inherited from class jaggregate.AbstractCollection

allSatisfy, anySatisfy, detect, includes, inject, isEmpty, occurrencesOf, rehash, toArray, toArray, toBag, toIdentityBag, toIdentitySet, toOrderedCollection, toSet, toSortedCollection

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface jaggregate.Collection

allSatisfy, anySatisfy, detect, includes, inject, isEmpty, occurrencesOf, rehash, toArray, toArray, toBag, toIdentityBag, toIdentitySet, toOrderedCollection, toSet, toSortedCollection

Methods inherited from interface jaggregate.Collection

allSatisfy, anySatisfy, detect, includes, inject, isEmpty, occurrencesOf, rehash, toArray, toArray, toBag, toIdentityBag, toIdentitySet, toOrderedCollection, toSet, toSortedCollection

Constructor Detail

SortedCollection

public SortedCollection(Comparator<? super E> comparator)

Creates an empty sorted collection whose elements are sorted using the given comparator.

Parameters:

comparator - the comparator with which to compare elements for sorting

Throws:

NullPointerException - if comparator is null

SortedCollection

public SortedCollection(Comparator<? super E> comparator,
                        Collection<? extends E> newElements)

Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given collection.

Parameters:

comparator - the comparator with which to compare elements for sorting

newElements - the elements to add to the new collection

Throws:

NullPointerException - if either comparator or newElements is null

SortedCollection

public SortedCollection(Comparator<? super E> comparator,
                        E... newElements)

Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given array.

Parameters:

comparator - the comparator with which to compare elements for sorting

newElements - the elements to add to the new collection

Throws:

NullPointerException - if either comparator or newElements is null

SortedCollection

public SortedCollection(Comparator<? super E> comparator,
                        Iterable<? extends E> newElements)

Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given iterable.

Parameters:

comparator - the comparator with which to compare elements for sorting

newElements - the elements to add to the new collection

Throws:

NullPointerException - if either comparator or newElements is null

Method Detail

emptySortedCollection

public static <T> SortedCollection<T> emptySortedCollection(Comparator<? super T> comparator)

Creates an empty sorted collection whose elements are sorted using the given comparator.

Type Parameters:

T - the type of elements allowed in the new sorted collection

Parameters:

comparator - the comparator with which to compare elements for sorting

Returns:

the new sorted collection

Throws:

NullPointerException - if comparator is null

sortedCollectionFrom

public static <T> SortedCollection<T> sortedCollectionFrom(Comparator<? super T> comparator,
                                                           Collection<? extends T> newElements)

Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given collection.

Type Parameters:

T - the type of elements allowed in the new sorted collection

Parameters:

comparator - the comparator with which to compare elements for sorting

newElements - the elements to add to the new collection

Returns:

the new sorted collection

Throws:

NullPointerException - if either comparator or newElements is null

sortedCollectionWith

public static <T> SortedCollection<T> sortedCollectionWith(Comparator<? super T> comparator,
                                                           T... newElements)

Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given array.

Type Parameters:

T - the type of elements allowed in the new sorted collection

Parameters:

comparator - the comparator with which to compare elements for sorting

newElements - the elements to add to the new collection

Returns:

the new sorted collection

Throws:

NullPointerException - if either comparator or newElements is null

sortedCollectionFrom

public static <T> SortedCollection<T> sortedCollectionFrom(Comparator<? super T> comparator,
                                                           Iterable<? extends T> newElements)

Creates a sorted collection whose elements are sorted using the given comparator, and containing the elements of the given iterable.

Type Parameters:

T - the type of elements allowed in the new sorted collection

Parameters:

comparator - the comparator with which to compare elements for sorting

newElements - the elements to add to the new collection

Returns:

the new sorted collection

Throws:

NullPointerException - if either comparator or newElements is null

toSortedCollection

public SortedCollection<E> toSortedCollection()

Answers a sorted collection with the same elements as this collection. If this collection has established an ordering on its elements, then that ordering is used in the answer. Otherwise, order of the elements is arbitrary--in such a case, one should probably use the overload of this method that accepts a comparator.

Answers self.

Specified by:

toSortedCollection in interface Collection<E>

Overrides:

toSortedCollection in class AbstractCollection<E>

Returns:

a sorted collection of this collection's elements

collect

public <R> OrderedCollection<R> collect(UnaryFunctor<? super E,? extends R> transformer)

Evaluates the given transformer for each element of this collection, with the element as the parameter, and answers a new collection containing the results of these evaluations.

The elements are traversed in the order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection.

Specified by:

collect in interface Collection<E>

Specified by:

collect in interface ContractibleSequence<E>

Specified by:

collect in interface ExtensibleCollection<E>

Specified by:

collect in interface ReadOnlySequence<E>

Overrides:

collect in class AbstractExtensibleCollection<E>

Type Parameters:

R - return type of the transformer

Parameters:

transformer - the transformer to evaluate

Returns:

an ordered collection of the results

forEachDo

public void forEachDo(UnaryFunctor<? super E,?> operation)

For each element of this collection, evaluates the given operation with the element as the parameter.

Unless specifically refined, the elements are not traversed in a particular order. Each element is visited exactly once. Conformant protocols may refine this message to specify a particular ordering.

Specified by:

forEachDo in interface Collection<E>

Specified by:

forEachDo in interface ReadOnlySequence<E>

Parameters:

operation - the operation to perform

reject

public SortedCollection<E> reject(UnaryCondition<? super E> discriminator)

Answers a new collection which contains only the elements in this collection which cause the given discriminator to answer false.

For each element of this collection, discriminator is evaluated with the element as the parameter. Each element which causes discriminator to answer false is included in the new collection.

The elements are traversed in the order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection. If both this collection and the result maintain an ordering of their elements, the elements of the result will be in the same relative order as the elements of this collection.

Specified by:

reject in interface Collection<E>

Specified by:

reject in interface ContractibleSequence<E>

Specified by:

reject in interface ExtensibleCollection<E>

Specified by:

reject in interface ReadOnlySequence<E>

Overrides:

reject in class AbstractExtensibleCollection<E>

Parameters:

discriminator - the discriminator to evaluate

Returns:

a sorted collection of the rejects

select

public SortedCollection<E> select(UnaryCondition<? super E> discriminator)

Answers a new collection which contains only the elements in this collection which cause the given discriminator to answer true.

For each element of this collection, discriminator is evaluated with the element as the parameter. Each element which causes discriminator to answer true is included in the new collection.

The elements are traversed in order specified by forEachDo for this collection.

Unless specifically refined, this message is defined to answer an object conforming to the same protocol as this collection. If both this collection and the result maintain an ordering of their elements, the elements of the result will be in the same relative order as the elements of this collection.

Specified by:

select in interface Collection<E>

Specified by:

select in interface ContractibleSequence<E>

Specified by:

select in interface ExtensibleCollection<E>

Specified by:

select in interface ReadOnlySequence<E>

Overrides:

select in class AbstractExtensibleCollection<E>

Parameters:

discriminator - the discriminator to evaluate

Returns:

a sorted collection of the matches

size

public int size()

Answers the number of elements in this collection.

Specified by:

size in interface Collection<E>

Returns:

the number of elements in this collection

concat

public SortedCollection<E> concat(ReadOnlySequence<? extends E> otherSequence)

Answers a new sequence containing all of this sequence's elements in their original order followed by all of the elements of the given sequence, in their original order. The size of the new sequence is equal to the sum of the sizes of this sequence and otherSequence.

Sequences that enforce an ordering on their elements are permitted to refine this message to reorder the result.

Since this collection sorts its elements, the result will also be sorted as defined by this collection's comparator.

Specified by:

concat in interface ReadOnlySequence<E>

Parameters:

otherSequence -

Returns:

a sorted collection that is the concatenation of this collection and otherSequence

after

public E after(E target)

Answers the object immediately following the first element which is equivalent to the given target in this sequence. An element immediately follows another if its index is one greater than that of the other. The order used to determine which of this sequence's elements is the first to be equivalent to target is the traversal order defined by forEachDo for this sequence.

Specified by:

after in interface ReadOnlySequence<E>

Parameters:

target - the object to lookup

Returns:

the object following target

at

public E at(int index)

Answers the element at the given position in this sequence.

Specified by:

at in interface ReadOnlySequence<E>

Parameters:

index - the index to lookup

Returns:

the corresponding element

before

public E before(E target)

Answers the object immediately preceding the first element which is equivalent to the given target in this sequence. An element immediately precedes another if its index is one less than that of the other.

Specified by:

before in interface ReadOnlySequence<E>

Parameters:

target - the object to lookup

Returns:

the object preceding target

copyRange

public SortedCollection<E> copyRange(int start,
                                     int stop)

Answers a new sequence containing the specified range of elements of this sequence in their original order. The element at index start in this sequence is at index 0 in the new sequence; the element at start + 1 is at index 1, etc. If stop < start, then the new sequence is empty. Otherwise, the size of the new sequence is max(0, stop - start).

The given indices must be non-negative.

Specified by:

copyRange in interface ReadOnlySequence<E>

Parameters:

start - the beginning index

stop - the ending index

Returns:

a new sequence containing the specified range of elements

copyWith

public SortedCollection<E> copyWith(E newElement)

Answers a new sequence with size one greater than the size of this sequence, containing the elements of this sequence and a given new element placed at the end.

Unless specifically refined, this message is defined to answer an instance of the same class as this sequence.

Sequences that enforce an ordering on their elements are permitted to refine this message to reorder the result.

Specified by:

copyWith in interface ReadOnlySequence<E>

Parameters:

newElement - element to add to the copy

Returns:

copy of this sequence with newElement appended

copyWithout

public SortedCollection<E> copyWithout(E oldElement)

Answers a new sequence with all of the elements of this sequence that are not equivalent to the given element, in their original order.

Specified by:

copyWithout in interface ReadOnlySequence<E>

Parameters:

oldElement - the element to strip from the copy of this sequence

Returns:

copy of this sequence with oldElement removed

findFirst

public int findFirst(UnaryCondition<? super E> discriminator)

Answers the index of the first element which causes the given discriminator to answer true when the element is used as a parameter. Answers -1 if no such element is found.

The elements are traversed in the order specified by forEachDo for this sequence.

Specified by:

findFirst in interface ReadOnlySequence<E>

Parameters:

discriminator - the discriminator to evaluate

Returns:

the index of the first match, or -1 if there is no match

findLast

public int findLast(UnaryCondition<? super E> discriminator)

Answers the index of the last element which causes the given discriminator to answer true when the element is used as a parameter. Answers -1 if no such element is found.

The elements are traversed in the order specified by forEachInReverseDo for this sequence.

Specified by:

findLast in interface ReadOnlySequence<E>

Parameters:

discriminator - the discriminator to evaluate

Returns:

the index of the last match, or -1 if there is no match

forEachInReverseDo

public void forEachInReverseDo(UnaryFunctor<? super E,?> operation)

Evaluates the given operation with each element of this sequence in the reverse of this sequence's standard traversal order. The elements are traversed in the opposite order from forEachDo. Each element is visited exactly once.

Specified by:

forEachInReverseDo in interface ReadOnlySequence<E>

Parameters:

operation - the operation to evaluate

first

public E first()

Answers the element at index 0 in this sequence.

Specified by:

first in interface ReadOnlySequence<E>

Returns:

the first element in the sequence

forEachInRangeDo

public void forEachInRangeDo(int start,
                             int stop,
                             UnaryFunctor<? super E,?> operation)

For those elements of this sequence between two given positions, inclusive, evaluates the given operation with the element at that index as its argument.

Specified by:

forEachInRangeDo in interface ReadOnlySequence<E>

Parameters:

start - beginning index

stop - ending index

operation - the operation to evaluate

forEachInRangeDoWithIndex

public void forEachInRangeDoWithIndex(int start,
                                      int stop,
                                      BinaryFunctor<? super Integer,? super E,?> operation)

For those elements of this sequence between two given positions, inclusive, evaluates the given operation with an element of this sequence as the first argument and the element's position (index) as the second.

Specified by:

forEachInRangeDoWithIndex in interface ReadOnlySequence<E>

Parameters:

start - beginning index

stop - ending index

operation - the operation to evaluate

indexOf

public int indexOf(E target)

Answers the index of the first element which is equivalent to the given target}. Answers -1 if no such element is found.

The elements are traversed in the order specified by forEachDo for this sequence.

Specified by:

indexOf in interface ReadOnlySequence<E>

Parameters:

target - element to match

Returns:

index of first match, or -1 if no match

indexOf

public int indexOf(ReadOnlySequence<? extends E> targetSequence,
                   int start)

Answers the index of the first element of this sequence which is the start of a subsequence which matches a given target sequence.

Each subsequence of this sequence starting at index start is checked for a match with targetSequence. To match, each element of a subsequence of this sequence must be equivalent to the corresponding element of\ targetSequence. Answers the index of the first element which begins a matching subsequence; no further subsequences are considered. Answers -1 if no such subsequence is found in this sequence, or if targetSequence is empty.

The elements are traversed in the order specified by forEachDo message for this sequence.

Specified by:

indexOf in interface ReadOnlySequence<E>

Parameters:

targetSequence - sequence to match

start - index at which to begin the search

Returns:

index of the beginning of the first match, or -1 if none

doWithIndex

public void doWithIndex(BinaryFunctor<? super Integer,? super E,?> operation)

Evaluates the given operation with the index of each element of this sequence, in order, together with the element itself.

operation is evaluated with the index of each element of this sequence as the first argument and the element itself as the second argument. Evaluation is in indexed order starting at 0. The first element is at index 0, the second at index 1, etc. The index of the last element is equal to this sequence's size minus 1.

Specified by:

doWithIndex in interface ReadOnlySequence<E>

Parameters:

operation - the operation to perform

last

public E last()

Answers the last element of this sequence, the element at the index equal to this sequence's size minus 1.

Specified by:

last in interface ReadOnlySequence<E>

Returns:

the last element in the sequence

reverse

public ReadOnlySequence<E> reverse()

Answers a sequence with the elements of this sequence arranged in reverse order.

This operation is equivalent to:

1. Create a new sequence which conforms to the same protocols as this sequence.
2. Traverse the elements of this sequence in the order specified by forEachInReverseDo message, adding each element of this sequence to the new sequence.
3. Answer the new sequence.

Specified by:

reverse in interface ReadOnlySequence<E>

Returns:

a new sequence with the elements of this sequence in reverse order

doWithOthers

public <T> void doWithOthers(ReadOnlySequence<? extends T> otherSequence,
                             BinaryFunctor<? super E,? super T,?> operation)

For each element of this sequence and the corresponding element of the given sequence, evaluates the given operation with this sequence's element as the first parameter, and the element of the other sequence as the second parameter. This sequence and otherSequence must have the same size.

The elements of this sequence and otherSequence are traversed in indexed order starting at 0. The operation is evaluated with the elements at index 0 in the two sequences, then index 1, etc.

Specified by:

doWithOthers in interface ReadOnlySequence<E>

Type Parameters:

T - a constraint on the types of elements in the given sequence

Parameters:

otherSequence - the other elements to use in the evaluation

operation - the operation to perform

add

public void add(E newElement)

Adds a new element to this collection. Unless specifically refined, the position of newElement in the element traversal order is unspecified.

Conformant protocols may place restrictions on the characteristics of objects that are valid elements. Unless otherwise specified, any object that is of the same class as or of a subclass of this collection's type parameter is acceptable.

Specified by:

add in interface ExtensibleCollection<E>

Parameters:

newElement - the element to add

remove

public boolean remove(E oldElement)

Removes the first element of this collection which is equivalent to the given element.

The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.

Specified by:

remove in interface ExtensibleCollection<E>

Parameters:

oldElement - the element to remove

Returns:

true if any removal occurred

removeAt

public E removeAt(int index)

Removes and answers the element at a given position in this sequence.

Specified by:

removeAt in interface ContractibleSequence<E>

Parameters:

index - the index at which to remove the element

Returns:

the removed element

removeFirst

public E removeFirst()

Removes and answers the first element of this sequence.

Specified by:

removeFirst in interface ContractibleSequence<E>

Returns:

the removed element

removeLast

public E removeLast()

Removes and answers the last element of this sequence.

Specified by:

removeLast in interface ContractibleSequence<E>

Returns:

the removed element

removeIf

public boolean removeIf(UnaryCondition<? super E> discriminator)

Removes each element of this collection which causes the given discriminator to answer true.

The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.

Specified by:

removeIf in interface ExtensibleCollection<E>

Overrides:

removeIf in class AbstractExtensibleCollection<E>

Parameters:

discriminator - the discriminator to evaluate

Returns:

true if any removal occurred

retainIf

public boolean retainIf(UnaryCondition<? super E> discriminator)

Removes each element of this collection which causes the given discriminator to answer false.

The elements are tested in the same order in which they would be enumerated by forEachDo for this collection.

Specified by:

retainIf in interface ExtensibleCollection<E>

Overrides:

retainIf in class AbstractExtensibleCollection<E>

Parameters:

discriminator - the discriminator to evaluate

Returns:

true if any removal occurred

comparator

public Comparator<? super E> comparator()

Answers the comparator which is used to order this collection's elements.

Returns:

this collection's comparator

equals

public boolean equals(Object that)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object