org.eclipse.collections.api.collection.ImmutableCollection Maven / Gradle / Ivy
/*
* Copyright (c) 2021 Goldman Sachs and others.
* 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 java.util.Spliterator;
import java.util.Spliterators;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.bag.ImmutableBag;
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.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.ImmutableBooleanCollection;
import org.eclipse.collections.api.collection.primitive.ImmutableByteCollection;
import org.eclipse.collections.api.collection.primitive.ImmutableCharCollection;
import org.eclipse.collections.api.collection.primitive.ImmutableDoubleCollection;
import org.eclipse.collections.api.collection.primitive.ImmutableFloatCollection;
import org.eclipse.collections.api.collection.primitive.ImmutableIntCollection;
import org.eclipse.collections.api.collection.primitive.ImmutableLongCollection;
import org.eclipse.collections.api.collection.primitive.ImmutableShortCollection;
import org.eclipse.collections.api.factory.Maps;
import org.eclipse.collections.api.map.ImmutableMap;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.map.primitive.ImmutableObjectDoubleMap;
import org.eclipse.collections.api.map.primitive.ImmutableObjectLongMap;
import org.eclipse.collections.api.multimap.ImmutableMultimap;
import org.eclipse.collections.api.partition.PartitionImmutableCollection;
import org.eclipse.collections.api.tuple.Pair;
/**
* ImmutableCollection is the common interface between ImmutableList, ImmutableSet and ImmutableBag.
* The ImmutableCollection interface is "contractually immutable" in that it does not have any mutating
* methods available on the public interface.
*/
public interface ImmutableCollection
extends RichIterable
{
/**
* This method is similar to the {@code with} method in {@code MutableCollection}
* with the difference that a new copy of this collection with the element appended will be returned.
*/
ImmutableCollection newWith(T element);
/**
* This method is similar to the {@code without} method in {@code MutableCollection}
* with the difference that a new copy of this collection with the element removed will be returned.
*/
ImmutableCollection newWithout(T element);
/**
* This method is similar to the {@code withAll} method in {@code MutableCollection}
* with the difference that a new copy of this collection with the elements appended will be returned.
*/
ImmutableCollection newWithAll(Iterable elements);
/**
* This method is similar to the {@code withoutAll} method in {@code MutableCollection}
* with the difference that a new copy of this collection with the elements removed will be returned.
*/
ImmutableCollection newWithoutAll(Iterable elements);
@Override
ImmutableCollection tap(Procedure procedure);
@Override
ImmutableCollection select(Predicate predicate);
@Override
ImmutableCollection selectWith(Predicate2 predicate, P parameter);
@Override
ImmutableCollection reject(Predicate predicate);
@Override
ImmutableCollection rejectWith(Predicate2 predicate, P parameter);
@Override
PartitionImmutableCollection partition(Predicate predicate);
@Override
PartitionImmutableCollection partitionWith(Predicate2 predicate, P parameter);
@Override
ImmutableCollection selectInstancesOf(Class clazz);
@Override
ImmutableCollection collect(Function function);
@Override
ImmutableBooleanCollection collectBoolean(BooleanFunction booleanFunction);
@Override
ImmutableByteCollection collectByte(ByteFunction byteFunction);
@Override
ImmutableCharCollection collectChar(CharFunction charFunction);
@Override
ImmutableDoubleCollection collectDouble(DoubleFunction doubleFunction);
@Override
ImmutableFloatCollection collectFloat(FloatFunction floatFunction);
@Override
ImmutableIntCollection collectInt(IntFunction intFunction);
@Override
ImmutableLongCollection collectLong(LongFunction longFunction);
@Override
ImmutableShortCollection collectShort(ShortFunction shortFunction);
@Override
ImmutableCollection collectWith(Function2 function, P parameter);
@Override
ImmutableCollection collectIf(Predicate predicate, Function function);
@Override
ImmutableCollection flatCollect(Function> function);
/**
* @since 9.2
*/
@Override
default ImmutableCollection flatCollectWith(Function2> function, P parameter)
{
return this.flatCollect(each -> function.apply(each, parameter));
}
@Override
ImmutableObjectLongMap sumByInt(Function groupBy, IntFunction function);
@Override
ImmutableObjectDoubleMap sumByFloat(Function groupBy, FloatFunction function);
@Override
ImmutableObjectLongMap sumByLong(Function groupBy, LongFunction function);
@Override
ImmutableObjectDoubleMap sumByDouble(Function groupBy, DoubleFunction function);
/**
* @since 9.0
*/
@Override
default ImmutableBag countBy(Function function)
{
return this.asLazy().collect(function).toBag().toImmutable();
}
/**
* @since 9.0
*/
@Override
default ImmutableBag countByWith(Function2 function, P parameter)
{
return this.asLazy().collectWith(function, parameter).toBag().toImmutable();
}
/**
* @since 10.0.0
*/
@Override
default ImmutableBag countByEach(Function> function)
{
return this.asLazy().flatCollect(function).toBag().toImmutable();
}
@Override
ImmutableMultimap groupBy(Function function);
@Override
ImmutableMultimap groupByEach(Function> function);
@Override
default ImmutableMap groupByUniqueKey(Function function)
{
MutableMap target = Maps.mutable.withInitialCapacity(this.size());
return this.groupByUniqueKey(function, target).toImmutable();
}
@Override
ImmutableCollection> zip(Iterable that);
@Override
ImmutableCollection> zipWithIndex();
@Override
default ImmutableMap aggregateInPlaceBy(
Function groupBy,
Function0 zeroValueFactory,
Procedure2 mutatingAggregator)
{
MutableMap map = Maps.mutable.empty();
this.forEach(each ->
{
K key = groupBy.valueOf(each);
V value = map.getIfAbsentPut(key, zeroValueFactory);
mutatingAggregator.value(value, each);
});
return map.toImmutable();
}
@Override
default ImmutableMap aggregateBy(
Function groupBy,
Function0 zeroValueFactory,
Function2 nonMutatingAggregator)
{
MutableMap map = this.aggregateBy(
groupBy,
zeroValueFactory,
nonMutatingAggregator,
Maps.mutable.empty());
return map.toImmutable();
}
/**
* @since 9.0
*/
default Stream stream()
{
return StreamSupport.stream(this.spliterator(), false);
}
/**
* @since 9.0
*/
default Stream parallelStream()
{
return StreamSupport.stream(this.spliterator(), true);
}
/**
* @since 9.0
*/
@Override
default Spliterator spliterator()
{
return Spliterators.spliterator(this.iterator(), (long) this.size(), 0);
}
/**
* This can be overridden in most implementations to just return this.
*
* @since 9.0
*/
Collection castToCollection();
}