Class OrderedMapAdapter<K,​V>

    • Field Detail

      • delegate

        private final java.util.Map<K,​V> delegate
    • Constructor Detail

      • OrderedMapAdapter

        protected OrderedMapAdapter​(java.util.Map<K,​V> delegate)
    • Method Detail

      • adapt

        public static <K,​V> MutableOrderedMap<K,​V> adapt​(java.util.Map<K,​V> map)
      • equals

        public boolean equals​(java.lang.Object o)
        Description copied from interface: MapIterable
        Follows the same general contract as Map.equals(Object).
        Specified by:
        equals in interface java.util.Map<K,​V>
        Specified by:
        equals in interface MapIterable<K,​V>
        Overrides:
        equals in class java.lang.Object
      • hashCode

        public int hashCode()
        Description copied from interface: MapIterable
        Follows the same general contract as Map.hashCode().
        Specified by:
        hashCode in interface java.util.Map<K,​V>
        Specified by:
        hashCode in interface MapIterable<K,​V>
        Overrides:
        hashCode in class java.lang.Object
      • forEachKeyValue

        public void forEachKeyValue​(Procedure2<? super K,​? super V> procedure)
        Description copied from interface: MapIterable
        Calls the procedure with each key-value pair of the map.
             final Collection<String> collection = new ArrayList<String>();
             MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three");
             map.forEachKeyValue((Integer key, String value) -> collection.add(String.valueOf(key) + value));
             Verify.assertContainsAll(collection, "1One", "2Two", "3Three");
         
        Specified by:
        forEachKeyValue in interface MapIterable<K,​V>
      • containsKey

        public boolean containsKey​(java.lang.Object key)
        Specified by:
        containsKey in interface java.util.Map<K,​V>
        Specified by:
        containsKey in interface MapIterable<K,​V>
        See Also:
        Map.containsKey(Object)
      • containsValue

        public boolean containsValue​(java.lang.Object value)
        Specified by:
        containsValue in interface java.util.Map<K,​V>
        Specified by:
        containsValue in interface MapIterable<K,​V>
        See Also:
        Map.containsValue(Object)
      • size

        public int size()
        Description copied from interface: RichIterable
        Returns the number of items in this iterable.
        Specified by:
        size in interface java.util.Map<K,​V>
        Specified by:
        size in interface RichIterable<K>
      • iterator

        public java.util.Iterator<V> iterator()
        Specified by:
        iterator in interface java.lang.Iterable<K>
      • remove

        public V remove​(java.lang.Object key)
        Specified by:
        remove in interface java.util.Map<K,​V>
      • putAll

        public void putAll​(java.util.Map<? extends K,​? extends V> map)
        Specified by:
        putAll in interface java.util.Map<K,​V>
      • values

        public MutableCollection<V> values()
        Specified by:
        values in interface java.util.Map<K,​V>
      • entrySet

        public MutableSet<java.util.Map.Entry<K,​V>> entrySet()
        Specified by:
        entrySet in interface java.util.Map<K,​V>
      • keySet

        public MutableSet<K> keySet()
        Specified by:
        keySet in interface java.util.Map<K,​V>
      • clear

        public void clear()
        Specified by:
        clear in interface java.util.Map<K,​V>
      • get

        public V get​(java.lang.Object key)
        Specified by:
        get in interface java.util.Map<K,​V>
        Specified by:
        get in interface MapIterable<K,​V>
        See Also:
        Map.get(Object)
      • put

        public V put​(K key,
                     V value)
        Specified by:
        put in interface java.util.Map<K,​V>
      • removeKey

        public V removeKey​(K key)
        Description copied from interface: MutableMapIterable
        Remove an entry from the map at the specified key.
        Specified by:
        removeKey in interface MutableMapIterable<K,​V>
        Returns:
        The value removed from entry at key, or null if not found.
        See Also:
        Map.remove(Object)
      • toString

        public java.lang.String toString()
        Description copied from class: AbstractRichIterable
        Returns a string with the elements of the iterable separated by commas with spaces and enclosed in square brackets.
         Assert.assertEquals("[]", Lists.mutable.empty().toString());
         Assert.assertEquals("[1]", Lists.mutable.with(1).toString());
         Assert.assertEquals("[1, 2, 3]", Lists.mutable.with(1, 2, 3).toString());
         
        Specified by:
        toString in interface MapIterable<K,​V>
        Specified by:
        toString in interface RichIterable<K>
        Overrides:
        toString in class AbstractRichIterable<V>
        Returns:
        a string representation of this collection.
        See Also:
        AbstractCollection.toString()
      • clone

        public MutableOrderedMap<K,​V> clone()
        Overrides:
        clone in class java.lang.Object
      • withKeyValue

        public MutableOrderedMap<K,​V> withKeyValue​(K key,
                                                         V value)
        Description copied from interface: MutableMapIterable
        This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing elements. In order to support fixed size maps, a new instance of a map would have to be returned including the keys and values of the original plus the additional key and value. In the case of mutable maps, the original map is modified and then returned. In order to use this method properly with mutable and fixed size maps the following approach must be taken:
         map = map.withKeyValue("new key", "new value");
         
        In the case of FixedSizeMap, a new instance will be returned by withKeyValue, and any variables that previously referenced the original map will need to be redirected to reference the new instance. In the case of a FastMap or UnifiedMap, you will be replacing the reference to map with map, since FastMap and UnifiedMap will both return "this" after calling put on themselves.
        Specified by:
        withKeyValue in interface MutableMapIterable<K,​V>
        Specified by:
        withKeyValue in interface MutableOrderedMap<K,​V>
        See Also:
        Map.put(Object, Object)
      • withAllKeyValues

        public MutableOrderedMap<K,​V> withAllKeyValues​(java.lang.Iterable<? extends Pair<? extends K,​? extends V>> keyValues)
        Description copied from interface: MutableMapIterable
        This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing elements. In order to support fixed size maps, a new instance of a map would have to be returned including the keys and values of the original plus all the additional keys and values. In the case of mutable maps, the original map is modified and then returned. In order to use this method properly with mutable and fixed size maps the following approach must be taken:
         map = map.withAllKeyValues(FastList.newListWith(PairImpl.of("new key", "new value")));
         
        In the case of FixedSizeMap, a new instance will be returned by withAllKeyValues, and any variables that previously referenced the original map will need to be redirected to reference the new instance. In the case of a FastMap or UnifiedMap, you will be replacing the reference to map with map, since FastMap and UnifiedMap will both return "this" after calling put on themselves.
        Specified by:
        withAllKeyValues in interface MutableMapIterable<K,​V>
        Specified by:
        withAllKeyValues in interface MutableOrderedMap<K,​V>
        See Also:
        Map.put(Object, Object)
      • withoutKey

        public MutableOrderedMap<K,​V> withoutKey​(K key)
        Description copied from interface: MutableMapIterable
        This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing elements. In order to support fixed size maps, a new instance of a map would have to be returned including the keys and values of the original minus the key and value to be removed. In the case of mutable maps, the original map is modified and then returned. In order to use this method properly with mutable and fixed size maps the following approach must be taken:
         map = map.withoutKey("key");
         
        In the case of FixedSizeMap, a new instance will be returned by withoutKey, and any variables that previously referenced the original map will need to be redirected to reference the new instance. In the case of a FastMap or UnifiedMap, you will be replacing the reference to map with map, since FastMap and UnifiedMap will both return "this" after calling remove on themselves.
        Specified by:
        withoutKey in interface MutableMapIterable<K,​V>
        Specified by:
        withoutKey in interface MutableOrderedMap<K,​V>
        See Also:
        Map.remove(Object)
      • withoutAllKeys

        public MutableOrderedMap<K,​V> withoutAllKeys​(java.lang.Iterable<? extends K> keys)
        Description copied from interface: MutableMapIterable
        This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing elements. In order to support fixed size maps, a new instance of a map would have to be returned including the keys and values of the original minus all the keys and values to be removed. In the case of mutable maps, the original map is modified and then returned. In order to use this method properly with mutable and fixed size maps the following approach must be taken:
         map = map.withoutAllKeys(FastList.newListWith("key1", "key2"));
         
        In the case of FixedSizeMap, a new instance will be returned by withoutAllKeys, and any variables that previously referenced the original map will need to be redirected to reference the new instance. In the case of a FastMap or UnifiedMap, you will be replacing the reference to map with map, since FastMap and UnifiedMap will both return "this" after calling remove on themselves.
        Specified by:
        withoutAllKeys in interface MutableMapIterable<K,​V>
        Specified by:
        withoutAllKeys in interface MutableOrderedMap<K,​V>
        See Also:
        Map.remove(Object)
      • asUnmodifiable

        public MutableOrderedMap<K,​V> asUnmodifiable()
        Description copied from interface: MutableMapIterable
        Returns an unmodifiable view of this map. This is the equivalent of using Collections.unmodifiableMap(this) only with a return type that supports the full iteration protocols available on MutableMapIterable. Methods which would mutate the underlying map will throw UnsupportedOperationExceptions.
        Specified by:
        asUnmodifiable in interface MutableMapIterable<K,​V>
        Specified by:
        asUnmodifiable in interface MutableOrderedMap<K,​V>
        Returns:
        an unmodifiable view of this map.
        See Also:
        Collections.unmodifiableMap(Map)
      • asSynchronized

        public MutableOrderedMap<K,​V> asSynchronized()
        Description copied from interface: MutableMapIterable
        Returns a synchronized wrapper backed by this map. This is the equivalent of calling Collections.synchronizedMap(this) only with the more feature rich return type of MutableMapIterable.

        The preferred way of iterating over a synchronized map is to use the forEachKey(), forEachValue() and forEachKeyValue() methods which are properly synchronized internally.

          MutableMap synchedMap = map.asSynchronized();
        
          synchedMap.forEachKey(key -> ... );
          synchedMap.forEachValue(value -> ... );
          synchedMap.forEachKeyValue((key, value) -> ... );
         

        If you want to iterate imperatively over the keySet(), values(), or entrySet(), you will need to protect the iteration by wrapping the code in a synchronized block on the map.

        Specified by:
        asSynchronized in interface MutableMapIterable<K,​V>
        See Also:
        Collections.synchronizedMap(Map)
      • flip

        public MutableListMultimap<V,​K> flip()
        Description copied from interface: MapIterable
        Given a map from Domain -> Range return a multimap from Range -> Domain. We chose the name 'flip' rather than 'invert' or 'transpose' since this method does not have the property of applying twice returns the original.

        Since the keys in the input are unique, the values in the output are unique, so the return type should be a SetMultimap. However, since SetMultimap and SortedSetMultimap don't inherit from one another, SetMultimap here does not allow SortedMapIterable to have a SortedSetMultimap return. Thus, we compromise and call this Multimap, even though all implementations will be a SetMultimap or SortedSetMultimap.

        Specified by:
        flip in interface MapIterable<K,​V>
        Specified by:
        flip in interface MutableMapIterable<K,​V>
        Specified by:
        flip in interface MutableOrderedMap<K,​V>
        Specified by:
        flip in interface OrderedMap<K,​V>
      • collectBoolean

        public MutableBooleanList collectBoolean​(BooleanFunction<? super V> booleanFunction)
        Description copied from interface: RichIterable
        Returns a new primitive boolean iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         BooleanIterable licenses =
             people.collectBoolean(person -> person.hasDrivingLicense());
         

        Example using an anonymous inner class:

         BooleanIterable licenses =
             people.collectBoolean(new BooleanFunction<Person>()
             {
                 public boolean booleanValueOf(Person person)
                 {
                     return person.hasDrivingLicense();
                 }
             });
         
        Specified by:
        collectBoolean in interface MutableOrderedMap<K,​V>
        Specified by:
        collectBoolean in interface OrderedIterable<K>
        Specified by:
        collectBoolean in interface OrderedMap<K,​V>
        Specified by:
        collectBoolean in interface ReversibleIterable<K>
        Specified by:
        collectBoolean in interface RichIterable<K>
      • collectByte

        public MutableByteList collectByte​(ByteFunction<? super V> byteFunction)
        Description copied from interface: RichIterable
        Returns a new primitive byte iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         ByteIterable bytes =
             people.collectByte(person -> person.getCode());
         

        Example using an anonymous inner class:

         ByteIterable bytes =
             people.collectByte(new ByteFunction<Person>()
             {
                 public byte byteValueOf(Person person)
                 {
                     return person.getCode();
                 }
             });
         
        Specified by:
        collectByte in interface MutableOrderedMap<K,​V>
        Specified by:
        collectByte in interface OrderedIterable<K>
        Specified by:
        collectByte in interface OrderedMap<K,​V>
        Specified by:
        collectByte in interface ReversibleIterable<K>
        Specified by:
        collectByte in interface RichIterable<K>
      • collectChar

        public MutableCharList collectChar​(CharFunction<? super V> charFunction)
        Description copied from interface: RichIterable
        Returns a new primitive char iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         CharIterable chars =
             people.collectChar(person -> person.getMiddleInitial());
         

        Example using an anonymous inner class:

         CharIterable chars =
             people.collectChar(new CharFunction<Person>()
             {
                 public char charValueOf(Person person)
                 {
                     return person.getMiddleInitial();
                 }
             });
         
        Specified by:
        collectChar in interface MutableOrderedMap<K,​V>
        Specified by:
        collectChar in interface OrderedIterable<K>
        Specified by:
        collectChar in interface OrderedMap<K,​V>
        Specified by:
        collectChar in interface ReversibleIterable<K>
        Specified by:
        collectChar in interface RichIterable<K>
      • collectDouble

        public MutableDoubleList collectDouble​(DoubleFunction<? super V> doubleFunction)
        Description copied from interface: RichIterable
        Returns a new primitive double iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         DoubleIterable doubles =
             people.collectDouble(person -> person.getMilesFromNorthPole());
         

        Example using an anonymous inner class:

         DoubleIterable doubles =
             people.collectDouble(new DoubleFunction<Person>()
             {
                 public double doubleValueOf(Person person)
                 {
                     return person.getMilesFromNorthPole();
                 }
             });
         
        Specified by:
        collectDouble in interface MutableOrderedMap<K,​V>
        Specified by:
        collectDouble in interface OrderedIterable<K>
        Specified by:
        collectDouble in interface OrderedMap<K,​V>
        Specified by:
        collectDouble in interface ReversibleIterable<K>
        Specified by:
        collectDouble in interface RichIterable<K>
      • collectFloat

        public MutableFloatList collectFloat​(FloatFunction<? super V> floatFunction)
        Description copied from interface: RichIterable
        Returns a new primitive float iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         FloatIterable floats =
             people.collectFloat(person -> person.getHeightInInches());
         

        Example using an anonymous inner class:

         FloatIterable floats =
             people.collectFloat(new FloatFunction<Person>()
             {
                 public float floatValueOf(Person person)
                 {
                     return person.getHeightInInches();
                 }
             });
         
        Specified by:
        collectFloat in interface MutableOrderedMap<K,​V>
        Specified by:
        collectFloat in interface OrderedIterable<K>
        Specified by:
        collectFloat in interface OrderedMap<K,​V>
        Specified by:
        collectFloat in interface ReversibleIterable<K>
        Specified by:
        collectFloat in interface RichIterable<K>
      • collectInt

        public MutableIntList collectInt​(IntFunction<? super V> intFunction)
        Description copied from interface: RichIterable
        Returns a new primitive int iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         IntIterable ints =
             people.collectInt(person -> person.getAge());
         

        Example using an anonymous inner class:

         IntIterable ints =
             people.collectInt(new IntFunction<Person>()
             {
                 public int intValueOf(Person person)
                 {
                     return person.getAge();
                 }
             });
         
        Specified by:
        collectInt in interface MutableOrderedMap<K,​V>
        Specified by:
        collectInt in interface OrderedIterable<K>
        Specified by:
        collectInt in interface OrderedMap<K,​V>
        Specified by:
        collectInt in interface ReversibleIterable<K>
        Specified by:
        collectInt in interface RichIterable<K>
      • collectLong

        public MutableLongList collectLong​(LongFunction<? super V> longFunction)
        Description copied from interface: RichIterable
        Returns a new primitive long iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         LongIterable longs =
             people.collectLong(person -> person.getGuid());
         

        Example using an anonymous inner class:

         LongIterable longs =
             people.collectLong(new LongFunction<Person>()
             {
                 public long longValueOf(Person person)
                 {
                     return person.getGuid();
                 }
             });
         
        Specified by:
        collectLong in interface MutableOrderedMap<K,​V>
        Specified by:
        collectLong in interface OrderedIterable<K>
        Specified by:
        collectLong in interface OrderedMap<K,​V>
        Specified by:
        collectLong in interface ReversibleIterable<K>
        Specified by:
        collectLong in interface RichIterable<K>
      • collectShort

        public MutableShortList collectShort​(ShortFunction<? super V> shortFunction)
        Description copied from interface: RichIterable
        Returns a new primitive short iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         ShortIterable shorts =
             people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth());
         

        Example using an anonymous inner class:

         ShortIterable shorts =
             people.collectShort(new ShortFunction<Person>()
             {
                 public short shortValueOf(Person person)
                 {
                     return person.getNumberOfJunkMailItemsReceivedPerMonth();
                 }
             });
         
        Specified by:
        collectShort in interface MutableOrderedMap<K,​V>
        Specified by:
        collectShort in interface OrderedIterable<K>
        Specified by:
        collectShort in interface OrderedMap<K,​V>
        Specified by:
        collectShort in interface ReversibleIterable<K>
        Specified by:
        collectShort in interface RichIterable<K>
      • collectValues

        public <R> MutableOrderedMap<K,​R> collectValues​(Function2<? super K,​? super V,​? extends R> function)
        Description copied from interface: MapIterable
        For each key and value of the map the function is evaluated. The results of these evaluations are returned in a new map. The map returned will use the values projected from the function rather than the original values.
         MapIterable<City, String> collected =
             peopleByCity.collectValues((City city, Person person) -> person.getFirstName() + " " + person.getLastName());
         
        Specified by:
        collectValues in interface MapIterable<K,​V>
        Specified by:
        collectValues in interface MutableMapIterable<K,​V>
        Specified by:
        collectValues in interface MutableOrderedMap<K,​V>
        Specified by:
        collectValues in interface OrderedMap<K,​V>
      • select

        public MutableOrderedMap<K,​V> select​(Predicate2<? super K,​? super V> predicate)
        Description copied from interface: MapIterable
        For each key and value of the map the predicate is evaluated, if the result of the evaluation is true, that key and value are returned in a new map.
         MapIterable<City, Person> selected =
             peopleByCity.select((city, person) -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
         
        Specified by:
        select in interface MapIterable<K,​V>
        Specified by:
        select in interface MutableMapIterable<K,​V>
        Specified by:
        select in interface MutableOrderedMap<K,​V>
        Specified by:
        select in interface OrderedMap<K,​V>
      • reject

        public MutableOrderedMap<K,​V> reject​(Predicate2<? super K,​? super V> predicate)
        Description copied from interface: MapIterable
        For each key and value of the map the predicate is evaluated, if the result of the evaluation is false, that key and value are returned in a new map.
         MapIterable<City, Person> rejected =
             peopleByCity.reject((city, person) -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
         
        Specified by:
        reject in interface MapIterable<K,​V>
        Specified by:
        reject in interface MutableMapIterable<K,​V>
        Specified by:
        reject in interface MutableOrderedMap<K,​V>
        Specified by:
        reject in interface OrderedMap<K,​V>
      • collect

        public <R> MutableList<R> collect​(Function<? super V,​? extends R> function)
        Description copied from interface: RichIterable
        Returns a new collection with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         RichIterable<String> names =
             people.collect(person -> person.getFirstName() + " " + person.getLastName());
         

        Example using an anonymous inner class:

         RichIterable<String> names =
             people.collect(new Function<Person, String>()
             {
                 public String valueOf(Person person)
                 {
                     return person.getFirstName() + " " + person.getLastName();
                 }
             });
         
        Specified by:
        collect in interface MutableOrderedMap<K,​V>
        Specified by:
        collect in interface OrderedIterable<K>
        Specified by:
        collect in interface OrderedMap<K,​V>
        Specified by:
        collect in interface ReversibleIterable<K>
        Specified by:
        collect in interface RichIterable<K>
      • collectWith

        public <P,​VV> MutableList<VV> collectWith​(Function2<? super V,​? super P,​? extends VV> function,
                                                        P parameter)
        Description copied from interface: RichIterable
        Same as RichIterable.collect(Function) with a Function2 and specified parameter which is passed to the block.

        Example using a Java 8 lambda expression:

         RichIterable<Integer> integers =
             Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1));
         

        Example using an anonymous inner class:

         Function2<Integer, Integer, Integer> addParameterFunction =
             new Function2<Integer, Integer, Integer>()
             {
                 public Integer value(Integer each, Integer parameter)
                 {
                     return each + parameter;
                 }
             };
         RichIterable<Integer> integers =
             Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
         
        Specified by:
        collectWith in interface MutableOrderedMap<K,​V>
        Specified by:
        collectWith in interface OrderedIterable<K>
        Specified by:
        collectWith in interface OrderedMap<K,​V>
        Specified by:
        collectWith in interface ReversibleIterable<K>
        Specified by:
        collectWith in interface RichIterable<K>
        Parameters:
        function - A Function2 to use as the collect transformation function
        parameter - A parameter to pass in for evaluation of the second argument P in function
        Returns:
        A new RichIterable that contains the transformed elements returned by Function2.value(Object, Object)
        See Also:
        RichIterable.collect(Function)
      • collectIf

        public <R> MutableList<R> collectIf​(Predicate<? super V> predicate,
                                            Function<? super V,​? extends R> function)
        Description copied from interface: RichIterable
        Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate. This is the optimized equivalent of calling iterable.select(predicate).collect(function).

        Example using a Java 8 lambda and method reference:

         RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(e -> e != null, Object::toString);
         

        Example using Predicates factory:

         RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString());
         
        Specified by:
        collectIf in interface MutableOrderedMap<K,​V>
        Specified by:
        collectIf in interface OrderedIterable<K>
        Specified by:
        collectIf in interface OrderedMap<K,​V>
        Specified by:
        collectIf in interface ReversibleIterable<K>
        Specified by:
        collectIf in interface RichIterable<K>
      • flatCollect

        public <R> MutableList<R> flatCollect​(Function<? super V,​? extends java.lang.Iterable<R>> function)
        Description copied from interface: RichIterable
        flatCollect is a special case of RichIterable.collect(Function). With collect, when the Function returns a collection, the result is a collection of collections. flatCollect outputs a single "flattened" collection instead. This method is commonly called flatMap.

        Consider the following example where we have a Person class, and each Person has a list of Address objects. Take the following Function:

         Function<Person, List<Address>> addressFunction = Person::getAddresses;
         RichIterable<Person> people = ...;
         
        Using collect returns a collection of collections of addresses.
         RichIterable<List<Address>> addresses = people.collect(addressFunction);
         
        Using flatCollect returns a single flattened list of addresses.
         RichIterable<Address> addresses = people.flatCollect(addressFunction);
         
        Specified by:
        flatCollect in interface MutableOrderedMap<K,​V>
        Specified by:
        flatCollect in interface OrderedIterable<K>
        Specified by:
        flatCollect in interface OrderedMap<K,​V>
        Specified by:
        flatCollect in interface ReversibleIterable<K>
        Specified by:
        flatCollect in interface RichIterable<K>
        Parameters:
        function - The Function to apply
        Returns:
        a new flattened collection produced by applying the given function
      • select

        public MutableList<V> select​(Predicate<? super V> predicate)
        Description copied from interface: RichIterable
        Returns all elements of the source collection that return true when evaluating the predicate. This method is also commonly called filter.

        Example using a Java 8 lambda expression:

         RichIterable<Person> selected =
             people.select(person -> person.getAddress().getCity().equals("London"));
         

        Example using an anonymous inner class:

         RichIterable<Person> selected =
             people.select(new Predicate<Person>()
             {
                 public boolean accept(Person person)
                 {
                     return person.getAddress().getCity().equals("London");
                 }
             });
         
        Specified by:
        select in interface MutableMapIterable<K,​V>
        Specified by:
        select in interface MutableOrderedMap<K,​V>
        Specified by:
        select in interface OrderedIterable<K>
        Specified by:
        select in interface OrderedMap<K,​V>
        Specified by:
        select in interface ReversibleIterable<K>
        Specified by:
        select in interface RichIterable<K>
      • reject

        public MutableList<V> reject​(Predicate<? super V> predicate)
        Description copied from interface: RichIterable
        Returns all elements of the source collection that return false when evaluating of the predicate. This method is also sometimes called filterNot and is the equivalent of calling iterable.select(Predicates.not(predicate)).

        Example using a Java 8 lambda expression:

         RichIterable<Person> rejected =
             people.reject(person -> person.person.getLastName().equals("Smith"));
         

        Example using an anonymous inner class:

         RichIterable<Person> rejected =
             people.reject(new Predicate<Person>()
             {
                 public boolean accept(Person person)
                 {
                     return person.person.getLastName().equals("Smith");
                 }
             });
         
        Specified by:
        reject in interface MutableMapIterable<K,​V>
        Specified by:
        reject in interface MutableOrderedMap<K,​V>
        Specified by:
        reject in interface OrderedIterable<K>
        Specified by:
        reject in interface OrderedMap<K,​V>
        Specified by:
        reject in interface ReversibleIterable<K>
        Specified by:
        reject in interface RichIterable<K>
        Parameters:
        predicate - a Predicate to use as the reject criteria
        Returns:
        a RichIterable that contains elements that cause Predicate.accept(Object) method to evaluate to false
      • partition

        public PartitionMutableList<V> partition​(Predicate<? super V> predicate)
        Description copied from interface: RichIterable
        Filters a collection into a PartitionedIterable based on the evaluation of the predicate.

        Example using a Java 8 lambda expression:

         PartitionIterable<Person> newYorkersAndNonNewYorkers =
             people.partition(person -> person.getAddress().getState().getName().equals("New York"));
         

        Example using an anonymous inner class:

         PartitionIterable<Person> newYorkersAndNonNewYorkers =
             people.partition(new Predicate<Person>()
             {
                 public boolean accept(Person person)
                 {
                     return person.getAddress().getState().getName().equals("New York");
                 }
             });
         
        Specified by:
        partition in interface MutableMapIterable<K,​V>
        Specified by:
        partition in interface MutableOrderedMap<K,​V>
        Specified by:
        partition in interface OrderedIterable<K>
        Specified by:
        partition in interface OrderedMap<K,​V>
        Specified by:
        partition in interface ReversibleIterable<K>
        Specified by:
        partition in interface RichIterable<K>
      • partitionWith

        public <P> PartitionMutableList<V> partitionWith​(Predicate2<? super V,​? super P> predicate,
                                                         P parameter)
        Description copied from interface: RichIterable
        Filters a collection into a PartitionIterable based on the evaluation of the predicate.

        Example using a Java 8 lambda expression:

         PartitionIterable<Person> newYorkersAndNonNewYorkers =
             people.partitionWith((Person person, String state) -> person.getAddress().getState().getName().equals(state), "New York");
         

        Example using an anonymous inner class:

         PartitionIterable<Person> newYorkersAndNonNewYorkers =
             people.partitionWith(new Predicate2<Person, String>()
             {
                 public boolean accept(Person person, String state)
                 {
                     return person.getAddress().getState().getName().equals(state);
                 }
             }, "New York");
         
        Specified by:
        partitionWith in interface MutableOrderedMap<K,​V>
        Specified by:
        partitionWith in interface OrderedIterable<K>
        Specified by:
        partitionWith in interface OrderedMap<K,​V>
        Specified by:
        partitionWith in interface ReversibleIterable<K>
        Specified by:
        partitionWith in interface RichIterable<K>
      • zip

        public <S> MutableList<Pair<V,​S>> zip​(java.lang.Iterable<S> that)
        Description copied from interface: RichIterable
        Returns a RichIterable formed from this RichIterable and another RichIterable by combining corresponding elements in pairs. If one of the two RichIterables is longer than the other, its remaining elements are ignored.
        Specified by:
        zip in interface MutableMapIterable<K,​V>
        Specified by:
        zip in interface MutableOrderedMap<K,​V>
        Specified by:
        zip in interface OrderedIterable<K>
        Specified by:
        zip in interface OrderedMap<K,​V>
        Specified by:
        zip in interface ReversibleIterable<K>
        Specified by:
        zip in interface RichIterable<K>
        Type Parameters:
        S - the type of the second half of the returned pairs
        Parameters:
        that - The RichIterable providing the second half of each result pair
        Returns:
        A new RichIterable containing pairs consisting of corresponding elements of this RichIterable and that. The length of the returned RichIterable is the minimum of the lengths of this RichIterable and that.
      • groupBy

        public <VV> MutableListMultimap<VV,​V> groupBy​(Function<? super V,​? extends VV> function)
        Description copied from interface: RichIterable
        For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable.

        Example using a Java 8 method reference:

         Multimap<String, Person> peopleByLastName =
             people.groupBy(Person::getLastName);
         

        Example using an anonymous inner class:

         Multimap<String, Person> peopleByLastName =
             people.groupBy(new Function<Person, String>()
             {
                 public String valueOf(Person person)
                 {
                     return person.getLastName();
                 }
             });
         
        Specified by:
        groupBy in interface MutableMapIterable<K,​V>
        Specified by:
        groupBy in interface MutableOrderedMap<K,​V>
        Specified by:
        groupBy in interface OrderedIterable<K>
        Specified by:
        groupBy in interface OrderedMap<K,​V>
        Specified by:
        groupBy in interface ReversibleIterable<K>
        Specified by:
        groupBy in interface RichIterable<K>
      • detectLastIndex

        public int detectLastIndex​(Predicate<? super V> predicate)
        Description copied from interface: ReversibleIterable
        Returns the index of the last element of the ReversibleIterable for which the predicate evaluates to true. Returns -1 if no element evaluates true for the predicate.
        Specified by:
        detectLastIndex in interface ReversibleIterable<K>
      • indexOf

        public int indexOf​(java.lang.Object object)
        Description copied from interface: OrderedIterable
        Returns the index of the first occurrence of the specified item in this iterable, or -1 if this iterable does not contain the item.
        Specified by:
        indexOf in interface OrderedIterable<K>
        See Also:
        List.indexOf(Object)
      • corresponds

        public <S> boolean corresponds​(OrderedIterable<S> other,
                                       Predicate2<? super V,​? super S> predicate)
        Description copied from interface: OrderedIterable
        Returns true if both OrderedIterables have the same length and predicate returns true for all corresponding elements e1 of this OrderedIterable and e2 of other. The predicate is evaluated for each element at the same position of each OrderedIterable in a forward iteration order. This is a short circuit pattern.
        Specified by:
        corresponds in interface OrderedIterable<K>
      • forEach

        public void forEach​(int startIndex,
                            int endIndex,
                            Procedure<? super V> procedure)
        Description copied from interface: OrderedIterable
        Iterates over the section of the iterable covered by the specified inclusive indexes. The indexes are both inclusive.
        e.g.
         OrderedIterable<People> people = FastList.newListWith(ted, mary, bob, sally)
         people.forEach(0, 1, new Procedure<Person>()
         {
             public void value(Person person)
             {
                  LOGGER.info(person.getName());
             }
         });
         

        This code would output ted and mary's names.

        Specified by:
        forEach in interface OrderedIterable<K>
      • forEachWithIndex

        public void forEachWithIndex​(int fromIndex,
                                     int toIndex,
                                     ObjectIntProcedure<? super V> objectIntProcedure)
        Description copied from interface: OrderedIterable
        Iterates over the section of the iterable covered by the specified inclusive indexes. The indexes are both inclusive.
        e.g.
         OrderedIterable<People> people = FastList.newListWith(ted, mary, bob, sally)
         people.forEachWithIndex(0, 1, new ObjectIntProcedure<Person>()
         {
             public void value(Person person, int index)
             {
                  LOGGER.info(person.getName());
             }
         });
         

        This code would output ted and mary's names.

        Specified by:
        forEachWithIndex in interface OrderedIterable<K>
      • detectIndex

        public int detectIndex​(Predicate<? super V> predicate)
        Description copied from interface: OrderedIterable
        Returns the index of the first element of the OrderedIterable for which the predicate evaluates to true. Returns -1 if no element evaluates true for the predicate.
        Specified by:
        detectIndex in interface OrderedIterable<K>
      • getIfAbsentPut

        public V getIfAbsentPut​(K key,
                                Function0<? extends V> function)
        Description copied from interface: MutableMapIterable
        Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map at the key, return the result of evaluating the specified Function0, and put that value in the map at the specified key.
        Specified by:
        getIfAbsentPut in interface MutableMapIterable<K,​V>
      • getIfAbsentPut

        public V getIfAbsentPut​(K key,
                                V value)
        Description copied from interface: MutableMapIterable
        Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map at the key, return the specified value, and put that value in the map at the specified key.
        Specified by:
        getIfAbsentPut in interface MutableMapIterable<K,​V>
      • getIfAbsentPutWithKey

        public V getIfAbsentPutWithKey​(K key,
                                       Function<? super K,​? extends V> function)
        Description copied from interface: MutableMapIterable
        Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map for that key return the result of evaluating the specified Function using the specified key, and put that value in the map at the specified key.
        Specified by:
        getIfAbsentPutWithKey in interface MutableMapIterable<K,​V>
      • getIfAbsentPutWith

        public <P> V getIfAbsentPutWith​(K key,
                                        Function<? super P,​? extends V> function,
                                        P parameter)
        Description copied from interface: MutableMapIterable
        Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map for that key return the result of evaluating the specified Function using the specified parameter, and put that value in the map at the specified key.
        Specified by:
        getIfAbsentPutWith in interface MutableMapIterable<K,​V>
      • updateValue

        public V updateValue​(K key,
                             Function0<? extends V> factory,
                             Function<? super V,​? extends V> function)
        Description copied from interface: MutableMapIterable
        Looks up the value associated with key, applies the function to it, and replaces the value. If there is no value associated with key, starts it off with a value supplied by factory.
        Specified by:
        updateValue in interface MutableMapIterable<K,​V>
      • keysView

        public RichIterable<K> keysView()
        Description copied from interface: MapIterable
        Returns an unmodifiable lazy iterable wrapped around the keySet for the map.
        Specified by:
        keysView in interface MapIterable<K,​V>
      • valuesView

        public RichIterable<V> valuesView()
        Description copied from interface: MapIterable
        Returns an unmodifiable lazy iterable wrapped around the values for the map.
        Specified by:
        valuesView in interface MapIterable<K,​V>
      • keyValuesView

        public RichIterable<Pair<K,​V>> keyValuesView()
        Description copied from interface: MapIterable
        Returns an unmodifiable lazy iterable of key/value pairs wrapped around the entrySet for the map.
        Specified by:
        keyValuesView in interface MapIterable<K,​V>
      • collect

        public <K2,​V2> MutableOrderedMap<K2,​V2> collect​(Function2<? super K,​? super V,​Pair<K2,​V2>> function)
        Description copied from interface: MapIterable
        For each key and value of the map the function is evaluated. The results of these evaluations are returned in a new map. The map returned will use the values projected from the function rather than the original values.
         MapIterable<String, String> collected =
             peopleByCity.collect((City city, Person person) -> Pair.of(city.getCountry(), person.getAddress().getCity()));
         
        Specified by:
        collect in interface MapIterable<K,​V>
        Specified by:
        collect in interface MutableMapIterable<K,​V>
        Specified by:
        collect in interface MutableOrderedMap<K,​V>
        Specified by:
        collect in interface OrderedMap<K,​V>
      • detect

        public Pair<K,​V> detect​(Predicate2<? super K,​? super V> predicate)
        Description copied from interface: MapIterable
        Return the first key and value of the map for which the predicate evaluates to true when they are given as arguments. The predicate will only be evaluated until such pair is found or until all the keys and values of the map have been used as arguments. That is, there may be keys and values of the map that are never used as arguments to the predicate. The result is null if predicate does not evaluate to true for any key/value combination.
         Pair<City, Person> detected =
             peopleByCity.detect((City city, Person person) -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
         
        Specified by:
        detect in interface MapIterable<K,​V>
      • detectOptional

        public java.util.Optional<Pair<K,​V>> detectOptional​(Predicate2<? super K,​? super V> predicate)
        Description copied from interface: MapIterable
        Return the first key and value of the map as an Optional for which the predicate evaluates to true when they are given as arguments. The predicate will only be evaluated until such pair is found or until all the keys and values of the map have been used as arguments. That is, there may be keys and values of the map that are never used as arguments to the predicate.
         Optional<Pair<City, Person>> detected =
             peopleByCity.detectOptional((city, person)
                  -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
         
        Specified by:
        detectOptional in interface MapIterable<K,​V>
      • countBy

        public <V1> MutableBag<V1> countBy​(Function<? super V,​? extends V1> function)
        Description copied from interface: RichIterable
        This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.
        Specified by:
        countBy in interface MutableMapIterable<K,​V>
        Specified by:
        countBy in interface RichIterable<K>
      • countByWith

        public <V1,​P> MutableBag<V1> countByWith​(Function2<? super V,​? super P,​? extends V1> function,
                                                       P parameter)
        Description copied from interface: RichIterable
        This method will count the number of occurrences of each value calculated by applying the function to each element of the collection with the specified parameter as the second argument.
        Specified by:
        countByWith in interface MutableMapIterable<K,​V>
        Specified by:
        countByWith in interface RichIterable<K>