Package com.intellij.util.containers

Class ContainerUtil

java.lang.Object

com.intellij.util.containers.ContainerUtil

public class ContainerUtil
extends Object

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> void	addAll(Collection<T> collection, Enumeration<T> enumeration)
static <T> void	addAll(Collection<T> collection, Iterator<T> iterator)
static <T> void	addAll(Collection<T> collection, T... elements)
static <T> void	addIfNotNull(T element, Collection<T> result)
static <T> boolean	and(Iterable<T> iterable, Condition<T> condition)
static <T> boolean	and(T[] iterable, Condition<T> condition)
static <K,V> HashMap<K,V>	assignKeys(Iterator<V> iterator, Convertor<V,K> keyConvertor)
static <K,V> HashMap<K,V>	assignValues(Iterator<K> iterator, Convertor<K,V> valueConvertor)
static <K,V> Map<K,Set<V>>	classify(Iterator<V> iterator, Convertor<V,K> keyConvertor)
static <T> ArrayList<T>	collect(Iterator<?> iterator, FilteringIterator.InstanceOf<T> instanceOf)
static <T> ArrayList<T>	collect(Iterator<T> iterator)
static <T> HashSet<T>	collectSet(Iterator<T> iterator)
static <T> List<T>	concat(Iterable<? extends Collection<T>> list)
static <T> Iterable<T>	concat(Iterable<? extends T>... iterables)
static <T,V> List<T>	concat(Iterable<? extends V> list, Function<V,Collection<? extends T>> fun)
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> CopyOnWriteArrayList<T>	createEmptyCOWList()
static <T> List<T>	createMaybeSingletonList(T element)
static <T> List<T>	dropTail(List<T> items)
static <T> Iterable<T>	emptyIterable()
static <T> Iterator<T>	emptyIterator()
static <T> List<T>	emptyList()
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,V extends T> V	find(Iterator<V> iterator, Condition<T> condition)
static <T> T	find(T[] array, Condition<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	findInstance(Iterable<T> iterable, Class<U> aClass)
static <T,U extends T> U	findInstance(Iterator<T> iterator, Class<U> aClass)
static <T,U extends T> U	findInstance(T[] array, Class<U> aClass)
static <E> List<E>	flatten(Collection<? extends Collection<E>> collections)
static <T> T	getFirstItem(Collection<T> items, T def)
static <T,V> V	getOrCreate(Map<T,V> result, T key, Factory<V> factory)
static <T,V> V	getOrCreate(Map<T,V> result, T key, V defaultValue)
static <T> boolean	intersects(Collection<? extends T> collection1, Collection<? extends T> collection2)
static <T> Iterable<T>	iterate(Collection<? extends T> collection, Condition<? super T> condition)
static <T> Iterator<T>	iterate(Enumeration<T> enumeration)
static <T> Iterator<T>	iterate(T[] arrays)
static <T> Iterable<T>	iterate(T[] arrays, Condition<? super T> condition)
static <T> Iterable<T>	iterateBackward(List<? extends T> list)
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(T[] arr, 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<? extends 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<? extends V> aClass, Function<T,V> mapper)
static <T,V> List<V>	map2List(Collection<? extends T> collection, Function<T,V> mapper)
static <T,V> List<V>	map2List(T[] array, Function<T,V> mapper)
static <T,V> Set<V>	map2Set(Collection<? extends T> collection, Function<T,V> mapper)
static <T,V> Set<V>	map2Set(T[] collection, Function<T,V> mapper)
static <T,V> List<V>	mapNotNull(Iterable<? extends T> iterable, Function<T,V> mapping)
static <T,V> List<V>	mapNotNull(T[] array, Function<T,V> mapping)
static <T> List<T>	mergeSortedArrays(T[] list1, T[] list2, Comparator<? super T> comparator, boolean mergeEqualItems, Processor<? super T> filter)
static <T> List<T>	mergeSortedLists(List<T> list1, List<T> list2, Comparator<? super T> comparator, boolean mergeEqualItems)
static <T> boolean	or(Iterable<T> iterable, Condition<T> condition)
static <T> boolean	or(T[] iterable, Condition<T> condition)
static <T> List<T>	packNullables(T... elements)
static <T> boolean	process(Iterable<? extends T> iterable, Processor<T> processor)
static <T> boolean	process(T[] iterable, Processor<? super 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> void	removeDuplicates(Collection<T> collection)
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<T> comparator)
static <T extends Comparable<T>> void	sort(T[] a)
static <T> void	sort(T[] a, Comparator<T> comparator)
static <T> Collection<T>	subtract(Collection<T> from, Collection<T> what)
static <E> void	swapElements(List<E> list, int index1, int index2)
static <T> T[]	toArray(Collection<T> c, T[] sample)	This is a replacement for Collection.toArray(Object[]).
static <T> T[]	toArray(List<T> collection, T[] array)
static <T> List<T>	unfold(T t, NullableFunction<T,T> next)

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

mergeSortedLists

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

mergeSortedArrays

public static <T> List<T> mergeSortedArrays(T[] list1,
                                            T[] list2,
                                            Comparator<? super T> comparator,
                                            boolean mergeEqualItems,
                                            @Nullable
                                            Processor<? super T> filter)

addAll

public static <T> void addAll(Collection<T> collection,
                              Iterator<T> iterator)

collect

public static <T> ArrayList<T> collect(Iterator<T> iterator)

collectSet

public static <T> HashSet<T> collectSet(Iterator<T> iterator)

assignKeys

public static <K,V> HashMap<K,V> assignKeys(Iterator<V> iterator,
                                                        Convertor<V,K> keyConvertor)

classify

public static <K,V> Map<K,Set<V>> classify(Iterator<V> iterator,
                                                       Convertor<V,K> keyConvertor)

assignValues

public static <K,V> HashMap<K,V> assignValues(Iterator<K> iterator,
                                                          Convertor<K,V> valueConvertor)

emptyIterator

public static <T> Iterator<T> emptyIterator()

emptyIterable

public static <T> Iterable<T> emptyIterable()

find

@Nullable
public static <T> T find(T[] array,
                         Condition<T> condition)

process

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

process

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

find

@Nullable
public static <T,V extends T> V find(Iterable<V> iterable,
                                           Condition<T> condition)

find

@Nullable
public static <T> T find(Iterable<? extends T> iterable,
                         T equalTo)

find

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

map2List

public static <T,V> List<V> map2List(T[] array,
                                           Function<T,V> mapper)

map2List

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

map2Set

public static <T,V> Set<V> map2Set(T[] collection,
                                         Function<T,V> mapper)

map2Set

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

map2Array

public static <T> Object[] map2Array(T[] array,
                                     Function<T,Object> mapper)

map2Array

public static <T> Object[] map2Array(Collection<T> array,
                                     Function<T,Object> mapper)

map2Array

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

map2Array

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

map2Array

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

findAll

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

findAll

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

skipNulls

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

findAll

public static <T,V> List<V> findAll(T[] collection,
                                          Class<V> instanceOf)

findAllAsArray

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

findAllAsArray

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

findAllAsArray

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

findAll

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

removeDuplicates

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

iterate

public static <T> Iterator<T> iterate(T[] arrays)

iterate

public static <T> Iterator<T> iterate(Enumeration<T> enumeration)

iterate

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

iterate

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

iterateBackward

public static <T> Iterable<T> iterateBackward(List<? extends T> list)

swapElements

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

collect

public static <T> ArrayList<T> collect(@NotNull
                                       Iterator<?> iterator,
                                       @NotNull
                                       FilteringIterator.InstanceOf<T> instanceOf)

addAll

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

addAll

public static <T> void addAll(@NotNull
                              Collection<T> collection,
                              @NotNull
                              T... elements)

findInstance

public static <T,U extends T> U findInstance(Iterable<T> iterable,
                                                   Class<U> aClass)

findInstance

public static <T,U extends T> U findInstance(Iterator<T> iterator,
                                                   Class<U> aClass)

findInstance

@Nullable
public static <T,U extends T> U findInstance(T[] array,
                                                   Class<U> aClass)

concat

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

concat

public static <T> List<T> concat(Iterable<? extends Collection<T>> list)

concat

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

concat

public static <T> Iterable<T> concat(@NotNull
                                     Iterable<? extends T>... iterables)

concat

public static <T> List<T> concat(@NotNull
                                 List<List<? extends T>> lists)

concat

public static <T> List<T> concat(@NotNull
                                 List<? extends T>... lists)

concat

public static <T,V> List<T> concat(Iterable<? extends V> list,
                                         Function<V,Collection<? extends T>> fun)

intersects

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

getFirstItem

public static <T> T getFirstItem(Collection<T> items,
                                 T def)

subtract

public static <T> Collection<T> subtract(Collection<T> from,
                                         Collection<T> what)

toArray

public static <T> T[] toArray(List<T> collection,
                              T[] array)

toArray

public static <T> T[] toArray(Collection<T> c,
                              T[] sample)

This is a replacement for Collection.toArray(Object[]). For small collections it is faster to stay at java level and refrain from calling JNI System.arraycopy(Object, int, Object, int, int)

sort

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

sort

public static <T> void sort(List<T> list,
                            Comparator<T> comparator)

sort

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

sort

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

map

public static <T,V> List<V> map(Iterable<? extends T> iterable,
                                      Function<T,V> mapping)

mapNotNull

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

mapNotNull

public static <T,V> List<V> mapNotNull(Iterable<? extends T> iterable,
                                             Function<T,V> mapping)

packNullables

public static <T> List<T> packNullables(T... elements)

map

public static <T,V> List<V> map(T[] arr,
                                      Function<T,V> mapping)

map

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

addIfNotNull

public static <T> void addIfNotNull(T element,
                                    Collection<T> result)

putIfNotNull

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

add

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

createMaybeSingletonList

public static <T> List<T> createMaybeSingletonList(@Nullable
                                                   T element)

getOrCreate

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

getOrCreate

public static <T,V> V getOrCreate(Map<T,V> result,
                                        T key,
                                        Factory<V> factory)

and

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

and

public static <T> boolean and(Iterable<T> iterable,
                              Condition<T> condition)

or

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

or

public static <T> boolean or(Iterable<T> iterable,
                             Condition<T> condition)

unfold

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

dropTail

public static <T> List<T> dropTail(List<T> items)

list

public static <T> List<T> list(T... items)

quickSort

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

createEmptyCOWList

public static <T> CopyOnWriteArrayList<T> createEmptyCOWList()

emptyList

public static <T> List<T> emptyList()

flatten

public static <E> List<E> flatten(Collection<? extends Collection<E>> collections)