ContainerUtil (Unofficial IntelliJ Community Edition API docs)

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 and Description
`static class`	`ContainerUtil.ImmutableMapBuilder<K,V>`
`static class`	`ContainerUtil.KeyOrderedMultiMap<K extends java.lang.Comparable<? super K>,V>`

Constructor Summary

Constructors
Constructor and Description

ContainerUtil()

Constructors
Constructor and Description
`ContainerUtil()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> void`	`add(T element, java.util.Collection<? super T> result, Disposable parentDisposable)`
`static <T> void`	`addAll(java.util.Collection<? super T> collection, java.util.Collection<? extends T> elements)` Deprecated. Use `Collection.addAll(Collection)` instead
`static <T> void`	`addAll(java.util.Collection<? super T> collection, java.util.Enumeration<? extends T> enumeration)`
`static <T> void`	`addAll(java.util.Collection<? super T> collection, java.lang.Iterable<? extends T> appendix)`
`static <T> void`	`addAll(java.util.Collection<? super T> collection, java.util.Iterator<? extends T> iterator)`
`static <T,C extends java.util.Collection<? super T>> C`	`addAll(C collection, T... elements)` Add all supplied elements to the supplied collection and returns the modified collection.
`static <T> void`	`addAllNotNull(java.util.Collection<? super T> collection, java.lang.Iterable<? extends T> elements)` Adds all not-null elements from the `elements`, ignoring nulls
`static <T> void`	`addAllNotNull(java.util.Collection<? super T> collection, java.util.Iterator<? extends T> elements)` Adds all not-null elements from the `elements`, ignoring nulls
`static <T,C extends java.util.Collection<T>> C`	`addAllNotNull(C collection, T... elements)` Adds all not-null elements from the `elements`, ignoring nulls
`static <T> void`	`addIfNotNull(java.util.Collection<? super T> result, T element)`
`static <T> void`	`addIfNotNull(T element, java.util.Collection<? super T> result)` Deprecated. use `addIfNotNull(Collection, Object)` instead
`static <T> boolean`	`all(java.util.Collection<? extends T> collection, Condition<? super T> condition)`
`static <T> boolean`	`and(java.lang.Iterable<? extends T> iterable, Condition<? super T> condition)`
`static <T> boolean`	`and(T [] iterable, Condition<? super T> condition)`
`static <T> java.util.List<T>`	`append(java.util.List<? extends T> list, T... values)`
`static <T> T []`	`ar(T... elements)`
`static <T> <any>`	`canonicalStrategy()`
`static <K,V> java.util.Map<K,java.util.Set<V>>`	`classify(java.util.Iterator<? extends V> iterator, Convertor<? super V,? extends K> keyConvertor)`
`static <T> java.util.List<T>`	`collect(java.util.Iterator<?> iterator, FilteringIterator.InstanceOf<T> instanceOf)`
`static <T> java.util.List<T>`	`collect(java.util.Iterator<? extends T> iterator)`
`static <T extends java.lang.Comparable<? super T>> int`	`compareLexicographically(java.util.List<? extends T> o1, java.util.List<? extends T> o2)`
`static <T> int`	`compareLexicographically(java.util.List<? extends T> o1, java.util.List<? extends T> o2, java.util.Comparator<? super T> comparator)`
`static <T> java.util.List<T>`	`concat(java.lang.Iterable<? extends java.util.Collection<? extends T>> list)`
`static <T> java.lang.Iterable<T>`	`concat(java.lang.Iterable<? extends T>... iterables)`
`static <T,V> java.util.List<V>`	`concat(java.lang.Iterable<? extends T> list, Function<? super T,? extends java.util.Collection<? extends V>> listGenerator)`
`static <T> java.lang.Iterable<T>`	`concat(java.lang.Iterable<? extends T> it1, java.lang.Iterable<? extends T> it2)`
`static <T> java.util.List<T>`	`concat(java.util.List<? extends T>... lists)`
`static <T> java.util.List<T>`	`concat(java.util.List<? extends T> list1, java.util.List<? extends T> list2)`
`static <T> java.util.List<T>`	`concat(java.util.List<java.util.List<? extends T>> lists)`
`static <T> java.lang.Iterable<T>`	`concat(T[]... iterables)`
`static <T,V> java.util.List<T>`	`concat(V [] array, Function<? super V,? extends java.util.Collection<? extends T>> fun)`
`static <T> java.util.Iterator<T>`	`concatIterators(java.util.Collection<? extends java.util.Iterator<? extends T>> iterators)`
`static <T> java.util.Iterator<T>`	`concatIterators(java.util.Iterator<? extends T>... iterators)`
`static <T> boolean`	`containsIdentity(java.lang.Iterable<? extends T> list, T element)`
`static <K,V> V []`	`convert(K [] from, V [] to, Function<? super K,? extends V> fun)`
`static <T> T []`	`copyAndClear(java.util.Collection<? extends T> collection, ArrayFactory<? extends T> factory, boolean clear)`
`static <T> java.util.List<T>`	`copyList(java.util.List<? extends T> list)`
`static <T> int`	`count(java.lang.Iterable<? extends T> iterable, Condition<? super T> condition)`
`static <V> ConcurrentIntObjectMap<V>`	`createConcurrentIntObjectMap()`
`static <V> ConcurrentIntObjectMap<V>`	`createConcurrentIntObjectMap(int initialCapacity, float loadFactor, int concurrencyLevel)`
`static <V> ConcurrentIntObjectMap<V>`	`createConcurrentIntObjectSoftValueMap()`
`static <V> ConcurrentIntObjectMap<V>`	`createConcurrentIntObjectWeakValueMap()`
`static <T> ConcurrentList<T>`	`createConcurrentList()`
`static <T> ConcurrentList<T>`	`createConcurrentList(java.util.Collection<? extends T> collection)`
`static <V> ConcurrentLongObjectMap<V>`	`createConcurrentLongObjectMap()`
`static <V> ConcurrentLongObjectMap<V>`	`createConcurrentLongObjectMap(int initialCapacity)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentSoftKeySoftValueMap()`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentSoftKeySoftValueMap(int initialCapacity, float loadFactor, int concurrencyLevel, <any> hashingStrategy)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentSoftMap()`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentSoftMap(int initialCapacity, float loadFactor, int concurrencyLevel, <any> hashingStrategy)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentSoftValueMap()`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentWeakKeySoftValueMap()`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentWeakKeySoftValueMap(int initialCapacity, float loadFactor, int concurrencyLevel, <any> hashingStrategy)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentWeakKeyWeakValueMap()`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentWeakKeyWeakValueMap(<any> strategy)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentWeakMap()`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentWeakMap(<any> hashingStrategy)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentWeakMap(int initialCapacity, float loadFactor, int concurrencyLevel, <any> hashingStrategy)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`createConcurrentWeakValueMap()`
`static <T> java.util.concurrent.CopyOnWriteArrayList<T>`	`createEmptyCOWList()`
`static <T> IntObjectMap<T>`	`createIntKeyWeakValueMap()`
`static <T> java.util.List<T>`	`createLockFreeCopyOnWriteList()` Creates List which is thread-safe to modify and iterate.
`static <T> java.util.List<T>`	`createLockFreeCopyOnWriteList(java.util.Collection<? extends T> c)`
`static <T> java.util.List<T>`	`createMaybeSingletonList(T element)`
`static <T> java.util.Set<T>`	`createMaybeSingletonSet(T element)`
`static <K,V> java.util.Map<K,V>`	`createSoftKeySoftValueMap()`
`static <K,V> java.util.Map<K,V>`	`createSoftMap()` Soft keys hard values hash map.
`static <K,V> java.util.Map<K,V>`	`createSoftMap(<any> strategy)`
`static <K,V> java.util.Map<K,V>`	`createSoftValueMap()` Hard keys soft values hash map.
`static <T> ObjectIntMap<T>`	`createWeakKeyIntValueMap()`
`static <K,V> java.util.Map<K,V>`	`createWeakKeySoftValueMap()`
`static <K,V> java.util.Map<K,V>`	`createWeakKeyWeakValueMap()`
`static <K,V> java.util.Map<K,V>`	`createWeakMap()` Weak keys hard values hash map.
`static <K,V> java.util.Map<K,V>`	`createWeakMap(int initialCapacity)`
`static <K,V> java.util.Map<K,V>`	`createWeakMap(int initialCapacity, float loadFactor, <any> strategy)`
`static <T> java.util.Set<T>`	`createWeakSet()`
`static <K,V> java.util.Map<K,V>`	`createWeakValueMap()` Hard keys weak values hash map.
`static <K,V> java.util.Map<K,Couple<V>>`	`diff(java.util.Map<? extends K,? extends V> map1, java.util.Map<? extends K,? extends V> map2)`
`static <T> java.lang.Iterable<T>`	`emptyIterable()` Deprecated. Use `Collections.emptyList()` instead
`static <T> java.util.Iterator<T>`	`emptyIterator()` Deprecated. Use `Collections.emptyIterator()` instead
`static <T> java.util.List<T>`	`emptyList()`
`static <T> boolean`	`equalsIdentity(java.util.List<? extends T> list1, java.util.List<? extends T> list2)`
`static <T> boolean`	`exists(java.lang.Iterable<? extends T> iterable, Condition<? super T> condition)`
`static <T> boolean`	`exists(T [] array, Condition<? super T> condition)`
`static <K,V> void`	`fillMapWithValues(java.util.Map<? super K,? super V> map, java.util.Iterator<? extends V> values, Convertor<? super V,? extends K> keyConvertor)`
`static <T> java.util.List<T>`	`filter(java.util.Collection<? extends T> collection, Condition<? super T> condition)`
`static int []`	`filter(int [] collection, TIntProcedure condition)`
`static <K,V> java.util.Map<K,V>`	`filter(java.util.Map<? extends K,? extends V> map, Condition<? super K> keyFilter)`
`static <T> java.util.List<T>`	`filter(T [] collection, Condition<? super T> condition)`
`static <T> java.util.List<T>`	`filterIsInstance(java.util.Collection<?> collection, java.lang.Class<? extends T> aClass)`
`static <T> java.util.Iterator<T>`	`filterIterator(java.util.Iterator<? extends T> iterator, Condition<? super T> filter)`
`static <T> T`	`find(java.lang.Iterable<? extends T> iterable, Condition<? super T> condition)`
`static <T> T`	`find(java.lang.Iterable<? extends T> iterable, T equalTo)`
`static <T> T`	`find(java.util.Iterator<? extends T> iterator, Condition<? super T> condition)`
`static <T> T`	`find(java.util.Iterator<? extends T> iterator, T equalTo)`
`static <T> T`	`find(T [] array, Condition<? super T> condition)`
`static <T,V> java.util.List<V>`	`findAll(java.util.Collection<? extends T> collection, java.lang.Class<V> instanceOf)`
`static <T> java.util.List<T>`	`findAll(java.util.Collection<? extends T> collection, Condition<? super T> condition)`
`static <T,V> java.util.List<V>`	`findAll(T [] array, java.lang.Class<V> instanceOf)`
`static <T> java.util.List<T>`	`findAll(T [] collection, Condition<? super T> condition)`
`static <T,V> V []`	`findAllAsArray(java.util.Collection<? extends T> collection, java.lang.Class<V> instanceOf)`
`static <T,V> V []`	`findAllAsArray(T [] collection, java.lang.Class<V> instanceOf)`
`static <T> T []`	`findAllAsArray(T [] collection, Condition<? super T> instanceOf)`
`static <T,U extends T> U`	`findInstance(java.lang.Iterable<? extends T> iterable, java.lang.Class<? extends U> aClass)`
`static <T,U extends T> U`	`findInstance(java.util.Iterator<? extends T> iterator, java.lang.Class<? extends U> aClass)`
`static <T,U extends T> U`	`findInstance(T [] array, java.lang.Class<? extends U> aClass)`
`static <T> T`	`findLast(java.util.List<? extends T> list, Condition<? super T> condition)`
`static <T,U extends T> U`	`findLastInstance(java.util.List<? extends T> list, java.lang.Class<? extends U> clazz)`
`static <T,V> java.util.List<V>`	`flatMap(java.lang.Iterable<? extends T> iterable, Function<? super T,? extends java.util.List<V>> mapping)`
`static <E> java.util.List<E>`	`flatten(java.util.Collection<E> [] collections)`
`static <E> java.util.List<E>`	`flatten(java.lang.Iterable<? extends java.util.Collection<? extends E>> collections)`
`static <E> java.util.List<E>`	`flattenIterables(java.lang.Iterable<? extends java.lang.Iterable<? extends E>> collections)`
`static <T> java.util.List<T>`	`freeze(java.util.List<? extends T> list)` Create an immutable copy of the `list`.
`static <T> T`	`getFirstItem(java.util.Collection<? extends T> items)`
`static <T> T`	`getFirstItem(java.util.Collection<? extends T> items, T defaultResult)`
`static <T> T`	`getFirstItem(java.util.List<? extends T> items)`
`static <T> java.util.List<T>`	`getFirstItems(java.util.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> T`	`getLastItem(java.util.List<? extends T> list)`
`static <T> T`	`getLastItem(java.util.List<? extends T> list, T def)`
`static <T> T`	`getOnlyItem(java.util.Collection<? extends T> items)` Returns the only item from the collection or null if collection is empty or contains more than one item
`static <T> T`	`getOnlyItem(java.util.Collection<? extends T> items, T defaultResult)`
`static <T,V> V`	`getOrCreate(java.util.Map<T,V> result, T key, Factory<? extends V> factory)`
`static <T,V> V`	`getOrCreate(java.util.Map<T,V> result, T key, V defaultValue)`
`static <T> T`	`getOrElse(java.util.List<? extends T> elements, int i, T defaultValue)`
`static <T,V> V`	`getOrElse(java.util.Map<? extends T,? extends V> map, T key, V defValue)`
`static <K,V> MultiMap<K,V>`	`groupBy(java.lang.Iterable<? extends V> collection, NullableFunction<? super V,? extends K> grouper)`
`static <T> <any>`	`identityStrategy()`
`static <E> ImmutableList<E>`	`immutableList(E... array)`
`static <E> ImmutableList<E>`	`immutableList(java.util.List<? extends E> list)`
`static <K,V> ContainerUtil.ImmutableMapBuilder<K,V>`	`immutableMapBuilder()`
`static <E> java.util.Set<E>`	`immutableSet(E... elements)`
`static <E> ImmutableList<E>`	`immutableSingletonList(E element)`
`static <T> int`	`indexOf(java.util.List<? extends T> list, Condition<? super T> condition)`
`static <T> int`	`indexOfIdentity(java.util.List<? extends T> list, T element)`
`static <T> java.util.Collection<T>`	`intersection(java.util.Collection<? extends T> collection1, java.util.Collection<? extends T> collection2)`
`static <E extends java.lang.Enum<E>> java.util.EnumSet<E>`	`intersection(java.util.EnumSet<E> collection1, java.util.EnumSet<E> collection2)`
`static <K,V> java.util.Map<K,V>`	`intersection(java.util.Map<? extends K,? extends V> map1, java.util.Map<? extends K,? extends V> map2)`
`static <T> boolean`	`intersects(java.util.Collection<? extends T> collection1, java.util.Collection<? extends T> collection2)`
`static <T> boolean`	`isEmpty(java.util.Collection<? extends T> collection)`
`static boolean`	`isEmpty(java.util.Map<?,?> map)`
`static <T> java.lang.Iterable<T>`	`iterate(java.util.Collection<? extends T> collection, Condition<? super T> condition)`
`static <T> java.util.Iterator<T>`	`iterate(java.util.Enumeration<? extends T> enumeration)`
`static <T> java.util.Iterator<T>`	`iterate(T [] array)`
`static <T> java.lang.Iterable<T>`	`iterate(T [] arrays, Condition<? super T> condition)`
`static <T> T`	`iterateAndGetLastItem(java.lang.Iterable<? extends T> items)`
`static <T> java.lang.Iterable<T>`	`iterateBackward(java.util.List<? extends T> list)`
`static <T> int`	`lastIndexOf(java.util.List<? extends T> list, Condition<? super T> condition)`
`static <T,U extends T> int`	`lastIndexOfInstance(java.util.List<? extends T> list, java.lang.Class<U> clazz)`
`static <T> java.util.List<T>`	`list(T... items)` Deprecated. Use `Arrays.asList(Object[])`
`static <T,V> java.util.List<V>`	`map(java.util.Collection<? extends T> collection, Function<? super T,? extends V> mapping)`
`static <T,V> java.util.List<V>`	`map(java.lang.Iterable<? extends T> iterable, Function<? super T,? extends V> mapping)`
`static <T,V> java.util.List<V>`	`map(T [] array, Function<? super T,? extends V> mapping)`
`static <T,V> V []`	`map(T [] arr, Function<? super T,? extends V> mapping, V [] emptyArray)`
`static <T,V> V []`	`map2Array(java.util.Collection<? extends T> collection, java.lang.Class<V> aClass, Function<? super T,? extends V> mapper)`
`static <T> java.lang.Object []`	`map2Array(java.util.Collection<? extends T> array, Function<? super T,java.lang.Object> mapper)`
`static <T,V> V []`	`map2Array(java.util.Collection<? extends T> collection, V [] to, Function<? super T,V> mapper)`
`static <T,V> V []`	`map2Array(T [] array, java.lang.Class<V> aClass, Function<? super T,? extends V> mapper)`
`static <T> java.lang.Object []`	`map2Array(T [] array, Function<? super T,java.lang.Object> mapper)`
`static <T,V> java.util.Set<V>`	`map2LinkedSet(java.util.Collection<? extends T> collection, Function<? super T,? extends V> mapper)`
`static <T,V> java.util.List<V>`	`map2List(java.util.Collection<? extends T> collection, Function<? super T,? extends V> mapper)`
`static <K,V> java.util.List<Pair<K,V>>`	`map2List(java.util.Map<? extends K,? extends V> map)`
`static <T,V> java.util.List<V>`	`map2List(T [] array, Function<? super T,? extends V> mapper)`
`static <K,V> java.util.Map<K,V>`	`map2Map(java.util.Collection<? extends Pair<? extends K,? extends V>> collection)`
`static <T,K,V> java.util.Map<K,V>`	`map2Map(java.util.Collection<? extends T> collection, Function<? super T,? extends Pair<K,V>> mapper)`
`static <T,K,V> java.util.Map<K,V>`	`map2Map(T [] collection, Function<? super T,? extends Pair<K,V>> mapper)`
`static <T,K,V> java.util.Map<K,V>`	`map2MapNotNull(java.util.Collection<? extends T> collection, Function<? super T,? extends Pair<K,V>> mapper)`
`static <T,K,V> java.util.Map<K,V>`	`map2MapNotNull(T [] collection, Function<? super T,? extends Pair<K,V>> mapper)`
`static <T,V> java.util.Set<V>`	`map2Set(java.util.Collection<? extends T> collection, Function<? super T,? extends V> mapper)`
`static <T,V> java.util.Set<V>`	`map2Set(T [] array, Function<? super T,? extends V> mapper)`
`static <T,V> java.util.Set<V>`	`map2SetNotNull(java.util.Collection<? extends T> collection, Function<? super T,? extends V> mapper)`
`static <T,U> java.util.Iterator<U>`	`mapIterator(java.util.Iterator<? extends T> iterator, Function<? super T,? extends U> mapper)`
`static <U> java.util.Iterator<U>`	`mapIterator(TIntIterator iterator, java.util.function.IntFunction<? extends U> mapper)`
`static <T,V> java.util.List<V>`	`mapNotNull(java.util.Collection<? extends T> collection, Function<? super T,? extends V> mapping)`
`static <T,V> java.util.List<V>`	`mapNotNull(java.lang.Iterable<? extends T> iterable, Function<? super T,? extends V> mapping)`
`static <T,V> java.util.List<V>`	`mapNotNull(T [] array, Function<? super T,? extends V> mapping)`
`static <T,V> V []`	`mapNotNull(T [] array, Function<? super T,? extends V> mapping, V [] emptyArray)`
`static <T> T []`	`mergeCollectionsToArray(java.util.Collection<? extends T> c1, java.util.Collection<? extends T> c2, ArrayFactory<? extends T> factory)`
`static <T> java.util.List<T>`	`mergeSortedLists(java.util.List<? extends T> list1, java.util.List<? extends T> list2, java.util.Comparator<? super T> comparator, boolean mergeEqualItems)`
`static <T> java.util.ArrayList<T>`	`newArrayList()` Deprecated. Use `ArrayList()`
`static <E> java.util.ArrayList<E>`	`newArrayList(java.util.Collection<? extends E> iterable)` Deprecated. Use `ArrayList(Collection)` instead
`static <E> java.util.ArrayList<E>`	`newArrayList(E... array)`
`static <E> java.util.ArrayList<E>`	`newArrayList(java.lang.Iterable<? extends E> iterable)`
`static <T> java.util.List<T>`	`newArrayList(T [] elements, int start, int end)`
`static <T> java.util.ArrayList<T>`	`newArrayListWithCapacity(int size)` Deprecated. Use `ArrayList(int)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`newConcurrentMap()`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`newConcurrentMap(int initialCapacity)`
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`newConcurrentMap(int initialCapacity, float loadFactor, int concurrencyLevel)`
`static <T> java.util.Set<T>`	`newConcurrentSet()`
`static <K extends java.lang.Enum<K>,V> java.util.EnumMap<K,V>`	`newEnumMap(java.lang.Class<K> keyType)` Deprecated. Use `EnumMap(Class)`
`static <K,V> java.util.HashMap<K,V>`	`newHashMap()` Deprecated. Use `HashMap()`
`static <K,V> java.util.Map<K,V>`	`newHashMap(java.util.List<? extends K> keys, java.util.List<? extends V> values)`
`static <K,V> java.util.HashMap<K,V>`	`newHashMap(java.util.Map<? extends K,? extends V> map)` Deprecated. Use `HashMap(Map)`
`static <K,V> java.util.Map<K,V>`	`newHashMap(Pair<? extends K,? extends V> first, Pair<? extends K,? extends V>... entries)`
`static <T> java.util.Set<T>`	`newHashOrEmptySet(java.lang.Iterable<? extends T> iterable)`
`static <T> java.util.HashSet<T>`	`newHashSet()` Deprecated. Use `HashSet()`
`static <T> java.util.HashSet<T>`	`newHashSet(java.util.Collection<? extends T> collection)` Deprecated. Use `HashSet(Collection)`
`static <T> java.util.HashSet<T>`	`newHashSet(int initialCapacity)` Deprecated. Use `HashSet(int)`
`static <T> java.util.HashSet<T>`	`newHashSet(java.lang.Iterable<? extends T> iterable)`
`static <T> java.util.HashSet<T>`	`newHashSet(java.util.Iterator<? extends T> iterator)`
`static <T> java.util.HashSet<T>`	`newHashSet(T... elements)`
`static <K,V> java.util.IdentityHashMap<K,V>`	`newIdentityHashMap()`
`static <K,V> <any>`	`newIdentityTroveMap()`
`static <K> <any>`	`newIdentityTroveSet()`
`static <K> <any>`	`newIdentityTroveSet(java.util.Collection<? extends K> collection)`
`static <K> <any>`	`newIdentityTroveSet(int initialCapacity)`
`static <K,V> java.util.LinkedHashMap<K,V>`	`newLinkedHashMap()` Deprecated. Use `LinkedHashMap()`
`static <K,V> java.util.LinkedHashMap<K,V>`	`newLinkedHashMap(java.util.Map<? extends K,? extends V> map)` Deprecated. Use `LinkedHashMap(Map)`
`static <K,V> java.util.LinkedHashMap<K,V>`	`newLinkedHashMap(Pair<? extends K,? extends V> first, Pair<? extends K,? extends V>... entries)`
`static <T> java.util.LinkedHashSet<T>`	`newLinkedHashSet()` Deprecated. Use `LinkedHashSet()`
`static <T> java.util.LinkedHashSet<T>`	`newLinkedHashSet(java.util.Collection<? extends T> elements)` Deprecated. Use `LinkedHashSet(Collection)` instead
`static <T> java.util.LinkedHashSet<T>`	`newLinkedHashSet(java.lang.Iterable<? extends T> elements)`
`static <T> java.util.LinkedHashSet<T>`	`newLinkedHashSet(T... elements)`
`static <T> java.util.LinkedList<T>`	`newLinkedList()` Deprecated. Use `LinkedList()`
`static <T> java.util.LinkedList<T>`	`newLinkedList(T... elements)`
`static <K,V> java.util.Map<K,V>`	`newMapFromKeys(java.util.Iterator<? extends K> keys, Convertor<? super K,? extends V> valueConvertor)`
`static <K,V> java.util.Map<K,V>`	`newMapFromValues(java.util.Iterator<? extends V> values, Convertor<? super V,? extends K> keyConvertor)`
`static <T> java.util.List<T>`	`newSmartList()` Deprecated. Use `SmartList()`
`static <T> java.util.List<T>`	`newSmartList(T... elements)` Deprecated. Use `SmartList(T)`
`static <T> java.util.List<T>`	`newSmartList(T element)` Deprecated. Use `SmartList(T)`
`static <T> Stack<T>`	`newStack()` Deprecated. Use `Stack()`
`static <K extends java.lang.Comparable<? super K>,V> java.util.TreeMap<K,V>`	`newTreeMap()` Deprecated. Use `TreeMap()`
`static <K extends java.lang.Comparable<? super K>,V> java.util.TreeMap<K,V>`	`newTreeMap(java.util.Map<? extends K,? extends V> map)` Deprecated. Use `TreeMap(Map)`
`static <T extends java.lang.Comparable<? super T>> java.util.TreeSet<T>`	`newTreeSet()` Deprecated. Use `TreeSet()`
`static <T> java.util.TreeSet<T>`	`newTreeSet(java.util.Comparator<? super T> comparator)` Deprecated. Use `TreeSet(Comparator)`
`static <K,V> <any>`	`newTroveMap()` Deprecated. Use `THashMap#THashMap(Map)`
`static <K,V> <any>`	`newTroveMap(<any> strategy)` Deprecated. Use `THashMap#THashMap(TObjectHashingStrategy)`
`static <T> <any>`	`newTroveSet()` Deprecated. Use `THashSet#THashSet()`
`static <T> <any>`	`newTroveSet(<any> strategy)` Deprecated. Use `THashSet#THashSet(TObjectHashingStrategy)`
`static <T> <any>`	`newTroveSet(<any> strategy, java.util.Collection<? extends T> elements)`
`static <T> <any>`	`newTroveSet(<any> strategy, T... elements)`
`static <T> <any>`	`newTroveSet(java.util.Collection<? extends T> elements)` Deprecated. Use `THashSet#THashSet(Collection)`
`static <T> <any>`	`newTroveSet(T... elements)`
`static <T> java.util.List<T>`	`newUnmodifiableList(java.util.List<? extends T> originalList)`
`static <T> java.util.List<T>`	`notNullize(java.util.List<T> list)`
`static <K,V> java.util.Map<K,V>`	`notNullize(java.util.Map<K,V> map)`
`static <T> java.util.Set<T>`	`notNullize(java.util.Set<T> set)`
`static <T,C extends java.util.Collection<? extends T>> C`	`nullize(C collection)`
`static <T> boolean`	`or(java.lang.Iterable<? extends T> iterable, Condition<? super T> condition)`
`static <T> boolean`	`or(T [] iterable, Condition<? super T> condition)`
`static <T> java.util.List<T>`	`packNullables(T... elements)`
`static <T> java.util.List<T>`	`prepend(java.util.List<? extends T> list, T... values)` prepend values in front of the list
`static <T> boolean`	`process(java.lang.Iterable<? extends T> iterable, Processor<? super T> processor)`
`static <T> boolean`	`process(java.util.Iterator<? extends T> iterator, Processor<? super T> processor)`
`static <T> boolean`	`process(java.util.List<? extends T> list, Processor<? super T> processor)`
`static <T> boolean`	`process(T [] iterable, Processor<? super T> processor)`
`static <T> void`	`processSortedListsInOrder(java.util.List<? extends T> list1, java.util.List<? extends T> list2, java.util.Comparator<? super T> comparator, boolean mergeEqualItems, Consumer<? super T> processor)`
`static <K,V> void`	`putIfAbsent(K key, V value, java.util.Map<? super K,? super V> result)`
`static <K,V> void`	`putIfNotNull(K key, java.util.Collection<? extends V> value, MultiMap<? super K,? super V> result)`
`static <K,V> void`	`putIfNotNull(K key, V value, java.util.Map<? super K,? super V> result)`
`static <K,V> void`	`putIfNotNull(K key, V value, MultiMap<? super K,? super V> result)`
`static <T> void`	`quickSort(java.util.List<? extends T> list, java.util.Comparator<? super T> comparator)`
`static <T> boolean`	`removeAll(java.util.Collection<T> collection, T... elements)`
`static <T> void`	`removeDuplicates(java.util.Collection<T> collection)`
`static <T> java.util.List<T>`	`removeDuplicatesFromSorted(java.util.List<T> list, java.util.Comparator<? super T> comparator)` Processes the list, remove all duplicates and return the list with unique elements.
`static <T> boolean`	`retainAll(java.util.Collection<T> collection, Condition<? super T> condition)`
`static <E> java.util.List<E>`	`reverse(java.util.List<? extends E> elements)`
`static <A,B> java.util.Map<B,A>`	`reverseMap(java.util.Map<? extends A,? extends B> map)`
`static <T> java.util.Set<T>`	`set(T... items)`
`static <T> java.util.Set<T>`	`singleton(T o, <any> strategy)`
`static <T> java.util.List<T>`	`skipNulls(java.util.Collection<? extends T> collection)`
`static <T extends java.lang.Comparable<? super T>> void`	`sort(java.util.List<T> list)`
`static <T> void`	`sort(java.util.List<T> list, java.util.Comparator<? super T> comparator)`
`static <T extends java.lang.Comparable<? super T>> void`	`sort(T [] a)`
`static <T> void`	`sort(T [] a, java.util.Comparator<? super T> comparator)`
`static <T extends java.lang.Comparable<? super T>> java.util.List<T>`	`sorted(java.util.Collection<? extends T> list)`
`static <T> java.util.List<T>`	`sorted(java.util.Collection<? extends T> list, java.util.Comparator<? super T> comparator)`
`static <T> java.util.List<T>`	`sorted(java.lang.Iterable<? extends T> list, java.util.Comparator<? super T> comparator)`
`static <T> boolean`	`startsWith(java.util.List<? extends T> list, java.util.List<? extends T> prefix)`
`static java.util.Map<java.lang.String,java.lang.String>`	`stringMap(java.lang.String... keyValues)`
`static <T> java.util.List<T>`	`subList(java.util.List<T> list, int from)`
`static <T> java.util.Collection<T>`	`subtract(java.util.Collection<? extends T> from, java.util.Collection<? extends T> what)`
`static <E> void`	`swapElements(java.util.List<E> list, int index1, int index2)`
`static <T> T []`	`toArray(java.util.Collection<? extends T> c1, java.util.Collection<? extends T> c2, ArrayFactory<? extends T> factory)`
`static <T> T []`	`toArray(java.util.Collection<? extends T> c, T [] sample)` Deprecated. use `Collection.toArray(Object[])` instead
`static <T> T []`	`toArray(java.util.Collection<T> c, ArrayFactory<? extends T> factory)`
`static <T> T []`	`toArray(java.util.List<T> collection, T [] array)` Deprecated. use `List.toArray(Object[])` instead
`static <T> java.util.Collection<T>`	`toCollection(java.lang.Iterable<? extends T> iterable)`
`static <T> java.util.List<T>`	`toList(java.util.Enumeration<? extends T> enumeration)`
`static java.lang.String`	`toString(java.util.Map<?,?> map)` Returns a String representation of the given map, by listing all key-value pairs contained in the map.
`static <T> java.util.List<T>`	`trimToSize(java.util.List<T> list)`
`static <T> java.util.Set<T>`	`union(java.util.Collection<? extends T> set, java.util.Collection<? extends T> set2)`
`static <K,V> java.util.Map<K,V>`	`union(java.util.Map<? extends K,? extends V> map, java.util.Map<? extends K,? extends V> map2)`
`static <T> java.util.Set<T>`	`union(java.util.Set<? extends T> set, java.util.Set<? extends T> set2)`
`static <T> java.util.Collection<T>`	`unmodifiableOrEmptyCollection(java.util.Collection<? extends T> original)`
`static <T> java.util.List<T>`	`unmodifiableOrEmptyList(java.util.List<? extends T> original)`
`static <K,V> java.util.Map<K,V>`	`unmodifiableOrEmptyMap(java.util.Map<? extends K,? extends V> original)`
`static <T> java.util.Set<T>`	`unmodifiableOrEmptySet(java.util.Set<? extends T> original)`
`static <T,E> java.lang.Iterable<Pair<T,E>>`	`zip(java.lang.Iterable<? extends T> iterable1, java.lang.Iterable<? extends E> iterable2)`

Methods inherited from class com.intellij.util.containers.ContainerUtilRt
newArrayList, newArrayList, newArrayList, newHashMap, newHashSet, newLinkedHashSet, newLinkedList, newLinkedList, putValue

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- ContainerUtil
```
public ContainerUtil()
```

Method Detail

ar

@SafeVarargs
public static <T> T [] ar(T... elements)

newHashMap

@Deprecated
public static <K,V> java.util.HashMap<K,V> newHashMap()

Deprecated. Use HashMap()

newHashMap

@Deprecated
public static <K,V> java.util.HashMap<K,V> newHashMap(java.util.Map<? extends K,? extends V> map)

Deprecated. Use HashMap(Map)

newHashMap

@SafeVarargs
public static <K,V> java.util.Map<K,V> newHashMap(Pair<? extends K,? extends V> first,
                                                  Pair<? extends K,? extends V>... entries)

newHashMap

public static <K,V> java.util.Map<K,V> newHashMap(java.util.List<? extends K> keys,
                                                  java.util.List<? extends V> values)

newTreeMap

@Deprecated
public static <K extends java.lang.Comparable<? super K>,V> java.util.TreeMap<K,V> newTreeMap()

Deprecated. Use TreeMap()

newTreeMap

@Deprecated
public static <K extends java.lang.Comparable<? super K>,V> java.util.TreeMap<K,V> newTreeMap(java.util.Map<? extends K,? extends V> map)

Deprecated. Use TreeMap(Map)

newLinkedHashMap

@Deprecated
public static <K,V> java.util.LinkedHashMap<K,V> newLinkedHashMap()

Deprecated. Use LinkedHashMap()

newLinkedHashMap

@Deprecated
public static <K,V> java.util.LinkedHashMap<K,V> newLinkedHashMap(java.util.Map<? extends K,? extends V> map)

Deprecated. Use LinkedHashMap(Map)

newLinkedHashMap

@SafeVarargs
public static <K,V> java.util.LinkedHashMap<K,V> newLinkedHashMap(Pair<? extends K,? extends V> first,
                                                                  Pair<? extends K,? extends V>... entries)

newTroveMap

@Deprecated
public static <K,V> <any> newTroveMap()

Deprecated. Use THashMap#THashMap(Map)

newTroveMap

@Deprecated
public static <K,V> <any> newTroveMap(<any> strategy)

Deprecated. Use THashMap#THashMap(TObjectHashingStrategy)

newEnumMap

@Deprecated
public static <K extends java.lang.Enum<K>,V> java.util.EnumMap<K,V> newEnumMap(java.lang.Class<K> keyType)

Deprecated. Use EnumMap(Class)

canonicalStrategy

public static <T> <any> canonicalStrategy()

identityStrategy

public static <T> <any> identityStrategy()

newIdentityHashMap

public static <K,V> java.util.IdentityHashMap<K,V> newIdentityHashMap()

newLinkedList

@Deprecated
public static <T> java.util.LinkedList<T> newLinkedList()

Deprecated. Use LinkedList()

newLinkedList

@SafeVarargs
public static <T> java.util.LinkedList<T> newLinkedList(T... elements)

newArrayList

@Deprecated
public static <T> java.util.ArrayList<T> newArrayList()

Deprecated. Use ArrayList()

newArrayList

@SafeVarargs
public static <E> java.util.ArrayList<E> newArrayList(E... array)

newArrayList

@Deprecated
public static <E> java.util.ArrayList<E> newArrayList(java.util.Collection<? extends E> iterable)

Deprecated. Use ArrayList(Collection) instead

newArrayList

public static <E> java.util.ArrayList<E> newArrayList(java.lang.Iterable<? extends E> iterable)

newArrayListWithCapacity

@Deprecated
public static <T> java.util.ArrayList<T> newArrayListWithCapacity(int size)

Deprecated. Use ArrayList(int)

newArrayList

public static <T> java.util.List<T> newArrayList(T [] elements,
                                                 int start,
                                                 int end)

newUnmodifiableList

public static <T> java.util.List<T> newUnmodifiableList(java.util.List<? extends T> originalList)

unmodifiableOrEmptyCollection

public static <T> java.util.Collection<T> unmodifiableOrEmptyCollection(java.util.Collection<? extends T> original)

unmodifiableOrEmptyList

public static <T> java.util.List<T> unmodifiableOrEmptyList(java.util.List<? extends T> original)

unmodifiableOrEmptySet

public static <T> java.util.Set<T> unmodifiableOrEmptySet(java.util.Set<? extends T> original)

unmodifiableOrEmptyMap

public static <K,V> java.util.Map<K,V> unmodifiableOrEmptyMap(java.util.Map<? extends K,? extends V> original)

newSmartList

@Deprecated
public static <T> java.util.List<T> newSmartList()

Deprecated. Use SmartList()

newSmartList

@Deprecated
public static <T> java.util.List<T> newSmartList(T element)

Deprecated. Use SmartList(T)

newSmartList

@SafeVarargs
@Deprecated
public static <T> java.util.List<T> newSmartList(T... elements)

Deprecated. Use SmartList(T)

newHashSet

@Deprecated
public static <T> java.util.HashSet<T> newHashSet()

Deprecated. Use HashSet()

newHashSet

@Deprecated
public static <T> java.util.HashSet<T> newHashSet(int initialCapacity)

Deprecated. Use HashSet(int)

newHashSet

@SafeVarargs
public static <T> java.util.HashSet<T> newHashSet(T... elements)

newHashSet

public static <T> java.util.HashSet<T> newHashSet(java.lang.Iterable<? extends T> iterable)

newHashSet

@Deprecated
public static <T> java.util.HashSet<T> newHashSet(java.util.Collection<? extends T> collection)

Deprecated. Use HashSet(Collection)

newHashSet

public static <T> java.util.HashSet<T> newHashSet(java.util.Iterator<? extends T> iterator)

newHashOrEmptySet

public static <T> java.util.Set<T> newHashOrEmptySet(java.lang.Iterable<? extends T> iterable)

newLinkedHashSet

@Deprecated
public static <T> java.util.LinkedHashSet<T> newLinkedHashSet()

Deprecated. Use LinkedHashSet()

newLinkedHashSet

public static <T> java.util.LinkedHashSet<T> newLinkedHashSet(java.lang.Iterable<? extends T> elements)

newLinkedHashSet

@Deprecated
public static <T> java.util.LinkedHashSet<T> newLinkedHashSet(java.util.Collection<? extends T> elements)

Deprecated. Use LinkedHashSet(Collection) instead

newLinkedHashSet

@SafeVarargs
public static <T> java.util.LinkedHashSet<T> newLinkedHashSet(T... elements)

newTroveSet

@Deprecated
public static <T> <any> newTroveSet()

Deprecated. Use THashSet#THashSet()

newTroveSet

@Deprecated
public static <T> <any> newTroveSet(<any> strategy)

Deprecated. Use THashSet#THashSet(TObjectHashingStrategy)

newTroveSet

@SafeVarargs
public static <T> <any> newTroveSet(T... elements)

newTroveSet

@SafeVarargs
public static <T> <any> newTroveSet(<any> strategy,
                                    T... elements)

newTroveSet

public static <T> <any> newTroveSet(<any> strategy,
                                    java.util.Collection<? extends T> elements)

newTroveSet

@Deprecated
public static <T> <any> newTroveSet(java.util.Collection<? extends T> elements)

Deprecated. Use THashSet#THashSet(Collection)

newIdentityTroveSet

public static <K> <any> newIdentityTroveSet()

newIdentityTroveSet

public static <K> <any> newIdentityTroveSet(int initialCapacity)

newIdentityTroveSet

public static <K> <any> newIdentityTroveSet(java.util.Collection<? extends K> collection)

newIdentityTroveMap

public static <K,V> <any> newIdentityTroveMap()

newTreeSet

@Deprecated
public static <T extends java.lang.Comparable<? super T>> java.util.TreeSet<T> newTreeSet()

Deprecated. Use TreeSet()

newTreeSet

@Deprecated
public static <T> java.util.TreeSet<T> newTreeSet(java.util.Comparator<? super T> comparator)

Deprecated. Use TreeSet(Comparator)

newConcurrentSet

public static <T> java.util.Set<T> newConcurrentSet()

newConcurrentMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> newConcurrentMap()

newConcurrentMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> newConcurrentMap(int initialCapacity)

newConcurrentMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> newConcurrentMap(int initialCapacity,
                                                                             float loadFactor,
                                                                             int concurrencyLevel)

reverse

public static <E> java.util.List<E> reverse(java.util.List<? extends E> elements)

union

public static <K,V> java.util.Map<K,V> union(java.util.Map<? extends K,? extends V> map,
                                             java.util.Map<? extends K,? extends V> map2)

union

public static <T> java.util.Set<T> union(java.util.Set<? extends T> set,
                                         java.util.Set<? extends T> set2)

union

public static <T> java.util.Set<T> union(java.util.Collection<? extends T> set,
                                         java.util.Collection<? extends T> set2)

immutableSet

@SafeVarargs
public static <E> java.util.Set<E> immutableSet(E... elements)

immutableList

@SafeVarargs
public static <E> ImmutableList<E> immutableList(E... array)

immutableSingletonList

public static <E> ImmutableList<E> immutableSingletonList(E element)

immutableList

public static <E> ImmutableList<E> immutableList(java.util.List<? extends E> list)

immutableMapBuilder

public static <K,V> ContainerUtil.ImmutableMapBuilder<K,V> immutableMapBuilder()

groupBy

public static <K,V> MultiMap<K,V> groupBy(java.lang.Iterable<? extends V> collection,
                                          NullableFunction<? super V,? extends K> grouper)

getOrElse

public static <T> T getOrElse(java.util.List<? extends T> elements,
                              int i,
                              T defaultValue)

mapIterator

public static <U> java.util.Iterator<U> mapIterator(TIntIterator iterator,
                                                    java.util.function.IntFunction<? extends U> mapper)

intersection

public static <K,V> java.util.Map<K,V> intersection(java.util.Map<? extends K,? extends V> map1,
                                                    java.util.Map<? extends K,? extends V> map2)

diff

public static <K,V> java.util.Map<K,Couple<V>> diff(java.util.Map<? extends K,? extends V> map1,
                                                    java.util.Map<? extends K,? extends V> map2)

processSortedListsInOrder

public static <T> void processSortedListsInOrder(java.util.List<? extends T> list1,
                                                 java.util.List<? extends T> list2,
                                                 java.util.Comparator<? super T> comparator,
                                                 boolean mergeEqualItems,
                                                 Consumer<? super T> processor)

mergeSortedLists

public static <T> java.util.List<T> mergeSortedLists(java.util.List<? extends T> list1,
                                                     java.util.List<? extends T> list2,
                                                     java.util.Comparator<? super T> comparator,
                                                     boolean mergeEqualItems)

subList

public static <T> java.util.List<T> subList(java.util.List<T> list,
                                            int from)

addAll

@Deprecated
public static <T> void addAll(java.util.Collection<? super T> collection,
                              java.util.Collection<? extends T> elements)

Deprecated. Use Collection.addAll(Collection) instead

addAll

public static <T> void addAll(java.util.Collection<? super T> collection,
                              java.lang.Iterable<? extends T> appendix)

addAll

public static <T> void addAll(java.util.Collection<? super T> collection,
                              java.util.Iterator<? extends T> iterator)

addAllNotNull

public static <T> void addAllNotNull(java.util.Collection<? super T> collection,
                                     java.lang.Iterable<? extends T> elements)

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

addAllNotNull

public static <T> void addAllNotNull(java.util.Collection<? super T> collection,
                                     java.util.Iterator<? extends T> elements)

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

collect

public static <T> java.util.List<T> collect(java.util.Iterator<? extends T> iterator)

newMapFromKeys

public static <K,V> java.util.Map<K,V> newMapFromKeys(java.util.Iterator<? extends K> keys,
                                                      Convertor<? super K,? extends V> valueConvertor)

newMapFromValues

public static <K,V> java.util.Map<K,V> newMapFromValues(java.util.Iterator<? extends V> values,
                                                        Convertor<? super V,? extends K> keyConvertor)

fillMapWithValues

public static <K,V> void fillMapWithValues(java.util.Map<? super K,? super V> map,
                                           java.util.Iterator<? extends V> values,
                                           Convertor<? super V,? extends K> keyConvertor)

classify

public static <K,V> java.util.Map<K,java.util.Set<V>> classify(java.util.Iterator<? extends V> iterator,
                                                               Convertor<? super V,? extends K> keyConvertor)

emptyIterator

@Deprecated
public static <T> java.util.Iterator<T> emptyIterator()

Deprecated. Use Collections.emptyIterator() instead

emptyIterable

@Deprecated
public static <T> java.lang.Iterable<T> emptyIterable()

Deprecated. Use Collections.emptyList() instead

find

public static <T> T find(T [] array,
                         Condition<? super T> condition)

process

public static <T> boolean process(java.lang.Iterable<? extends T> iterable,
                                  Processor<? super T> processor)

process

public static <T> boolean process(java.util.List<? extends T> list,
                                  Processor<? super T> processor)

process

public static <T> boolean process(T [] iterable,
                                  Processor<? super T> processor)

process

public static <T> boolean process(java.util.Iterator<? extends T> iterator,
                                  Processor<? super T> processor)

find

public static <T> T find(java.lang.Iterable<? extends T> iterable,
                         Condition<? super T> condition)

find

public static <T> T find(java.lang.Iterable<? extends T> iterable,
                         T equalTo)

find

public static <T> T find(java.util.Iterator<? extends T> iterator,
                         T equalTo)

find

public static <T> T find(java.util.Iterator<? extends T> iterator,
                         Condition<? super T> condition)

findLast

public static <T> T findLast(java.util.List<? extends T> list,
                             Condition<? super T> condition)

map2Map

public static <T,K,V> java.util.Map<K,V> map2Map(T [] collection,
                                                 Function<? super T,? extends Pair<K,V>> mapper)

map2Map

public static <T,K,V> java.util.Map<K,V> map2Map(java.util.Collection<? extends T> collection,
                                                 Function<? super T,? extends Pair<K,V>> mapper)

map2MapNotNull

public static <T,K,V> java.util.Map<K,V> map2MapNotNull(T [] collection,
                                                        Function<? super T,? extends Pair<K,V>> mapper)

map2MapNotNull

public static <T,K,V> java.util.Map<K,V> map2MapNotNull(java.util.Collection<? extends T> collection,
                                                        Function<? super T,? extends Pair<K,V>> mapper)

map2Map

public static <K,V> java.util.Map<K,V> map2Map(java.util.Collection<? extends Pair<? extends K,? extends V>> collection)

map2Array

public static <T> java.lang.Object [] map2Array(T [] array,
                                                Function<? super T,java.lang.Object> mapper)

map2Array

public static <T> java.lang.Object [] map2Array(java.util.Collection<? extends T> array,
                                                Function<? super T,java.lang.Object> mapper)

map2Array

public static <T,V> V [] map2Array(T [] array,
                                   java.lang.Class<V> aClass,
                                   Function<? super T,? extends V> mapper)

map2Array

public static <T,V> V [] map2Array(java.util.Collection<? extends T> collection,
                                   java.lang.Class<V> aClass,
                                   Function<? super T,? extends V> mapper)

map2Array

public static <T,V> V [] map2Array(java.util.Collection<? extends T> collection,
                                   V [] to,
                                   Function<? super T,V> mapper)

filter

public static <T> java.util.List<T> filter(T [] collection,
                                           Condition<? super T> condition)

filter

public static int [] filter(int [] collection,
                            TIntProcedure condition)

findAll

public static <T> java.util.List<T> findAll(T [] collection,
                                            Condition<? super T> condition)

filterIsInstance

public static <T> java.util.List<T> filterIsInstance(java.util.Collection<?> collection,
                                                     java.lang.Class<? extends T> aClass)

filter

public static <T> java.util.List<T> filter(java.util.Collection<? extends T> collection,
                                           Condition<? super T> condition)

filter

public static <K,V> java.util.Map<K,V> filter(java.util.Map<? extends K,? extends V> map,
                                              Condition<? super K> keyFilter)

findAll

public static <T> java.util.List<T> findAll(java.util.Collection<? extends T> collection,
                                            Condition<? super T> condition)

skipNulls

public static <T> java.util.List<T> skipNulls(java.util.Collection<? extends T> collection)

findAll

public static <T,V> java.util.List<V> findAll(T [] array,
                                              java.lang.Class<V> instanceOf)

findAllAsArray

public static <T,V> V [] findAllAsArray(T [] collection,
                                        java.lang.Class<V> instanceOf)

findAllAsArray

public static <T,V> V [] findAllAsArray(java.util.Collection<? extends T> collection,
                                        java.lang.Class<V> instanceOf)

findAllAsArray

public static <T> T [] findAllAsArray(T [] collection,
                                      Condition<? super T> instanceOf)

findAll

public static <T,V> java.util.List<V> findAll(java.util.Collection<? extends T> collection,
                                              java.lang.Class<V> instanceOf)

all

public static <T> boolean all(java.util.Collection<? extends T> collection,
                              Condition<? super T> condition)

removeDuplicates

public static <T> void removeDuplicates(java.util.Collection<T> collection)

stringMap

public static java.util.Map<java.lang.String,java.lang.String> stringMap(java.lang.String... keyValues)

iterate

public static <T> java.util.Iterator<T> iterate(T [] array)

iterate

public static <T> java.util.Iterator<T> iterate(java.util.Enumeration<? extends T> enumeration)

iterate

public static <T> java.lang.Iterable<T> iterate(T [] arrays,
                                                Condition<? super T> condition)

iterate

public static <T> java.lang.Iterable<T> iterate(java.util.Collection<? extends T> collection,
                                                Condition<? super T> condition)

iterateBackward

public static <T> java.lang.Iterable<T> iterateBackward(java.util.List<? extends T> list)

zip

public static <T,E> java.lang.Iterable<Pair<T,E>> zip(java.lang.Iterable<? extends T> iterable1,
                                                      java.lang.Iterable<? extends E> iterable2)

swapElements

public static <E> void swapElements(java.util.List<E> list,
                                    int index1,
                                    int index2)

collect

public static <T> java.util.List<T> collect(java.util.Iterator<?> iterator,
                                            FilteringIterator.InstanceOf<T> instanceOf)

addAll

public static <T> void addAll(java.util.Collection<? super T> collection,
                              java.util.Enumeration<? extends T> enumeration)

addAll
```
@SafeVarargs
public static <T,C extends java.util.Collection<? super T>> C addAll(C collection,
                                                                     T... elements)
```
Add all supplied elements to the supplied collection and returns the modified collection. Unlike Collections.addAll(Collection, Object[]) this method does not track whether collection was modified, so it could be marginally faster.

Type Parameters:

T - type of collection elements

C - type of the collection

Parameters:

collection - collection to add elements to

elements - elements to add

Returns:

the collection passed as first argument

addAllNotNull

@SafeVarargs
public static <T,C extends java.util.Collection<T>> C addAllNotNull(C collection,
                                                                    T... elements)

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

removeAll

@SafeVarargs
public static <T> boolean removeAll(java.util.Collection<T> collection,
                                    T... elements)

retainAll

public static <T> boolean retainAll(java.util.Collection<T> collection,
                                    Condition<? super T> condition)

findInstance

public static <T,U extends T> U findInstance(java.lang.Iterable<? extends T> iterable,
                                             java.lang.Class<? extends U> aClass)

findInstance

public static <T,U extends T> U findInstance(java.util.Iterator<? extends T> iterator,
                                             java.lang.Class<? extends U> aClass)

findInstance

public static <T,U extends T> U findInstance(T [] array,
                                             java.lang.Class<? extends U> aClass)

concat

public static <T,V> java.util.List<T> concat(V [] array,
                                             Function<? super V,? extends java.util.Collection<? extends T>> fun)

concat

public static <T> java.util.List<T> concat(java.lang.Iterable<? extends java.util.Collection<? extends T>> list)

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

append

@SafeVarargs
public static <T> java.util.List<T> append(java.util.List<? extends T> list,
                                           T... values)

prepend

@SafeVarargs
public static <T> java.util.List<T> prepend(java.util.List<? extends T> list,
                                            T... values)

prepend values in front of the list

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

concat

public static <T> java.util.List<T> concat(java.util.List<? extends T> list1,
                                           java.util.List<? extends T> list2)

Returns:: read-only list consisting of the two lists added together

concat

public static <T> java.lang.Iterable<T> concat(java.lang.Iterable<? extends T> it1,
                                               java.lang.Iterable<? extends T> it2)

concat

@SafeVarargs
public static <T> java.lang.Iterable<T> concat(java.lang.Iterable<? extends T>... iterables)

concatIterators

@SafeVarargs
public static <T> java.util.Iterator<T> concatIterators(java.util.Iterator<? extends T>... iterators)

concatIterators

public static <T> java.util.Iterator<T> concatIterators(java.util.Collection<? extends java.util.Iterator<? extends T>> iterators)

concat

@SafeVarargs
public static <T> java.lang.Iterable<T> concat(T[]... iterables)

concat

@SafeVarargs
public static <T> java.util.List<T> concat(java.util.List<? extends T>... lists)

Returns:: read-only list consisting of the lists added together

concat

public static <T> java.util.List<T> concat(java.util.List<java.util.List<? extends T>> lists)

Returns:: read-only list consisting of the lists added together

concat

public static <T,V> java.util.List<V> concat(java.lang.Iterable<? extends T> list,
                                             Function<? super T,? extends java.util.Collection<? extends V>> listGenerator)

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

intersects

public static <T> boolean intersects(java.util.Collection<? extends T> collection1,
                                     java.util.Collection<? extends T> collection2)

intersection

public static <T> java.util.Collection<T> intersection(java.util.Collection<? extends T> collection1,
                                                       java.util.Collection<? extends T> collection2)

Returns:: read-only collection consisting of elements from both collections

intersection

public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> intersection(java.util.EnumSet<E> collection1,
                                                                              java.util.EnumSet<E> collection2)

getFirstItem

public static <T> T getFirstItem(java.util.Collection<? extends T> items)

getFirstItem

public static <T> T getFirstItem(java.util.List<? extends T> items)

getFirstItem

public static <T> T getFirstItem(java.util.Collection<? extends T> items,
                                 T defaultResult)

getOnlyItem
```
public static <T> T getOnlyItem(java.util.Collection<? extends T> items)
```
Returns the only item from the collection or null if collection is empty or contains more than one item

Type Parameters:

T - type of collection element

Parameters:

items - collection to get the item from

Returns:

the only collection element or null

getOnlyItem

public static <T> T getOnlyItem(java.util.Collection<? extends T> items,
                                T defaultResult)

getFirstItems
```
public static <T> java.util.List<T> getFirstItems(java.util.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:

list with no more than maxItems first elements

iterateAndGetLastItem

public static <T> T iterateAndGetLastItem(java.lang.Iterable<? extends T> items)

mapIterator

public static <T,U> java.util.Iterator<U> mapIterator(java.util.Iterator<? extends T> iterator,
                                                      Function<? super T,? extends U> mapper)

filterIterator

public static <T> java.util.Iterator<T> filterIterator(java.util.Iterator<? extends T> iterator,
                                                       Condition<? super T> filter)

Returns:: iterator with elements from the original which are valid according to predicate.

getLastItem

public static <T> T getLastItem(java.util.List<? extends T> list,
                                T def)

getLastItem

public static <T> T getLastItem(java.util.List<? extends T> list)

subtract

public static <T> java.util.Collection<T> subtract(java.util.Collection<? extends T> from,
                                                   java.util.Collection<? extends T> what)

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

toArray

public static <T> T [] toArray(java.util.Collection<T> c,
                               ArrayFactory<? extends T> factory)

toArray

public static <T> T [] toArray(java.util.Collection<? extends T> c1,
                               java.util.Collection<? extends T> c2,
                               ArrayFactory<? extends T> factory)

mergeCollectionsToArray

public static <T> T [] mergeCollectionsToArray(java.util.Collection<? extends T> c1,
                                               java.util.Collection<? extends T> c2,
                                               ArrayFactory<? extends T> factory)

sort

public static <T extends java.lang.Comparable<? super T>> void sort(java.util.List<T> list)

sort

public static <T> void sort(java.util.List<T> list,
                            java.util.Comparator<? super T> comparator)

sort

public static <T extends java.lang.Comparable<? super T>> void sort(T [] a)

sorted

public static <T> java.util.List<T> sorted(java.util.Collection<? extends T> list,
                                           java.util.Comparator<? super T> comparator)

sorted

public static <T> java.util.List<T> sorted(java.lang.Iterable<? extends T> list,
                                           java.util.Comparator<? super T> comparator)

sorted

public static <T extends java.lang.Comparable<? super T>> java.util.List<T> sorted(java.util.Collection<? extends T> list)

sort

public static <T> void sort(T [] a,
                            java.util.Comparator<? super T> comparator)

map

public static <T,V> java.util.List<V> map(java.lang.Iterable<? extends T> iterable,
                                          Function<? super T,? extends V> mapping)

Parameters:: iterable - an input iterable to process; mapping - a side-effect free function which transforms iterable elements
Returns:: read-only list consisting of the elements from the iterable converted by mapping

map
```
public static <T,V> java.util.List<V> map(java.util.Collection<? extends T> collection,
                                          Function<? super T,? extends V> mapping)
```
Parameters:

collection - an input collection to process

mapping - a side-effect free function which transforms iterable elements

Returns:

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

mapNotNull
```
public static <T,V> java.util.List<V> mapNotNull(T [] array,
                                                 Function<? super T,? extends V> mapping)
```
Parameters:

array - an input array to process

mapping - a side-effect free function which transforms array elements

Returns:

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

mapNotNull
```
public static <T,V> V [] mapNotNull(T [] array,
                                    Function<? super T,? extends V> mapping,
                                    V [] emptyArray)
```
Parameters:

array - an input array to process

mapping - a side-effect free function which transforms array elements

emptyArray - an empty array of desired result type (may be returned if the result is also empty)

Returns:

array consisting of the elements from the input array converted by mapping with nulls filtered out

mapNotNull
```
public static <T,V> java.util.List<V> mapNotNull(java.lang.Iterable<? extends T> iterable,
                                                 Function<? super T,? extends V> mapping)
```
Parameters:

iterable - an input iterable to process

mapping - a side-effect free function which transforms iterable elements

Returns:

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

mapNotNull
```
public static <T,V> java.util.List<V> mapNotNull(java.util.Collection<? extends T> collection,
                                                 Function<? super T,? extends V> mapping)
```
Parameters:

collection - an input collection to process

mapping - a side-effect free function which transforms collection elements

Returns:

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

packNullables
```
@SafeVarargs
public static <T> java.util.List<T> packNullables(T... elements)
```
Returns:

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

map

public static <T,V> java.util.List<V> map(T [] array,
                                          Function<? super T,? extends V> mapping)

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

map

public static <T,V> V [] map(T [] arr,
                             Function<? super T,? extends V> mapping,
                             V [] emptyArray)

set

@SafeVarargs
public static <T> java.util.Set<T> set(T... items)

putIfAbsent

public static <K,V> void putIfAbsent(K key,
                                     V value,
                                     java.util.Map<? super K,? super V> result)

putIfNotNull

public static <K,V> void putIfNotNull(K key,
                                      V value,
                                      java.util.Map<? super K,? super V> result)

putIfNotNull

public static <K,V> void putIfNotNull(K key,
                                      java.util.Collection<? extends V> value,
                                      MultiMap<? super K,? super V> result)

putIfNotNull

public static <K,V> void putIfNotNull(K key,
                                      V value,
                                      MultiMap<? super K,? super V> result)

add

public static <T> void add(T element,
                           java.util.Collection<? super T> result,
                           Disposable parentDisposable)

createMaybeSingletonList

public static <T> java.util.List<T> createMaybeSingletonList(T element)

createMaybeSingletonSet

public static <T> java.util.Set<T> createMaybeSingletonSet(T element)

getOrCreate

public static <T,V> V getOrCreate(java.util.Map<T,V> result,
                                  T key,
                                  V defaultValue)

getOrCreate

public static <T,V> V getOrCreate(java.util.Map<T,V> result,
                                  T key,
                                  Factory<? extends V> factory)

getOrElse

public static <T,V> V getOrElse(java.util.Map<? extends T,? extends V> map,
                                T key,
                                V defValue)

and

public static <T> boolean and(T [] iterable,
                              Condition<? super T> condition)

and

public static <T> boolean and(java.lang.Iterable<? extends T> iterable,
                              Condition<? super T> condition)

exists

public static <T> boolean exists(T [] array,
                                 Condition<? super T> condition)

exists

public static <T> boolean exists(java.lang.Iterable<? extends T> iterable,
                                 Condition<? super T> condition)

or

public static <T> boolean or(T [] iterable,
                             Condition<? super T> condition)

or

public static <T> boolean or(java.lang.Iterable<? extends T> iterable,
                             Condition<? super T> condition)

count

public static <T> int count(java.lang.Iterable<? extends T> iterable,
                            Condition<? super T> condition)

list

@SafeVarargs
@Deprecated
public static <T> java.util.List<T> list(T... items)

Deprecated. Use Arrays.asList(Object[])

quickSort

public static <T> void quickSort(java.util.List<? extends T> list,
                                 java.util.Comparator<? super T> comparator)

singleton

public static <T> java.util.Set<T> singleton(T o,
                                             <any> strategy)

Returns:: read-only set consisting of the only element o

flatten

public static <E> java.util.List<E> flatten(java.util.Collection<E> [] collections)

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

removeDuplicatesFromSorted
```
public static <T> java.util.List<T> removeDuplicatesFromSorted(java.util.List<T> list,
                                                               java.util.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

public static <E> java.util.List<E> flatten(java.lang.Iterable<? extends java.util.Collection<? extends E>> collections)

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

flattenIterables

public static <E> java.util.List<E> flattenIterables(java.lang.Iterable<? extends java.lang.Iterable<? extends E>> collections)

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

flatMap

public static <T,V> java.util.List<V> flatMap(java.lang.Iterable<? extends T> iterable,
                                              Function<? super T,? extends java.util.List<V>> mapping)

Returns:: read-only list consisting of the elements from all of the collections returned by the mapping function, or a read-only view of the list returned by the mapping function, if it only returned a single list that was not empty

convert

public static <K,V> V [] convert(K [] from,
                                 V [] to,
                                 Function<? super K,? extends V> fun)

containsIdentity

public static <T> boolean containsIdentity(java.lang.Iterable<? extends T> list,
                                           T element)

indexOfIdentity

public static <T> int indexOfIdentity(java.util.List<? extends T> list,
                                      T element)

equalsIdentity

public static <T> boolean equalsIdentity(java.util.List<? extends T> list1,
                                         java.util.List<? extends T> list2)

indexOf

public static <T> int indexOf(java.util.List<? extends T> list,
                              Condition<? super T> condition)

lastIndexOf

public static <T> int lastIndexOf(java.util.List<? extends T> list,
                                  Condition<? super T> condition)

findLastInstance

public static <T,U extends T> U findLastInstance(java.util.List<? extends T> list,
                                                 java.lang.Class<? extends U> clazz)

lastIndexOfInstance

public static <T,U extends T> int lastIndexOfInstance(java.util.List<? extends T> list,
                                                      java.lang.Class<U> clazz)

reverseMap

public static <A,B> java.util.Map<B,A> reverseMap(java.util.Map<? extends A,? extends B> map)

trimToSize

public static <T> java.util.List<T> trimToSize(java.util.List<T> list)

newStack

@Deprecated
public static <T> Stack<T> newStack()

Deprecated. Use Stack()

emptyList

public static <T> java.util.List<T> emptyList()

createEmptyCOWList

public static <T> java.util.concurrent.CopyOnWriteArrayList<T> createEmptyCOWList()

createLockFreeCopyOnWriteList
```
public static <T> java.util.List<T> createLockFreeCopyOnWriteList()
```
Creates List which is thread-safe to modify and iterate. It differs from the java.util.concurrent.CopyOnWriteArrayList in the following: - faster modification in the uncontended case - less memory - slower modification in highly contented case (which is the kind of situation you shouldn't use COWAL anyway) N.B. Avoid using list.toArray(new T[list.size()]) on this list because it is inherently racey and therefore can return array with null elements at the end.

createLockFreeCopyOnWriteList

public static <T> java.util.List<T> createLockFreeCopyOnWriteList(java.util.Collection<? extends T> c)

createConcurrentIntObjectMap

public static <V> ConcurrentIntObjectMap<V> createConcurrentIntObjectMap()

createConcurrentIntObjectMap

public static <V> ConcurrentIntObjectMap<V> createConcurrentIntObjectMap(int initialCapacity,
                                                                         float loadFactor,
                                                                         int concurrencyLevel)

createConcurrentIntObjectSoftValueMap

public static <V> ConcurrentIntObjectMap<V> createConcurrentIntObjectSoftValueMap()

createConcurrentLongObjectMap

public static <V> ConcurrentLongObjectMap<V> createConcurrentLongObjectMap()

createConcurrentLongObjectMap

public static <V> ConcurrentLongObjectMap<V> createConcurrentLongObjectMap(int initialCapacity)

createConcurrentWeakValueMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentWeakValueMap()

createConcurrentIntObjectWeakValueMap

public static <V> ConcurrentIntObjectMap<V> createConcurrentIntObjectWeakValueMap()

createConcurrentWeakKeySoftValueMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentWeakKeySoftValueMap(int initialCapacity,
                                                                                                float loadFactor,
                                                                                                int concurrencyLevel,
                                                                                                <any> hashingStrategy)

createConcurrentSoftKeySoftValueMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentSoftKeySoftValueMap()

createConcurrentSoftKeySoftValueMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentSoftKeySoftValueMap(int initialCapacity,
                                                                                                float loadFactor,
                                                                                                int concurrencyLevel,
                                                                                                <any> hashingStrategy)

createConcurrentWeakKeySoftValueMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentWeakKeySoftValueMap()

createConcurrentWeakKeyWeakValueMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentWeakKeyWeakValueMap()

createConcurrentWeakKeyWeakValueMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentWeakKeyWeakValueMap(<any> strategy)

createConcurrentSoftValueMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentSoftValueMap()

createConcurrentSoftMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentSoftMap()

createConcurrentWeakMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentWeakMap()

createConcurrentSoftMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentSoftMap(int initialCapacity,
                                                                                    float loadFactor,
                                                                                    int concurrencyLevel,
                                                                                    <any> hashingStrategy)

createConcurrentWeakMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentWeakMap(int initialCapacity,
                                                                                    float loadFactor,
                                                                                    int concurrencyLevel,
                                                                                    <any> hashingStrategy)

createConcurrentWeakMap

public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createConcurrentWeakMap(<any> hashingStrategy)

createConcurrentList

public static <T> ConcurrentList<T> createConcurrentList()

See Also:: createLockFreeCopyOnWriteList()

createConcurrentList

public static <T> ConcurrentList<T> createConcurrentList(java.util.Collection<? extends T> collection)

addIfNotNull

@Deprecated
public static <T> void addIfNotNull(T element,
                                    java.util.Collection<? super T> result)

Deprecated. use addIfNotNull(Collection, Object) instead

addIfNotNull

public static <T> void addIfNotNull(java.util.Collection<? super T> result,
                                    T element)

map2List

public static <T,V> java.util.List<V> map2List(T [] array,
                                               Function<? super T,? extends V> mapper)

map2List

public static <T,V> java.util.List<V> map2List(java.util.Collection<? extends T> collection,
                                               Function<? super T,? extends V> mapper)

map2List

public static <K,V> java.util.List<Pair<K,V>> map2List(java.util.Map<? extends K,? extends V> map)

map2Set

public static <T,V> java.util.Set<V> map2Set(T [] array,
                                             Function<? super T,? extends V> mapper)

map2Set

public static <T,V> java.util.Set<V> map2Set(java.util.Collection<? extends T> collection,
                                             Function<? super T,? extends V> mapper)

map2LinkedSet

public static <T,V> java.util.Set<V> map2LinkedSet(java.util.Collection<? extends T> collection,
                                                   Function<? super T,? extends V> mapper)

map2SetNotNull

public static <T,V> java.util.Set<V> map2SetNotNull(java.util.Collection<? extends T> collection,
                                                    Function<? super T,? extends V> mapper)

toArray

@Deprecated
public static <T> T [] toArray(java.util.List<T> collection,
                               T [] array)

Deprecated. use List.toArray(Object[]) instead

toArray

@Deprecated
public static <T> T [] toArray(java.util.Collection<? extends T> c,
                               T [] sample)

Deprecated. use Collection.toArray(Object[]) instead

copyAndClear

public static <T> T [] copyAndClear(java.util.Collection<? extends T> collection,
                                    ArrayFactory<? extends T> factory,
                                    boolean clear)

copyList

public static <T> java.util.List<T> copyList(java.util.List<? extends T> list)

toCollection

public static <T> java.util.Collection<T> toCollection(java.lang.Iterable<? extends T> iterable)

toList

public static <T> java.util.List<T> toList(java.util.Enumeration<? extends T> enumeration)

isEmpty

public static <T> boolean isEmpty(java.util.Collection<? extends T> collection)

isEmpty

public static boolean isEmpty(java.util.Map<?,?> map)

notNullize

public static <T> java.util.List<T> notNullize(java.util.List<T> list)

notNullize

public static <T> java.util.Set<T> notNullize(java.util.Set<T> set)

notNullize

public static <K,V> java.util.Map<K,V> notNullize(java.util.Map<K,V> map)

startsWith

public static <T> boolean startsWith(java.util.List<? extends T> list,
                                     java.util.List<? extends T> prefix)

nullize

public static <T,C extends java.util.Collection<? extends T>> C nullize(C collection)

compareLexicographically

public static <T extends java.lang.Comparable<? super T>> int compareLexicographically(java.util.List<? extends T> o1,
                                                                                       java.util.List<? extends T> o2)

compareLexicographically

public static <T> int compareLexicographically(java.util.List<? extends T> o1,
                                               java.util.List<? extends T> o2,
                                               java.util.Comparator<? super T> comparator)

toString
```
public static java.lang.String toString(java.util.Map<?,?> map)
```
Returns a String representation of the given map, by listing all key-value pairs contained in the map.

createWeakKeySoftValueMap

public static <K,V> java.util.Map<K,V> createWeakKeySoftValueMap()

createWeakKeyWeakValueMap

public static <K,V> java.util.Map<K,V> createWeakKeyWeakValueMap()

createSoftKeySoftValueMap

public static <K,V> java.util.Map<K,V> createSoftKeySoftValueMap()

createSoftValueMap
```
public static <K,V> java.util.Map<K,V> createSoftValueMap()
```
Hard keys soft values hash map. Null keys are NOT allowed Null values are allowed

createWeakValueMap
```
public static <K,V> java.util.Map<K,V> createWeakValueMap()
```
Hard keys weak values hash map. Null keys are NOT allowed Null values are allowed

createSoftMap
```
public static <K,V> java.util.Map<K,V> createSoftMap()
```
Soft keys hard values hash map. Null keys are NOT allowed Null values are allowed

createSoftMap

public static <K,V> java.util.Map<K,V> createSoftMap(<any> strategy)

createWeakMap
```
public static <K,V> java.util.Map<K,V> createWeakMap()
```
Weak keys hard values hash map. Null keys are NOT allowed Null values are allowed

createWeakMap

public static <K,V> java.util.Map<K,V> createWeakMap(int initialCapacity)

createWeakMap

public static <K,V> java.util.Map<K,V> createWeakMap(int initialCapacity,
                                                     float loadFactor,
                                                     <any> strategy)

createWeakSet

public static <T> java.util.Set<T> createWeakSet()

createIntKeyWeakValueMap

public static <T> IntObjectMap<T> createIntKeyWeakValueMap()

createWeakKeyIntValueMap

public static <T> ObjectIntMap<T> createWeakKeyIntValueMap()

freeze
```
public static <T> java.util.List<T> freeze(java.util.List<? extends T> list)
```
Create an immutable copy of the list. Modifications of the list have no effect on the returned copy.

Class ContainerUtil

Nested Class Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

ContainerUtil

Method Detail

ar

newHashMap

newHashMap

newHashMap

newHashMap

newTreeMap

newTreeMap

newLinkedHashMap

newLinkedHashMap

newLinkedHashMap

newTroveMap

newTroveMap

newEnumMap

canonicalStrategy

identityStrategy

newIdentityHashMap

newLinkedList

newLinkedList

newArrayList

newArrayList

newArrayList

newArrayList

newArrayListWithCapacity

newArrayList

newUnmodifiableList

unmodifiableOrEmptyCollection

unmodifiableOrEmptyList

unmodifiableOrEmptySet

unmodifiableOrEmptyMap

newSmartList

newSmartList

newSmartList

newHashSet

newHashSet

newHashSet

newHashSet

newHashSet

newHashSet

newHashOrEmptySet

newLinkedHashSet

newLinkedHashSet

newLinkedHashSet

newLinkedHashSet

newTroveSet

newTroveSet

newTroveSet

newTroveSet

newTroveSet

newTroveSet

newIdentityTroveSet

newIdentityTroveSet

newIdentityTroveSet

newIdentityTroveMap

newTreeSet

newTreeSet

newConcurrentSet

newConcurrentMap

newConcurrentMap

newConcurrentMap

reverse

union

union

union

immutableSet

immutableList

immutableSingletonList

immutableList

immutableMapBuilder

groupBy

getOrElse

mapIterator