Package com.intellij.util.containers

Class ContainerUtil

java.lang.Object

com.intellij.util.containers.ContainerUtilRt

com.intellij.util.containers.ContainerUtil

public class ContainerUtil
extends ContainerUtilRt

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	ContainerUtil.ImmutableMapBuilder<K,V>

Constructor Summary

Constructors

Constructor	Description
ContainerUtil()

Method Summary

Modifier and Type	Method	Description
static <T> void	add(T element, Collection<T> result, Disposable parentDisposable)
static <T, A extends T, C extends Collection<T>> C	addAll(C collection, A... elements)
static <T> void	addAll(Collection<T> collection, Iterable<? extends T> appendix)
static <T> void	addAll(Collection<T> collection, Enumeration<? extends T> enumeration)
static <T> void	addAll(Collection<T> collection, Iterator<? extends T> iterator)
static <T, A extends T, C extends Collection<T>> C	addAllNotNull(C collection, A... elements)	Adds all not-null elements from the elements, ignoring nulls
static <T> void	addAllNotNull(Collection<T> collection, Iterable<? extends T> elements)	Adds all not-null elements from the elements, ignoring nulls
static <T> void	addAllNotNull(Collection<T> collection, Iterator<? extends T> elements)	Adds all not-null elements from the elements, ignoring nulls
static <T> boolean	and(Iterable<T> iterable, Condition<? super T> condition)
static <T> boolean	and(T[] iterable, Condition<? super T> condition)
static <T> List<T>	append(List<? extends T> list, T... values)
static <T> T[]	ar(T... elements)
static <T> TObjectHashingStrategy<T>	canonicalStrategy()
static <T> List<T>	collect(Iterator<T> iterator)
static <T> Set<T>	collectSet(Iterator<T> iterator)
static <T> List<T>	concat(boolean appendTail, List<? extends T> list, T... values)	Deprecated. Use append(List, Object[]) or prepend(List, Object[]) instead
static <T> List<T>	concat(Iterable<? extends Collection<T>> list)
static <T, V> List<T>	concat(Iterable<? extends V> list, Function<V,Collection<? extends T>> listGenerator)
static <T> List<T>	concat(List<? extends T>... lists)
static <T> List<T>	concat(List<? extends T> list1, List<? extends T> list2)
static <T> List<T>	concat(List<List<? extends T>> lists)
static <T, V> List<T>	concat(V[] array, Function<V,Collection<? extends T>> fun)
static <T> boolean	containsIdentity(Iterable<T> list, T element)
static <K, V> V[]	convert(K[] from, V[] to, Function<K,V> fun)
static <T> CopyOnWriteArrayList<T>	createEmptyCOWList()
static <T> List<T>	createMaybeSingletonList(T element)
static <T> Set<T>	createMaybeSingletonSet(T element)
static <K, V> Map<K,Couple<V>>	diff(Map<K,V> map1, Map<K,V> map2)
static <T> List<T>	dropTail(List<T> items)
static <T> List<T>	emptyList()
static <T> boolean	equalsIdentity(List<T> list1, List<T> list2)
static <T> boolean	exists(Iterable<T> iterable, Condition<? super T> condition)
static <T> boolean	exists(T[] iterable, Condition<? super T> condition)
static <T> List<T>	filter(Collection<? extends T> collection, Condition<? super T> condition)
static <K, V> Map<K,V>	filter(Map<K,? extends V> map, Condition<? super K> keyFilter)
static <T> List<T>	filter(T[] collection, Condition<? super T> condition)
static <T> T	find(Iterable<? extends T> iterable, T equalTo)
static <T, V extends T> V	find(Iterable<V> iterable, Condition<T> condition)
static <T> T	find(Iterator<? extends T> iterator, T equalTo)
static <T, V extends T> V	find(Iterator<V> iterator, Condition<T> condition)
static <T> T	find(T[] array, Condition<? super T> condition)
static <T> List<T>	findAll(Collection<? extends T> collection, Condition<? super T> condition)
static <T, V> List<V>	findAll(Collection<? extends T> collection, Class<V> instanceOf)
static <T> List<T>	findAll(T[] collection, Condition<? super T> condition)
static <T, V> List<V>	findAll(T[] collection, Class<V> instanceOf)
static <T, V> V[]	findAllAsArray(Collection<? extends T> collection, Class<V> instanceOf)
static <T> T[]	findAllAsArray(T[] collection, Condition<? super T> instanceOf)
static <T, V> V[]	findAllAsArray(T[] collection, Class<V> instanceOf)
static <T, U extends T> U	findLastInstance(List<T> list, Class<U> clazz)
static <E> List<E>	flatten(Iterable<? extends Collection<E>> collections)
static <E> List<E>	flatten(Collection<E>[] collections)
static <E> List<E>	flattenIterables(Iterable<? extends Iterable<E>> collections)
static <T> T	getFirstItem(Collection<T> items)
static <T> T	getFirstItem(Collection<T> items, T defaultResult)
static <T> T	getFirstItem(List<T> items)
static <T> List<T>	getFirstItems(List<T> items, int maxItems)	The main difference from subList is that getFirstItems does not throw any exceptions, even if maxItems is greater than size of the list
static <T, V> V	getOrCreate(Map<T,V> result, T key, V defaultValue)
static <T> T	getOrElse(List<T> elements, int i, T defaultValue)
static <T, V> V	getOrElse(Map<T,V> result, T key, V defValue)
static <T> TObjectHashingStrategy<T>	identityStrategy()
static <E> ImmutableList<E>	immutableList(E... array)
static <E> ImmutableList<E>	immutableList(List<E> list)
static <K, V> ContainerUtil.ImmutableMapBuilder<K,V>	immutableMapBuilder()
static <E> Set<E>	immutableSet(E... elements)
static <T> int	indexOf(List<T> list, Condition<? super T> condition)
static <T> int	indexOf(List<T> list, T object)
static <T> int	indexOfIdentity(List<T> list, T element)
static <T> Collection<T>	intersection(Collection<? extends T> collection1, Collection<? extends T> collection2)
static <K, V> Map<K,V>	intersection(Map<K,V> map1, Map<K,V> map2)
static <T> boolean	intersects(Collection<? extends T> collection1, Collection<? extends T> collection2)
static <T> Iterator<T>	iterate(Enumeration<T> enumeration)
static <T> Iterator<T>	iterate(T[] array)
static <T> T	iterateAndGetLastItem(Iterable<T> items)
static <T> Iterable<T>	iterateBackward(List<? extends T> list)
static <T> int	lastIndexOf(List<T> list, Condition<? super T> condition)
static <T, U extends T> int	lastIndexOfInstance(List<T> list, Class<U> clazz)
static <T> List<T>	list(T... items)
static <T, V> List<V>	map(Iterable<? extends T> iterable, Function<T,V> mapping)
static <T, V> List<V>	map(Collection<? extends T> iterable, Function<T,V> mapping)
static <T, V> List<V>	map(T[] array, Function<T,V> mapping)
static <T, V> V[]	map(T[] arr, Function<T,V> mapping, V[] emptyArray)
static <T, V> V[]	map2Array(Collection<? extends T> collection, Class<? super V> aClass, Function<T,V> mapper)
static <T, V> V[]	map2Array(Collection<? extends T> collection, V[] to, Function<T,V> mapper)
static <T> Object[]	map2Array(Collection<T> array, Function<T,Object> mapper)
static <T> Object[]	map2Array(T[] array, Function<T,Object> mapper)
static <T, V> V[]	map2Array(T[] array, Class<? super V> aClass, Function<T,V> mapper)
static <T, KEY, VALUE> Map<KEY,VALUE>	map2Map(Collection<? extends T> collection, Function<T,Pair<KEY,VALUE>> mapper)
static <KEY, VALUE> Map<KEY,VALUE>	map2Map(Collection<Pair<KEY,VALUE>> collection)
static <T, KEY, VALUE> Map<KEY,VALUE>	map2Map(T[] collection, Function<T,Pair<KEY,VALUE>> mapper)
static <T, KEY, VALUE> Map<KEY,VALUE>	map2MapNotNull(Collection<? extends T> collection, Function<T,Pair<KEY,VALUE>> mapper)
static <T, KEY, VALUE> Map<KEY,VALUE>	map2MapNotNull(T[] collection, Function<T,Pair<KEY,VALUE>> mapper)
static <T, U> Iterator<U>	mapIterator(Iterator<T> iterator, Function<T,U> mapper)
static <T, V> List<V>	mapNotNull(Iterable<? extends T> iterable, Function<T,V> mapping)
static <T, V> List<V>	mapNotNull(Collection<? extends T> iterable, Function<T,V> mapping)
static <T, V> List<V>	mapNotNull(T[] array, Function<T,V> mapping)
static <T, V> V[]	mapNotNull(T[] array, Function<T,V> mapping, V[] emptyArray)
static void	mergeSortedArrays(TIntArrayList x1, TIntArrayList y1, TIntArrayList x2, TIntArrayList y2)	Merge sorted points, which are sorted by x and with equal x by y.
static <T> ArrayList<T>	newArrayList()
static <E> ArrayList<E>	newArrayList(E... array)
static <E> ArrayList<E>	newArrayList(Iterable<? extends E> iterable)
static <T> List<T>	newArrayList(T[] elements, int start, int end)
static <T> ArrayList<T>	newArrayListWithCapacity(int size)
static <K extends Enum<K>, V> EnumMap<K,V>	newEnumMap(Class<K> keyType)
static <K, V> HashMap<K,V>	newHashMap()
static <K, V> Map<K,V>	newHashMap(Pair<K,? extends V> first, Pair<K,? extends V>... entries)
static <K, V> Map<K,V>	newHashMap(List<K> keys, List<V> values)
static <K, V> HashMap<K,V>	newHashMap(Map<? extends K,? extends V> map)
static <T> Set<T>	newHashOrEmptySet(Iterable<? extends T> iterable)
static <T> HashSet<T>	newHashSet()
static <T> HashSet<T>	newHashSet(int initialCapacity)
static <T> HashSet<T>	newHashSet(Iterable<? extends T> iterable)
static <T> HashSet<T>	newHashSet(Iterator<? extends T> iterator)
static <T> HashSet<T>	newHashSet(T... elements)
static <K, V> IdentityHashMap<K,V>	newIdentityHashMap()
static <K, V> THashMap<K,V>	newIdentityTroveMap()
static <K> THashSet<K>	newIdentityTroveSet()
static <K> THashSet<K>	newIdentityTroveSet(int initialCapacity)
static <K> THashSet<K>	newIdentityTroveSet(Collection<K> collection)
static <K, V> LinkedHashMap<K,V>	newLinkedHashMap()
static <K, V> LinkedHashMap<K,V>	newLinkedHashMap(int capacity)
static <K, V> LinkedHashMap<K,V>	newLinkedHashMap(Pair<K,V> first, Pair<K,V>... entries)
static <K, V> LinkedHashMap<K,V>	newLinkedHashMap(Map<K,V> map)
static <T> LinkedHashSet<T>	newLinkedHashSet()
static <T> LinkedHashSet<T>	newLinkedHashSet(Iterable<? extends T> elements)
static <T> LinkedHashSet<T>	newLinkedHashSet(T... elements)
static <T> LinkedList<T>	newLinkedList()
static <T> LinkedList<T>	newLinkedList(Iterable<? extends T> elements)
static <T> LinkedList<T>	newLinkedList(T... elements)
static <T> List<T>	newSmartList()
static <T> List<T>	newSmartList(T element)
static <T> List<T>	newSmartList(T... elements)
static <T> Stack<T>	newStack()
static <T> Stack<T>	newStack(Collection<T> initial)
static <T> Stack<T>	newStack(T... initial)
static <K extends Comparable, V> TreeMap<K,V>	newTreeMap()
static <K extends Comparable, V> TreeMap<K,V>	newTreeMap(Map<K,V> map)
static <T> TreeSet<T>	newTreeSet()
static <T> TreeSet<T>	newTreeSet(Iterable<? extends T> elements)
static <T> TreeSet<T>	newTreeSet(Comparator<? super T> comparator)
static <T> TreeSet<T>	newTreeSet(T... elements)
static <K, V> THashMap<K,V>	newTroveMap()
static <K, V> THashMap<K,V>	newTroveMap(TObjectHashingStrategy<K> strategy)
static <T> THashSet<T>	newTroveSet()
static <T> THashSet<T>	newTroveSet(TObjectHashingStrategy<T> strategy)
static <T> THashSet<T>	newTroveSet(TObjectHashingStrategy<T> strategy, Collection<T> elements)
static <T> THashSet<T>	newTroveSet(TObjectHashingStrategy<T> strategy, T... elements)
static <T> THashSet<T>	newTroveSet(Collection<T> elements)
static <T> THashSet<T>	newTroveSet(T... elements)
static <T> List<T>	newUnmodifiableList(List<? extends T> originalList)
static <T> boolean	or(Iterable<T> iterable, Condition<? super T> condition)
static <T> boolean	or(T[] iterable, Condition<? super T> condition)
static <T> List<T>	packNullables(T... elements)
static <T> List<T>	prepend(List<? extends T> list, T... values)	prepend values in front of the list
static <T> boolean	processSortedListsInOrder(List<T> list1, List<T> list2, Comparator<? super T> comparator, boolean mergeEqualItems, Processor<T> processor)
static <K, V> void	putIfNotNull(K key, V value, Map<K,V> result)
static <T> void	quickSort(List<T> list, Comparator<? super T> comparator)
static <T> boolean	removeAll(Collection<T> collection, T... elements)
static <T> void	removeDuplicates(Collection<T> collection)
static <T> List<T>	removeDuplicatesFromSorted(List<T> list, Comparator<? super T> comparator)	Processes the list, remove all duplicates and return the list with unique elements.
static <T> boolean	retainAll(Collection<T> collection, Condition<? super T> condition)
static <E> List<E>	reverse(List<E> elements)
static <A, B> Map<B,A>	reverseMap(Map<A,B> map)
static <T> Set<T>	set(T... items)
static <T> List<T>	skipNulls(Collection<? extends T> collection)
static <T extends Comparable<T>> void	sort(List<T> list)
static <T> void	sort(List<T> list, Comparator<? super T> comparator)
static <T extends Comparable<T>> void	sort(T[] a)
static <T> void	sort(T[] a, Comparator<T> comparator)
static <T> List<T>	sorted(Iterable<T> list, Comparator<? super T> comparator)
static <T extends Comparable<? super T>> List<T>	sorted(Collection<T> list)
static <T> List<T>	sorted(Collection<T> list, Comparator<? super T> comparator)
static Map<String,String>	stringMap(String... keyValues)
static <T> List<T>	subList(List<T> list, int from)
static <T> Collection<T>	subtract(Collection<T> from, Collection<T> what)
static <E> void	swapElements(List<E> list, int index1, int index2)
static <T> List<T>	trimToSize(List<T> list)
static <T> List<T>	unfold(T t, NullableFunction<T,T> next)
static <K, V> Map<K,V>	union(Map<? extends K,? extends V> map, Map<? extends K,? extends V> map2)
static <T> Set<T>	union(Set<T> set, Set<T> set2)
static <T, E> Iterable<Pair<T,E>>	zip(Iterable<T> iterable1, Iterable<E> iterable2)

Methods inherited from class com.intellij.util.containers.ContainerUtilRt

addIfNotNull, addIfNotNull, map2List, map2List, map2Set, map2Set, newHashMap, toArray, toArray

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

ContainerUtil

public ContainerUtil()

Method Details

ar

@NotNull
@Contract(pure=true)
public static <T> T[] ar(@NotNull
 T... elements)

newHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> HashMap<K,V> newHashMap()

newHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> HashMap<K,V> newHashMap(@NotNull
 Map<? extends K,? extends V> map)

newHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> Map<K,V> newHashMap(@NotNull
 Pair<K,? extends V> first,
 @NotNull
 Pair<K,? extends V>... entries)

newHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> Map<K,V> newHashMap(@NotNull
 List<K> keys,
 @NotNull
 List<V> values)

newTreeMap

@NotNull
@Contract(pure=true)
public static <K extends Comparable,
V>
TreeMap<K,V> newTreeMap()

newTreeMap

@NotNull
@Contract(pure=true)
public static <K extends Comparable,
V>
TreeMap<K,V> newTreeMap(@NotNull
 Map<K,V> map)

newLinkedHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> LinkedHashMap<K,V> newLinkedHashMap()

newLinkedHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> LinkedHashMap<K,V> newLinkedHashMap(int capacity)

newLinkedHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> LinkedHashMap<K,V> newLinkedHashMap(@NotNull
 Map<K,V> map)

newLinkedHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> LinkedHashMap<K,V> newLinkedHashMap(@NotNull
 Pair<K,V> first,
 @NotNull
 Pair<K,V>... entries)

newTroveMap

@NotNull
@Contract(pure=true)
public static <K,
V> THashMap<K,V> newTroveMap()

newTroveMap

@NotNull
@Contract(pure=true)
public static <K,
V> THashMap<K,V> newTroveMap(@NotNull
 TObjectHashingStrategy<K> strategy)

newEnumMap

@NotNull
@Contract(pure=true)
public static <K extends Enum<K>,
V> EnumMap<K,V> newEnumMap(@NotNull
 Class<K> keyType)

canonicalStrategy

@NotNull
@Contract(pure=true)
public static <T> TObjectHashingStrategy<T> canonicalStrategy()

identityStrategy

@NotNull
@Contract(pure=true)
public static <T> TObjectHashingStrategy<T> identityStrategy()

newIdentityHashMap

@NotNull
@Contract(pure=true)
public static <K,
V> IdentityHashMap<K,V> newIdentityHashMap()

newLinkedList

@NotNull
@Contract(pure=true)
public static <T> LinkedList<T> newLinkedList()

newLinkedList

@NotNull
@Contract(pure=true)
public static <T> LinkedList<T> newLinkedList(@NotNull
 T... elements)

newLinkedList

@NotNull
@Contract(pure=true)
public static <T> LinkedList<T> newLinkedList(@NotNull
 Iterable<? extends T> elements)

newArrayList

@NotNull
@Contract(pure=true)
public static <T> ArrayList<T> newArrayList()

newArrayList

@NotNull
@Contract(pure=true)
public static <E> ArrayList<E> newArrayList(@NotNull
 E... array)

newArrayList

@NotNull
@Contract(pure=true)
public static <E> ArrayList<E> newArrayList(@NotNull
 Iterable<? extends E> iterable)

newArrayListWithCapacity

@NotNull
@Contract(pure=true)
public static <T> ArrayList<T> newArrayListWithCapacity(int size)

newArrayList

@NotNull
@Contract(pure=true)
public static <T> List<T> newArrayList(@NotNull
 T[] elements,
 int start,
 int end)

newUnmodifiableList

@NotNull
@Contract(pure=true)
public static <T> List<T> newUnmodifiableList(List<? extends T> originalList)

newSmartList

@NotNull
@Contract(pure=true)
public static <T> List<T> newSmartList()

newSmartList

@NotNull
@Contract(pure=true)
public static <T> List<T> newSmartList(T element)

newSmartList

@NotNull
@Contract(pure=true)
public static <T> List<T> newSmartList(@NotNull
 T... elements)

newHashSet

@NotNull
@Contract(pure=true)
public static <T> HashSet<T> newHashSet()

newHashSet

@NotNull
@Contract(pure=true)
public static <T> HashSet<T> newHashSet(int initialCapacity)

newHashSet

@NotNull
@Contract(pure=true)
public static <T> HashSet<T> newHashSet(@NotNull
 T... elements)

newHashSet

@NotNull
@Contract(pure=true)
public static <T> HashSet<T> newHashSet(@NotNull
 Iterable<? extends T> iterable)

newHashSet

@NotNull
public static <T> HashSet<T> newHashSet(@NotNull
 Iterator<? extends T> iterator)

newHashOrEmptySet

@NotNull
@Contract(pure=true)
public static <T> Set<T> newHashOrEmptySet(@Nullable
 Iterable<? extends T> iterable)

newLinkedHashSet

@NotNull
@Contract(pure=true)
public static <T> LinkedHashSet<T> newLinkedHashSet()

newLinkedHashSet

@NotNull
@Contract(pure=true)
public static <T> LinkedHashSet<T> newLinkedHashSet(@NotNull
 Iterable<? extends T> elements)

newLinkedHashSet

@NotNull
@Contract(pure=true)
public static <T> LinkedHashSet<T> newLinkedHashSet(@NotNull
 T... elements)

newTroveSet

@NotNull
@Contract(pure=true)
public static <T> THashSet<T> newTroveSet()

newTroveSet

@NotNull
@Contract(pure=true)
public static <T> THashSet<T> newTroveSet(@NotNull
 TObjectHashingStrategy<T> strategy)

newTroveSet

@NotNull
@Contract(pure=true)
public static <T> THashSet<T> newTroveSet(@NotNull
 T... elements)

newTroveSet

@NotNull
@Contract(pure=true)
public static <T> THashSet<T> newTroveSet(@NotNull
 TObjectHashingStrategy<T> strategy,
 @NotNull
 T... elements)

newTroveSet

@NotNull
@Contract(pure=true)
public static <T> THashSet<T> newTroveSet(@NotNull
 TObjectHashingStrategy<T> strategy,
 @NotNull
 Collection<T> elements)

newTroveSet

@NotNull
@Contract(pure=true)
public static <T> THashSet<T> newTroveSet(@NotNull
 Collection<T> elements)

newIdentityTroveSet

@NotNull
@Contract(pure=true)
public static <K> THashSet<K> newIdentityTroveSet()

newIdentityTroveSet

@NotNull
@Contract(pure=true)
public static <K> THashSet<K> newIdentityTroveSet(int initialCapacity)

newIdentityTroveSet

@NotNull
@Contract(pure=true)
public static <K> THashSet<K> newIdentityTroveSet(@NotNull
 Collection<K> collection)

newIdentityTroveMap

@NotNull
@Contract(pure=true)
public static <K,
V> THashMap<K,V> newIdentityTroveMap()

newTreeSet

@NotNull
@Contract(pure=true)
public static <T> TreeSet<T> newTreeSet()

newTreeSet

@NotNull
@Contract(pure=true)
public static <T> TreeSet<T> newTreeSet(@NotNull
 Iterable<? extends T> elements)

newTreeSet

@NotNull
@Contract(pure=true)
public static <T> TreeSet<T> newTreeSet(@NotNull
 T... elements)

newTreeSet

@NotNull
@Contract(pure=true)
public static <T> TreeSet<T> newTreeSet(@Nullable
 Comparator<? super T> comparator)

reverse

@NotNull
@Contract(pure=true)
public static <E> List<E> reverse(@NotNull
 List<E> elements)

union

@NotNull
@Contract(pure=true)
public static <K,
V> Map<K,V> union(@NotNull
 Map<? extends K,? extends V> map,
 @NotNull
 Map<? extends K,? extends V> map2)

union

@NotNull
@Contract(pure=true)
public static <T> Set<T> union(@NotNull
 Set<T> set,
 @NotNull
 Set<T> set2)

immutableSet

@NotNull
@Contract(pure=true)
public static <E> Set<E> immutableSet(@NotNull
 E... elements)

immutableList

@NotNull
@Contract(pure=true)
public static <E> ImmutableList<E> immutableList(@NotNull
 E... array)

immutableList

@NotNull
@Contract(pure=true)
public static <E> ImmutableList<E> immutableList(@NotNull
 List<E> list)

immutableMapBuilder

@NotNull
@Contract(pure=true)
public static <K,
V>
ContainerUtil.ImmutableMapBuilder<K,V> immutableMapBuilder()

getOrElse

@Contract(pure=true)
public static <T> T getOrElse(@NotNull
 List<T> elements,
 int i,
 T defaultValue)

intersection

@NotNull
@Contract(pure=true)
public static <K,
V> Map<K,V> intersection(@NotNull
 Map<K,V> map1,
 @NotNull
 Map<K,V> map2)

diff

@NotNull
@Contract(pure=true)
public static <K,
V> Map<K,Couple<V>> diff(@NotNull
 Map<K,V> map1,
 @NotNull
 Map<K,V> map2)

processSortedListsInOrder

public static <T> boolean processSortedListsInOrder(@NotNull
 List<T> list1,
 @NotNull
 List<T> list2,
 @NotNull
 Comparator<? super T> comparator,
 boolean mergeEqualItems,
 @NotNull
 Processor<T> processor)

subList

@NotNull
@Contract(pure=true)
public static <T> List<T> subList(@NotNull
 List<T> list,
 int from)

addAll

public static <T> void addAll(@NotNull
 Collection<T> collection,
 @NotNull
 Iterable<? extends T> appendix)

addAll

public static <T> void addAll(@NotNull
 Collection<T> collection,
 @NotNull
 Iterator<? extends T> iterator)

addAllNotNull

public static <T> void addAllNotNull(@NotNull
 Collection<T> collection,
 @NotNull
 Iterable<? extends T> elements)

Adds all not-null elements from the elements, ignoring nulls

addAllNotNull

public static <T> void addAllNotNull(@NotNull
 Collection<T> collection,
 @NotNull
 Iterator<? extends T> elements)

Adds all not-null elements from the elements, ignoring nulls

collect

@NotNull
public static <T> List<T> collect(@NotNull
 Iterator<T> iterator)

collectSet

@NotNull
public static <T> Set<T> collectSet(@NotNull
 Iterator<T> iterator)

find

@Nullable
@Contract(pure=true)
public static <T> T find(@NotNull
 T[] array,
 @NotNull
 Condition<? super T> condition)

find

@Nullable
@Contract(pure=true)
public static <T,
V extends T> V find(@NotNull
 Iterable<V> iterable,
 @NotNull
 Condition<T> condition)

find

@Nullable
@Contract(pure=true)
public static <T> T find(@NotNull
 Iterable<? extends T> iterable,
 @NotNull
 T equalTo)

find

@Nullable
@Contract(pure=true)
public static <T> T find(@NotNull
 Iterator<? extends T> iterator,
 @NotNull
 T equalTo)

find

@Nullable
public static <T,
V extends T> V find(@NotNull
 Iterator<V> iterator,
 @NotNull
 Condition<T> condition)

map2Map

@NotNull
@Contract(pure=true)
public static <T,
KEY,
VALUE> Map<KEY,VALUE> map2Map(@NotNull
 T[] collection,
 @NotNull
 Function<T,Pair<KEY,VALUE>> mapper)

map2Map

@NotNull
@Contract(pure=true)
public static <T,
KEY,
VALUE> Map<KEY,VALUE> map2Map(@NotNull
 Collection<? extends T> collection,
 @NotNull
 Function<T,Pair<KEY,VALUE>> mapper)

map2MapNotNull

@NotNull
@Contract(pure=true)
public static <T,
KEY,
VALUE> Map<KEY,VALUE> map2MapNotNull(@NotNull
 T[] collection,
 @NotNull
 Function<T,Pair<KEY,VALUE>> mapper)

map2MapNotNull

@NotNull
@Contract(pure=true)
public static <T,
KEY,
VALUE> Map<KEY,VALUE> map2MapNotNull(@NotNull
 Collection<? extends T> collection,
 @NotNull
 Function<T,Pair<KEY,VALUE>> mapper)

map2Map

@NotNull
@Contract(pure=true)
public static <KEY,
VALUE> Map<KEY,VALUE> map2Map(@NotNull
 Collection<Pair<KEY,VALUE>> collection)

map2Array

@NotNull
@Contract(pure=true)
public static <T> Object[] map2Array(@NotNull
 T[] array,
 @NotNull
 Function<T,Object> mapper)

map2Array

@NotNull
@Contract(pure=true)
public static <T> Object[] map2Array(@NotNull
 Collection<T> array,
 @NotNull
 Function<T,Object> mapper)

map2Array

@NotNull
@Contract(pure=true)
public static <T,
V> V[] map2Array(@NotNull
 T[] array,
 @NotNull
 Class<? super V> aClass,
 @NotNull
 Function<T,V> mapper)

map2Array

@NotNull
@Contract(pure=true)
public static <T,
V> V[] map2Array(@NotNull
 Collection<? extends T> collection,
 @NotNull
 Class<? super V> aClass,
 @NotNull
 Function<T,V> mapper)

map2Array

@NotNull
@Contract(pure=true)
public static <T,
V> V[] map2Array(@NotNull
 Collection<? extends T> collection,
 @NotNull
 V[] to,
 @NotNull
 Function<T,V> mapper)

filter

@NotNull
@Contract(pure=true)
public static <T> List<T> filter(@NotNull
 T[] collection,
 @NotNull
 Condition<? super T> condition)

findAll

@NotNull
@Contract(pure=true)
public static <T> List<T> findAll(@NotNull
 T[] collection,
 @NotNull
 Condition<? super T> condition)

filter

@NotNull
@Contract(pure=true)
public static <T> List<T> filter(@NotNull
 Collection<? extends T> collection,
 @NotNull
 Condition<? super T> condition)

filter

@NotNull
@Contract(pure=true)
public static <K,
V> Map<K,V> filter(@NotNull
 Map<K,? extends V> map,
 @NotNull
 Condition<? super K> keyFilter)

findAll

@NotNull
@Contract(pure=true)
public static <T> List<T> findAll(@NotNull
 Collection<? extends T> collection,
 @NotNull
 Condition<? super T> condition)

skipNulls

@NotNull
@Contract(pure=true)
public static <T> List<T> skipNulls(@NotNull
 Collection<? extends T> collection)

findAll

@NotNull
@Contract(pure=true)
public static <T,
V> List<V> findAll(@NotNull
 T[] collection,
 @NotNull
 Class<V> instanceOf)

findAllAsArray

@NotNull
@Contract(pure=true)
public static <T,
V> V[] findAllAsArray(@NotNull
 T[] collection,
 @NotNull
 Class<V> instanceOf)

findAllAsArray

@NotNull
@Contract(pure=true)
public static <T,
V> V[] findAllAsArray(@NotNull
 Collection<? extends T> collection,
 @NotNull
 Class<V> instanceOf)

findAllAsArray

@NotNull
@Contract(pure=true)
public static <T> T[] findAllAsArray(@NotNull
 T[] collection,
 @NotNull
 Condition<? super T> instanceOf)

findAll

@NotNull
@Contract(pure=true)
public static <T,
V> List<V> findAll(@NotNull
 Collection<? extends T> collection,
 @NotNull
 Class<V> instanceOf)

removeDuplicates

public static <T> void removeDuplicates(@NotNull
 Collection<T> collection)

stringMap

@NotNull
@Contract(pure=true)
public static Map<String,String> stringMap(@NotNull
 String... keyValues)

iterate

@NotNull
@Contract(pure=true)
public static <T> Iterator<T> iterate(@NotNull
 T[] array)

iterate

@NotNull
@Contract(pure=true)
public static <T> Iterator<T> iterate(@NotNull
 Enumeration<T> enumeration)

iterateBackward

@NotNull
@Contract(pure=true)
public static <T> Iterable<T> iterateBackward(@NotNull
 List<? extends T> list)

zip

@NotNull
@Contract(pure=true)
public static <T,
E> Iterable<Pair<T,E>> zip(@NotNull
 Iterable<T> iterable1,
 @NotNull
 Iterable<E> iterable2)

swapElements

public static <E> void swapElements(@NotNull
 List<E> list,
 int index1,
 int index2)

addAll

public static <T> void addAll(@NotNull
 Collection<T> collection,
 @NotNull
 Enumeration<? extends T> enumeration)

addAll

@NotNull
public static <T,
A extends T,
C extends Collection<T>>
C addAll(@NotNull
 C collection,
 @NotNull
 A... elements)

addAllNotNull

@NotNull
public static <T,
A extends T,
C extends Collection<T>>
C addAllNotNull(@NotNull
 C collection,
 @NotNull
 A... elements)

Adds all not-null elements from the elements, ignoring nulls

removeAll

public static <T> boolean removeAll(@NotNull
 Collection<T> collection,
 @NotNull
 T... elements)

retainAll

public static <T> boolean retainAll(@NotNull
 Collection<T> collection,
 @NotNull
 Condition<? super T> condition)

concat

@NotNull
@Contract(pure=true)
public static <T,
V> List<T> concat(@NotNull
 V[] array,
 @NotNull
 Function<V,Collection<? extends T>> fun)

concat

@NotNull
@Contract(pure=true)
public static <T> List<T> concat(@NotNull
 Iterable<? extends Collection<T>> list)

Returns:

read-only list consisting of the elements from the collections stored in list added together

concat

@Deprecated
@NotNull
@Contract(pure=true)
public static <T> List<T> concat(boolean appendTail,
 @NotNull
 List<? extends T> list,
 @NotNull
 T... values)

Deprecated.

Use append(List, Object[]) or prepend(List, Object[]) instead

Parameters:

appendTail - specify whether additional values should be appended in front or after the list

Returns:

read-only list consisting of the elements from specified list with some additional values

append

@NotNull
@Contract(pure=true)
public static <T> List<T> append(@NotNull
 List<? extends T> list,
 @NotNull
 T... values)

prepend

@NotNull
@Contract(pure=true)
public static <T> List<T> prepend(@NotNull
 List<? extends T> list,
 @NotNull
 T... values)

prepend values in front of the list

Returns:

read-only list consisting of values and the elements from specified list

concat

@NotNull
@Contract(pure=true)
public static <T> List<T> concat(@NotNull
 List<? extends T> list1,
 @NotNull
 List<? extends T> list2)

Returns:

read-only list consisting of the two lists added together

concat

@NotNull
@Contract(pure=true)
public static <T> List<T> concat(@NotNull
 List<? extends T>... lists)

Returns:

read-only list consisting of the lists added together

concat

@NotNull
@Contract(pure=true)
public static <T> List<T> concat(@NotNull
 List<List<? extends T>> lists)

Returns:

read-only list consisting of the lists added together

concat

@NotNull
@Contract(pure=true)
public static <T,
V> List<T> concat(@NotNull
 Iterable<? extends V> list,
 @NotNull
 Function<V,Collection<? extends T>> listGenerator)

Returns:

read-only list consisting of the lists (made by listGenerator) added together

intersects

@Contract(pure=true)
public static <T> boolean intersects(@NotNull
 Collection<? extends T> collection1,
 @NotNull
 Collection<? extends T> collection2)

intersection

@NotNull
@Contract(pure=true)
public static <T> Collection<T> intersection(@NotNull
 Collection<? extends T> collection1,
 @NotNull
 Collection<? extends T> collection2)

Returns:

read-only collection consisting of elements from both collections

getFirstItem

@Nullable
@Contract(pure=true)
public static <T> T getFirstItem(@Nullable
 Collection<T> items)

getFirstItem

@Nullable
@Contract(pure=true)
public static <T> T getFirstItem(@Nullable
 List<T> items)

getFirstItem

@Contract(pure=true)
public static <T> T getFirstItem(@Nullable
 Collection<T> items,
 @Nullable
 T defaultResult)

getFirstItems

@NotNull
@Contract(pure=true)
public static <T> List<T> getFirstItems(@NotNull
 List<T> items,
 int maxItems)

The main difference from subList is that getFirstItems does not throw any exceptions, even if maxItems is greater than size of the list

Type Parameters:

T - type of list

Parameters:

items - list

maxItems - size of the result will be equal or less than maxItems

Returns:

new list with no more than maxItems first elements

iterateAndGetLastItem

@Nullable
@Contract(pure=true)
public static <T> T iterateAndGetLastItem(@NotNull
 Iterable<T> items)

mapIterator

@NotNull
@Contract(pure=true)
public static <T,
U> Iterator<U> mapIterator(@NotNull
 Iterator<T> iterator,
 @NotNull
 Function<T,U> mapper)

subtract

@NotNull
@Contract(pure=true)
public static <T> Collection<T> subtract(@NotNull
 Collection<T> from,
 @NotNull
 Collection<T> what)

Returns:

read-only collection consisting of elements from the 'from' collection which are absent from the 'what' collection

sort

public static <T extends Comparable<T>> void sort(@NotNull
 List<T> list)

sort

public static <T> void sort(@NotNull
 List<T> list,
 @NotNull
 Comparator<? super T> comparator)

sort

public static <T extends Comparable<T>> void sort(@NotNull
 T[] a)

sorted

@NotNull
@Contract(pure=true)
public static <T> List<T> sorted(@NotNull
 Collection<T> list,
 @NotNull
 Comparator<? super T> comparator)

sorted

@NotNull
@Contract(pure=true)
public static <T> List<T> sorted(@NotNull
 Iterable<T> list,
 @NotNull
 Comparator<? super T> comparator)

sorted

@NotNull
@Contract(pure=true)
public static <T extends Comparable<? super T>>
List<T> sorted(@NotNull
 Collection<T> list)

sort

public static <T> void sort(@NotNull
 T[] a,
 @NotNull
 Comparator<T> comparator)

map

@NotNull
@Contract(pure=true)
public static <T,
V> List<V> map(@NotNull
 Iterable<? extends T> iterable,
 @NotNull
 Function<T,V> mapping)

Returns:

read-only list consisting of the elements from the iterable converted by mapping

map

@NotNull
@Contract(pure=true)
public static <T,
V> List<V> map(@NotNull
 Collection<? extends T> iterable,
 @NotNull
 Function<T,V> mapping)

Returns:

read-only list consisting of the elements from the iterable converted by mapping

mapNotNull

@NotNull
@Contract(pure=true)
public static <T,
V> List<V> mapNotNull(@NotNull
 T[] array,
 @NotNull
 Function<T,V> mapping)

Returns:

read-only list consisting of the elements from the array converted by mapping with nulls filtered out

mapNotNull

@NotNull
@Contract(pure=true)
public static <T,
V> V[] mapNotNull(@NotNull
 T[] array,
 @NotNull
 Function<T,V> mapping,
 @NotNull
 V[] emptyArray)

Returns:

read-only list consisting of the elements from the array converted by mapping with nulls filtered out

mapNotNull

@NotNull
@Contract(pure=true)
public static <T,
V> List<V> mapNotNull(@NotNull
 Iterable<? extends T> iterable,
 @NotNull
 Function<T,V> mapping)

Returns:

read-only list consisting of the elements from the iterable converted by mapping with nulls filtered out

mapNotNull

@NotNull
@Contract(pure=true)
public static <T,
V> List<V> mapNotNull(@NotNull
 Collection<? extends T> iterable,
 @NotNull
 Function<T,V> mapping)

Returns:

read-only list consisting of the elements from the array converted by mapping with nulls filtered out

packNullables

@NotNull
@Contract(pure=true)
public static <T> List<T> packNullables(@NotNull
 T... elements)

Returns:

read-only list consisting of the elements with nulls filtered out

map

@NotNull
@Contract(pure=true)
public static <T,
V> List<V> map(@NotNull
 T[] array,
 @NotNull
 Function<T,V> mapping)

Returns:

read-only list consisting of the elements from the array converted by mapping

map

@NotNull
@Contract(pure=true)
public static <T,
V> V[] map(@NotNull
 T[] arr,
 @NotNull
 Function<T,V> mapping,
 @NotNull
 V[] emptyArray)

set

@NotNull
@Contract(pure=true)
public static <T> Set<T> set(@NotNull
 T... items)

putIfNotNull

public static <K,
V> void putIfNotNull(K key,
 @Nullable
 V value,
 @NotNull
 Map<K,V> result)

add

public static <T> void add(T element,
 @NotNull
 Collection<T> result,
 @NotNull
 Disposable parentDisposable)

createMaybeSingletonList

@NotNull
@Contract(pure=true)
public static <T> List<T> createMaybeSingletonList(@Nullable
 T element)

createMaybeSingletonSet

@NotNull
@Contract(pure=true)
public static <T> Set<T> createMaybeSingletonSet(@Nullable
 T element)

getOrCreate

@NotNull
public static <T,
V> V getOrCreate(@NotNull
 Map<T,V> result,
 T key,
 @NotNull
 V defaultValue)

getOrElse

@NotNull
@Contract(pure=true)
public static <T,
V> V getOrElse(@NotNull
 Map<T,V> result,
 T key,
 @NotNull
 V defValue)

and

@Contract(pure=true)
public static <T> boolean and(@NotNull
 T[] iterable,
 @NotNull
 Condition<? super T> condition)

and

@Contract(pure=true)
public static <T> boolean and(@NotNull
 Iterable<T> iterable,
 @NotNull
 Condition<? super T> condition)

exists

@Contract(pure=true)
public static <T> boolean exists(@NotNull
 T[] iterable,
 @NotNull
 Condition<? super T> condition)

exists

@Contract(pure=true)
public static <T> boolean exists(@NotNull
 Iterable<T> iterable,
 @NotNull
 Condition<? super T> condition)

or

@Contract(pure=true)
public static <T> boolean or(@NotNull
 T[] iterable,
 @NotNull
 Condition<? super T> condition)

or

@Contract(pure=true)
public static <T> boolean or(@NotNull
 Iterable<T> iterable,
 @NotNull
 Condition<? super T> condition)

unfold

@NotNull
@Contract(pure=true)
public static <T> List<T> unfold(@Nullable
 T t,
 @NotNull
 NullableFunction<T,T> next)

dropTail

@NotNull
@Contract(pure=true)
public static <T> List<T> dropTail(@NotNull
 List<T> items)

list

@NotNull
@Contract(pure=true)
public static <T> List<T> list(@NotNull
 T... items)

quickSort

public static <T> void quickSort(@NotNull
 List<T> list,
 @NotNull
 Comparator<? super T> comparator)

mergeSortedArrays

public static void mergeSortedArrays(@NotNull
 TIntArrayList x1,
 @NotNull
 TIntArrayList y1,
 @NotNull
 TIntArrayList x2,
 @NotNull
 TIntArrayList y2)

Merge sorted points, which are sorted by x and with equal x by y. Result is put to x1 y1.

flatten

@NotNull
@Contract(pure=true)
public static <E> List<E> flatten(@NotNull
 Collection<E>[] collections)

Returns:

read-only list consisting of the elements from all of the collections

removeDuplicatesFromSorted

@NotNull
public static <T> List<T> removeDuplicatesFromSorted(@NotNull
 List<T> list,
 @NotNull
 Comparator<? super T> comparator)

Processes the list, remove all duplicates and return the list with unique elements.

Parameters:

list - must be sorted (according to the comparator), all elements must be not-null

flatten

@NotNull
@Contract(pure=true)
public static <E> List<E> flatten(@NotNull
 Iterable<? extends Collection<E>> collections)

Returns:

read-only list consisting of the elements from all of the collections

flattenIterables

@NotNull
@Contract(pure=true)
public static <E> List<E> flattenIterables(@NotNull
 Iterable<? extends Iterable<E>> collections)

Returns:

read-only list consisting of the elements from all of the collections

convert

@NotNull
public static <K,
V> V[] convert(@NotNull
 K[] from,
 @NotNull
 V[] to,
 @NotNull
 Function<K,V> fun)

containsIdentity

@Contract(pure=true)
public static <T> boolean containsIdentity(@NotNull
 Iterable<T> list,
 T element)

indexOfIdentity

@Contract(pure=true)
public static <T> int indexOfIdentity(@NotNull
 List<T> list,
 T element)

equalsIdentity

@Contract(pure=true)
public static <T> boolean equalsIdentity(@NotNull
 List<T> list1,
 @NotNull
 List<T> list2)

indexOf

@Contract(pure=true)
public static <T> int indexOf(@NotNull
 List<T> list,
 @NotNull
 Condition<? super T> condition)

lastIndexOf

@Contract(pure=true)
public static <T> int lastIndexOf(@NotNull
 List<T> list,
 @NotNull
 Condition<? super T> condition)

findLastInstance

@Nullable
@Contract(pure=true)
public static <T,
U extends T> U findLastInstance(@NotNull
 List<T> list,
 @NotNull
 Class<U> clazz)

lastIndexOfInstance

@Contract(pure=true)
public static <T,
U extends T> int lastIndexOfInstance(@NotNull
 List<T> list,
 @NotNull
 Class<U> clazz)

indexOf

@Contract(pure=true)
public static <T> int indexOf(@NotNull
 List<T> list,
 @NotNull
 T object)

reverseMap

@NotNull
@Contract(pure=true)
public static <A,
B> Map<B,A> reverseMap(@NotNull
 Map<A,B> map)

trimToSize

@Contract("null -> null; !null -> !null")
public static <T> List<T> trimToSize(@Nullable
 List<T> list)

newStack

@NotNull
@Contract(pure=true)
public static <T> Stack<T> newStack()

newStack

@NotNull
@Contract(pure=true)
public static <T> Stack<T> newStack(@NotNull
 Collection<T> initial)

newStack

@NotNull
@Contract(pure=true)
public static <T> Stack<T> newStack(@NotNull
 T... initial)

emptyList

@NotNull
@Contract(pure=true)
public static <T> List<T> emptyList()

createEmptyCOWList

@NotNull
@Contract(pure=true)
public static <T> CopyOnWriteArrayList<T> createEmptyCOWList()