Package org.eclipse.collections.impl.factory

Class Iterables

java.lang.Object

org.eclipse.collections.impl.factory.Iterables

public final class Iterables
extends Object

Method Summary

Modifier and Type	Method	Description
static <T> ImmutableBag<T>	iBag()
static <T> ImmutableBag<T>	iBag(T one)
static <T> ImmutableBag<T>	iBag(T... elements)
static <T> ImmutableList<T>	iList()
static <T> ImmutableList<T>	iList(T one)
static <T> ImmutableList<T>	iList(T... elements)
static <T> ImmutableList<T>	iList(T one, T two)
static <T> ImmutableList<T>	iList(T one, T two, T three)
static <T> ImmutableList<T>	iList(T one, T two, T three, T four)
static <T> ImmutableList<T>	iList(T one, T two, T three, T four, T five)
static <T> ImmutableList<T>	iList(T one, T two, T three, T four, T five, T six)
static <T> ImmutableList<T>	iList(T one, T two, T three, T four, T five, T six, T seven)
static <T> ImmutableList<T>	iList(T one, T two, T three, T four, T five, T six, T seven, T eight)
static <T> ImmutableList<T>	iList(T one, T two, T three, T four, T five, T six, T seven, T eight, T nine)
static <T> ImmutableList<T>	iList(T one, T two, T three, T four, T five, T six, T seven, T eight, T nine, T ten)
static <K,V> ImmutableMap<K,V>	iMap()
static <K,V> ImmutableMap<K,V>	iMap(K key, V value)
static <K,V> ImmutableMap<K,V>	iMap(K key1, V value1, K key2, V value2)
static <K,V> ImmutableMap<K,V>	iMap(K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> ImmutableMap<K,V>	iMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <T> ImmutableSet<T>	iSet()
static <T> ImmutableSet<T>	iSet(T one)
static <T> ImmutableSet<T>	iSet(T... elements)
static <T> ImmutableSet<T>	iSet(T one, T two)
static <T> ImmutableSet<T>	iSet(T one, T two, T three)
static <T> ImmutableSet<T>	iSet(T one, T two, T three, T four)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap()
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(Comparator<? super K> comparator)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(Comparator<? super K> comparator, K key, V value)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(Comparator<? super K> comparator, K key1, V value1, K key2, V value2)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(Comparator<? super K> comparator, K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(Comparator<? super K> comparator, K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(K key, V value)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(K key1, V value1, K key2, V value2)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> ImmutableSortedMap<K,V>	iSortedMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <T> ImmutableSortedSet<T>	iSortedSet()
static <T> ImmutableSortedSet<T>	iSortedSet(Comparator<? super T> comparator)
static <T> ImmutableSortedSet<T>	iSortedSet(Comparator<? super T> comparator, T... elements)
static <T> ImmutableSortedSet<T>	iSortedSet(T... elements)
static <T> MutableBag<T>	mBag()
static <T> MutableBag<T>	mBag(T... elements)
static <T> MutableList<T>	mList()
static <T> MutableList<T>	mList(T... elements)
static <K,V> MutableMap<K,V>	mMap()
static <K,V> MutableMap<K,V>	mMap(K key, V value)
static <K,V> MutableMap<K,V>	mMap(K key1, V value1, K key2, V value2)
static <K,V> MutableMap<K,V>	mMap(K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> MutableMap<K,V>	mMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <T> MutableSet<T>	mSet()
static <T> MutableSet<T>	mSet(T... elements)
static <K,V> MutableSortedMap<K,V>	mSortedMap()
static <K,V> MutableSortedMap<K,V>	mSortedMap(Comparator<? super K> comparator)
static <K,V> MutableSortedMap<K,V>	mSortedMap(Comparator<? super K> comparator, K key, V value)
static <K,V> MutableSortedMap<K,V>	mSortedMap(Comparator<? super K> comparator, K key1, V value1, K key2, V value2)
static <K,V> MutableSortedMap<K,V>	mSortedMap(Comparator<? super K> comparator, K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> MutableSortedMap<K,V>	mSortedMap(Comparator<? super K> comparator, K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <K,V> MutableSortedMap<K,V>	mSortedMap(K key, V value)
static <K,V> MutableSortedMap<K,V>	mSortedMap(K key1, V value1, K key2, V value2)
static <K,V> MutableSortedMap<K,V>	mSortedMap(K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> MutableSortedMap<K,V>	mSortedMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <T> MutableSortedSet<T>	mSortedSet()
static <T> MutableSortedSet<T>	mSortedSet(Comparator<? super T> comparator)
static <T> MutableSortedSet<T>	mSortedSet(Comparator<? super T> comparator, T... elements)
static <T> MutableSortedSet<T>	mSortedSet(T... elements)

Methods inherited from class java.lang.Object

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

Method Detail

mList

public static <T> MutableList<T> mList()

mList

public static <T> MutableList<T> mList(T... elements)

mSet

public static <T> MutableSet<T> mSet()

mSet

public static <T> MutableSet<T> mSet(T... elements)

mBag

public static <T> MutableBag<T> mBag()

mBag

public static <T> MutableBag<T> mBag(T... elements)

mMap

public static <K,V> MutableMap<K,V> mMap()

mMap

public static <K,V> MutableMap<K,V> mMap(K key,
                                         V value)

mMap

public static <K,V> MutableMap<K,V> mMap(K key1,
                                         V value1,
                                         K key2,
                                         V value2)

mMap

public static <K,V> MutableMap<K,V> mMap(K key1,
                                         V value1,
                                         K key2,
                                         V value2,
                                         K key3,
                                         V value3)

mMap

public static <K,V> MutableMap<K,V> mMap(K key1,
                                         V value1,
                                         K key2,
                                         V value2,
                                         K key3,
                                         V value3,
                                         K key4,
                                         V value4)

mSortedSet

public static <T> MutableSortedSet<T> mSortedSet()

mSortedSet

public static <T> MutableSortedSet<T> mSortedSet(T... elements)

mSortedSet

public static <T> MutableSortedSet<T> mSortedSet(Comparator<? super T> comparator)

mSortedSet

public static <T> MutableSortedSet<T> mSortedSet(Comparator<? super T> comparator,
                                                 T... elements)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap()

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(K key,
                                                     V value)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2,
                                                     K key3,
                                                     V value3)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2,
                                                     K key3,
                                                     V value3,
                                                     K key4,
                                                     V value4)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(Comparator<? super K> comparator)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(Comparator<? super K> comparator,
                                                     K key,
                                                     V value)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(Comparator<? super K> comparator,
                                                     K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(Comparator<? super K> comparator,
                                                     K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2,
                                                     K key3,
                                                     V value3)

mSortedMap

public static <K,V> MutableSortedMap<K,V> mSortedMap(Comparator<? super K> comparator,
                                                     K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2,
                                                     K key3,
                                                     V value3,
                                                     K key4,
                                                     V value4)

iList

public static <T> ImmutableList<T> iList()

iList

public static <T> ImmutableList<T> iList(T one)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two,
                                         T three)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two,
                                         T three,
                                         T four)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two,
                                         T three,
                                         T four,
                                         T five)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two,
                                         T three,
                                         T four,
                                         T five,
                                         T six)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two,
                                         T three,
                                         T four,
                                         T five,
                                         T six,
                                         T seven)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two,
                                         T three,
                                         T four,
                                         T five,
                                         T six,
                                         T seven,
                                         T eight)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two,
                                         T three,
                                         T four,
                                         T five,
                                         T six,
                                         T seven,
                                         T eight,
                                         T nine)

iList

public static <T> ImmutableList<T> iList(T one,
                                         T two,
                                         T three,
                                         T four,
                                         T five,
                                         T six,
                                         T seven,
                                         T eight,
                                         T nine,
                                         T ten)

iList

public static <T> ImmutableList<T> iList(T... elements)

iSet

public static <T> ImmutableSet<T> iSet()

iSet

public static <T> ImmutableSet<T> iSet(T one)

iSet

public static <T> ImmutableSet<T> iSet(T one,
                                       T two)

iSet

public static <T> ImmutableSet<T> iSet(T one,
                                       T two,
                                       T three)

iSet

public static <T> ImmutableSet<T> iSet(T one,
                                       T two,
                                       T three,
                                       T four)

iSet

public static <T> ImmutableSet<T> iSet(T... elements)

iBag

public static <T> ImmutableBag<T> iBag()

iBag

public static <T> ImmutableBag<T> iBag(T one)

iBag

public static <T> ImmutableBag<T> iBag(T... elements)

iMap

public static <K,V> ImmutableMap<K,V> iMap()

iMap

public static <K,V> ImmutableMap<K,V> iMap(K key,
                                           V value)

iMap

public static <K,V> ImmutableMap<K,V> iMap(K key1,
                                           V value1,
                                           K key2,
                                           V value2)

iMap

public static <K,V> ImmutableMap<K,V> iMap(K key1,
                                           V value1,
                                           K key2,
                                           V value2,
                                           K key3,
                                           V value3)

iMap

public static <K,V> ImmutableMap<K,V> iMap(K key1,
                                           V value1,
                                           K key2,
                                           V value2,
                                           K key3,
                                           V value3,
                                           K key4,
                                           V value4)

iSortedSet

public static <T> ImmutableSortedSet<T> iSortedSet()

iSortedSet

public static <T> ImmutableSortedSet<T> iSortedSet(T... elements)

iSortedSet

public static <T> ImmutableSortedSet<T> iSortedSet(Comparator<? super T> comparator)

iSortedSet

public static <T> ImmutableSortedSet<T> iSortedSet(Comparator<? super T> comparator,
                                                   T... elements)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap()

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(K key,
                                                       V value)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(K key1,
                                                       V value1,
                                                       K key2,
                                                       V value2)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(K key1,
                                                       V value1,
                                                       K key2,
                                                       V value2,
                                                       K key3,
                                                       V value3)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(K key1,
                                                       V value1,
                                                       K key2,
                                                       V value2,
                                                       K key3,
                                                       V value3,
                                                       K key4,
                                                       V value4)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(Comparator<? super K> comparator)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(Comparator<? super K> comparator,
                                                       K key,
                                                       V value)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(Comparator<? super K> comparator,
                                                       K key1,
                                                       V value1,
                                                       K key2,
                                                       V value2)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(Comparator<? super K> comparator,
                                                       K key1,
                                                       V value1,
                                                       K key2,
                                                       V value2,
                                                       K key3,
                                                       V value3)

iSortedMap

public static <K,V> ImmutableSortedMap<K,V> iSortedMap(Comparator<? super K> comparator,
                                                       K key1,
                                                       V value1,
                                                       K key2,
                                                       V value2,
                                                       K key3,
                                                       V value3,
                                                       K key4,
                                                       V value4)