TreeSortedMap (Eclipse Collections

java.lang.Object
- org.eclipse.collections.impl.AbstractRichIterable<V>
- - org.eclipse.collections.impl.map.AbstractMapIterable<K,V>
  - - org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable<K,V>
    - - org.eclipse.collections.impl.map.sorted.mutable.AbstractMutableSortedMap<K,V>
      - org.eclipse.collections.impl.map.sorted.mutable.TreeSortedMap<K,V>

All Implemented Interfaces:

Externalizable, Serializable, Cloneable, Iterable<V>, Map<K,V>, SortedMap<K,V>, InternalIterable<V>, MapIterable<K,V>, MutableMapIterable<K,V>, MutableSortedMap<K,V>, SortedMapIterable<K,V>, OrderedIterable<V>, ReversibleIterable<V>, RichIterable<V>
```
public class TreeSortedMap<K,V>
extends AbstractMutableSortedMap<K,V>
implements Externalizable
```
See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description
`TreeSortedMap()`
`TreeSortedMap(Comparator<? super K> comparator)`
`TreeSortedMap(Comparator<? super K> comparator, Map<? extends K,? extends V> map)`
`TreeSortedMap(Map<? extends K,? extends V> map)`
`TreeSortedMap(Pair<K,V>... pairs)`
`TreeSortedMap(SortedMap<K,? extends V> map)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`TreeSortedMap<K,V>`	`clone()`
`Comparator<? super K>`	`comparator()`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`MutableList<V>`	`distinct()` Returns a new `OrderedIterable` containing the distinct elements in this iterable.
`MutableSortedMap<K,V>`	`drop(int count)` Returns an iterable after skipping the first `count` elements or an empty iterable if the `count` is greater than the length of the iterable.
`MutableSortedMap<K,V>`	`dropWhile(Predicate<? super V> predicate)` Returns the final elements that do not satisfy the Predicate.
`MutableSet<Map.Entry<K,V>>`	`entrySet()`
`boolean`	`equals(Object o)` Follows the same general contract as `Map.equals(Object)`.
`K`	`firstKey()`
`void`	`forEachKeyValue(Procedure2<? super K,? super V> procedure2)` Calls the `procedure` with each key-value pair of the map.
`V`	`get(Object key)`
`int`	`hashCode()` Follows the same general contract as `Map.hashCode()`.
`MutableSortedMap<K,V>`	`headMap(K toKey)`
`MutableSet<K>`	`keySet()` The underlying set for the keys is sorted in ascending order according to their natural ordering or a custom comparator.
`K`	`lastKey()`
`MutableSortedMap<K,V>`	`newEmpty()` Creates a new instance of the same type with the same internal Comparator.
`static <K,V> TreeSortedMap<K,V>`	`newMap()`
`static <K,V> TreeSortedMap<K,V>`	`newMap(Comparator<? super K> comparator)`
`static <K,V> TreeSortedMap<K,V>`	`newMap(Comparator<? super K> comparator, Map<? extends K,? extends V> map)`
`static <K,V> TreeSortedMap<K,V>`	`newMap(Map<? extends K,? extends V> map)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(Comparator<? super K> comparator, K key, V value)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(Comparator<? super K> comparator, K key1, V value1, K key2, V value2)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(Comparator<? super K> comparator, K key1, V value1, K key2, V value2, K key3, V value3)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(Comparator<? super K> comparator, K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(Comparator<? super K> comparator, Pair<K,V>... pairs)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(K key, V value)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(K key1, V value1, K key2, V value2)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(K key1, V value1, K key2, V value2, K key3, V value3)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)`
`static <K,V> TreeSortedMap<K,V>`	`newMapWith(Pair<K,V>... pairs)`
`PartitionMutableList<V>`	`partitionWhile(Predicate<? super V> predicate)` Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements.
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> map)`
`void`	`readExternal(ObjectInput in)`
`V`	`remove(Object key)`
`V`	`removeKey(K key)` Remove an entry from the map at the specified `key`.
`int`	`size()` Returns the number of items in this iterable.
`MutableSortedMap<K,V>`	`subMap(K fromKey, K toKey)`
`MutableSortedMap<K,V>`	`tailMap(K fromKey)`
`MutableSortedMap<K,V>`	`take(int count)` Returns the first `count` elements of the iterable or all the elements in the iterable if `count` is greater than the length of the iterable.
`MutableSortedMap<K,V>`	`takeWhile(Predicate<? super V> predicate)` Returns the initial elements that satisfy the Predicate.
`MutableSortedMap<K,V>`	`toReversed()` Returns a new ReversibleIterable in reverse order.
`String`	`toString()` Returns a string representation of this collection.
`MutableCollection<V>`	`values()`
`TreeSortedMap<K,V>`	`with(K key, V value)`
`TreeSortedMap<K,V>`	`with(K key1, V value1, K key2, V value2)`
`TreeSortedMap<K,V>`	`with(K key1, V value1, K key2, V value2, K key3, V value3)`
`TreeSortedMap<K,V>`	`with(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)`
`TreeSortedMap<K,V>`	`with(Pair<K,V>... pairs)`
`void`	`writeExternal(ObjectOutput out)`

Methods inherited from class org.eclipse.collections.impl.map.sorted.mutable.AbstractMutableSortedMap
asReversed, asSynchronized, asUnmodifiable, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectKeysAndValues, collectLong, collectShort, collectValues, collectWith, corresponds, detectIndex, detectLastIndex, flatCollect, flip, forEach, forEachWithIndex, groupBy, groupByEach, indexOf, partition, partitionWith, reject, reject, rejectWith, reverseForEach, select, select, selectInstancesOf, selectWith, tap, toImmutable, toStack, withAllKeyValueArguments, withAllKeyValues, withKeyValue, withoutAllKeys, withoutKey, zip, zipWithIndex

Methods inherited from class org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable
add, aggregateBy, aggregateInPlaceBy, collect, detect, flipUniqueValues, getIfAbsentPut, getIfAbsentPut, getIfAbsentPutWith, getIfAbsentPutWithKey, groupByUniqueKey, iterator, keysView, keyValuesView, updateValue, updateValueWith, valuesView

Methods inherited from class org.eclipse.collections.impl.map.AbstractMapIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, asLazy, chunk, contains, detect, detectIfNone, detectWith, detectWithIfNone, each, forEachKey, forEachValue, forEachWith, forEachWithIndex, getFirst, getIfAbsent, getIfAbsentValue, getIfAbsentWith, getLast, ifPresentApply, noneSatisfy, noneSatisfyWith, toArray, toArray

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable
appendString, appendString, appendString, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, containsAll, containsAllArguments, containsAllIterable, count, countWith, flatCollect, forEach, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, notEmpty, reject, rejectWith, select, selectWith, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndex

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.collections.api.map.sorted.MutableSortedMap
aggregateBy, aggregateInPlaceBy, collect, getIfAbsentPutWith, groupByUniqueKey

Methods inherited from interface org.eclipse.collections.api.map.MutableMapIterable
add, flipUniqueValues, getIfAbsentPut, getIfAbsentPut, getIfAbsentPutWithKey, updateValue, updateValueWith

Methods inherited from interface org.eclipse.collections.api.map.MapIterable
detect, forEachKey, forEachValue, getIfAbsent, getIfAbsentValue, getIfAbsentWith, ifPresentApply, keysView, keyValuesView, valuesView

Methods inherited from interface org.eclipse.collections.api.ordered.OrderedIterable
forEachWithIndex, getFirst, getLast, max, min, zip, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.RichIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, each, flatCollect, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, maxBy, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reject, rejectWith, select, selectWith, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy

Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach, forEachWith

Methods inherited from interface java.lang.Iterable
forEach, iterator, spliterator

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, isEmpty, merge, putIfAbsent, remove, replace, replace, replaceAll

- Constructor Detail
  - TreeSortedMap
```
public TreeSortedMap()
```
  - TreeSortedMap
```
public TreeSortedMap(Comparator<? super K> comparator)
```
  - TreeSortedMap
```
public TreeSortedMap(Map<? extends K,? extends V> map)
```
  - TreeSortedMap
```
public TreeSortedMap(Comparator<? super K> comparator,
                     Map<? extends K,? extends V> map)
```
  - TreeSortedMap
```
public TreeSortedMap(SortedMap<K,? extends V> map)
```
  - TreeSortedMap
```
public TreeSortedMap(Pair<K,V>... pairs)
```
- Method Detail
  - newMap
```
public static <K,V> TreeSortedMap<K,V> newMap()
```
  - newMap
```
public static <K,V> TreeSortedMap<K,V> newMap(Comparator<? super K> comparator)
```
  - newMap
```
public static <K,V> TreeSortedMap<K,V> newMap(Map<? extends K,? extends V> map)
```
  - newMap
```
public static <K,V> TreeSortedMap<K,V> newMap(Comparator<? super K> comparator,
                                              Map<? extends K,? extends V> map)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(Pair<K,V>... pairs)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(Comparator<? super K> comparator,
                                                  Pair<K,V>... pairs)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(K key,
                                                  V value)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(K key1,
                                                  V value1,
                                                  K key2,
                                                  V value2)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(K key1,
                                                  V value1,
                                                  K key2,
                                                  V value2,
                                                  K key3,
                                                  V value3)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(K key1,
                                                  V value1,
                                                  K key2,
                                                  V value2,
                                                  K key3,
                                                  V value3,
                                                  K key4,
                                                  V value4)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(Comparator<? super K> comparator,
                                                  K key,
                                                  V value)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(Comparator<? super K> comparator,
                                                  K key1,
                                                  V value1,
                                                  K key2,
                                                  V value2)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(Comparator<? super K> comparator,
                                                  K key1,
                                                  V value1,
                                                  K key2,
                                                  V value2,
                                                  K key3,
                                                  V value3)
```
  - newMapWith
```
public static <K,V> TreeSortedMap<K,V> newMapWith(Comparator<? super K> comparator,
                                                  K key1,
                                                  V value1,
                                                  K key2,
                                                  V value2,
                                                  K key3,
                                                  V value3,
                                                  K key4,
                                                  V value4)
```
  - with
```
public TreeSortedMap<K,V> with(K key,
                               V value)
```
  - with
```
public TreeSortedMap<K,V> with(K key1,
                               V value1,
                               K key2,
                               V value2)
```
  - with
```
public TreeSortedMap<K,V> with(K key1,
                               V value1,
                               K key2,
                               V value2,
                               K key3,
                               V value3)
```
  - with
```
public TreeSortedMap<K,V> with(K key1,
                               V value1,
                               K key2,
                               V value2,
                               K key3,
                               V value3,
                               K key4,
                               V value4)
```
  - with
```
public TreeSortedMap<K,V> with(Pair<K,V>... pairs)
```
    Specified by:
    
    with in interface MutableSortedMap<K,V>
    
    Overrides:
    
    with in class AbstractMutableSortedMap<K,V>
  - size
```
public int size()
```
    Description copied from interface: RichIterable
    
    Returns the number of items in this iterable.
    
    Specified by:
    
    size in interface Map<K,V>
    
    Specified by:
    
    size in interface RichIterable<V>
  - newEmpty
```
public MutableSortedMap<K,V> newEmpty()
```
    Description copied from interface: MutableSortedMap
    
    Creates a new instance of the same type with the same internal Comparator.
    
    Specified by:
    
    newEmpty in interface MutableMapIterable<K,V>
    
    Specified by:
    
    newEmpty in interface MutableSortedMap<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)
  - clone
```
public TreeSortedMap<K,V> clone()
```
    Specified by:
    
    clone in interface MutableSortedMap<K,V>
    
    Specified by:
    
    clone in class AbstractMutableSortedMap<K,V>
  - equals
```
public boolean equals(Object o)
```
    Description copied from interface: MapIterable
    
    Follows the same general contract as Map.equals(Object).
    
    Specified by:
    
    equals in interface Map<K,V>
    
    Specified by:
    
    equals in interface MapIterable<K,V>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Description copied from interface: MapIterable
    
    Follows the same general contract as Map.hashCode().
    
    Specified by:
    
    hashCode in interface Map<K,V>
    
    Specified by:
    
    hashCode in interface MapIterable<K,V>
    
    Overrides:
    
    hashCode in class Object
  - forEachKeyValue
```
public void forEachKeyValue(Procedure2<? super K,? super V> procedure2)
```
    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(new Procedure2<Integer, String>()
     {
         public void value(final Integer key, final String value)
         {
             collection.add(String.valueOf(key) + value);
         }
     });
     Verify.assertContainsAll(collection, "1One", "2Two", "3Three");
 
```
    Specified by:
    
    forEachKeyValue in interface MapIterable<K,V>
  - firstKey
```
public K firstKey()
```
    Specified by:
    
    firstKey in interface SortedMap<K,V>
  - lastKey
```
public K lastKey()
```
    Specified by:
    
    lastKey in interface SortedMap<K,V>
  - entrySet
```
public MutableSet<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
    
    Specified by:
    
    entrySet in interface SortedMap<K,V>
    
    Specified by:
    
    entrySet in interface MutableSortedMap<K,V>
  - keySet
```
public MutableSet<K> keySet()
```
    Description copied from interface: MutableSortedMap
    
    The underlying set for the keys is sorted in ascending order according to their natural ordering or a custom comparator. However, Java 5 TreeMap returns a keySet that does not inherit from SortedSet therefore we have decided to return the keySet simply as a MutableSet to maintain Java 5 compatibility.
    
    Specified by:
    
    keySet in interface Map<K,V>
    
    Specified by:
    
    keySet in interface SortedMap<K,V>
    
    Specified by:
    
    keySet in interface MutableSortedMap<K,V>
  - values
```
public MutableCollection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
    
    Specified by:
    
    values in interface SortedMap<K,V>
    
    Specified by:
    
    values in interface MutableSortedMap<K,V>
  - comparator
```
public Comparator<? super K> comparator()
```
    Specified by:
    
    comparator in interface SortedMap<K,V>
    
    Specified by:
    
    comparator in interface SortedMapIterable<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface 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 Map<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
    
    Specified by:
    
    containsKey in interface MapIterable<K,V>
    
    See Also:
    
    Map.containsKey(Object)
  - headMap
```
public MutableSortedMap<K,V> headMap(K toKey)
```
    Specified by:
    
    headMap in interface SortedMap<K,V>
    
    Specified by:
    
    headMap in interface MutableSortedMap<K,V>
  - tailMap
```
public MutableSortedMap<K,V> tailMap(K fromKey)
```
    Specified by:
    
    tailMap in interface SortedMap<K,V>
    
    Specified by:
    
    tailMap in interface MutableSortedMap<K,V>
  - subMap
```
public MutableSortedMap<K,V> subMap(K fromKey,
                                    K toKey)
```
    Specified by:
    
    subMap in interface SortedMap<K,V>
    
    Specified by:
    
    subMap in interface MutableSortedMap<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
    
    Specified by:
    
    containsValue in interface MapIterable<K,V>
    
    See Also:
    
    Map.containsValue(Object)
  - toReversed
```
public MutableSortedMap<K,V> toReversed()
```
    Description copied from interface: ReversibleIterable
    
    Returns a new ReversibleIterable in reverse order.
    
    Specified by:
    
    toReversed in interface MutableSortedMap<K,V>
    
    Specified by:
    
    toReversed in interface SortedMapIterable<K,V>
    
    Specified by:
    
    toReversed in interface ReversibleIterable<V>
  - take
```
public MutableSortedMap<K,V> take(int count)
```
    Description copied from interface: ReversibleIterable
    
    Returns the first count elements of the iterable or all the elements in the iterable if count is greater than the length of the iterable.
    
    Specified by:
    
    take in interface MutableSortedMap<K,V>
    
    Specified by:
    
    take in interface SortedMapIterable<K,V>
    
    Specified by:
    
    take in interface ReversibleIterable<V>
    
    Parameters:
    
    count - the number of items to take.
  - takeWhile
```
public MutableSortedMap<K,V> takeWhile(Predicate<? super V> predicate)
```
    Description copied from interface: ReversibleIterable
    
    Returns the initial elements that satisfy the Predicate. Short circuits at the first element which does not satisfy the Predicate.
    
    Specified by:
    
    takeWhile in interface MutableSortedMap<K,V>
    
    Specified by:
    
    takeWhile in interface SortedMapIterable<K,V>
    
    Specified by:
    
    takeWhile in interface OrderedIterable<V>
    
    Specified by:
    
    takeWhile in interface ReversibleIterable<V>
  - drop
```
public MutableSortedMap<K,V> drop(int count)
```
    Description copied from interface: ReversibleIterable
    
    Returns an iterable after skipping the first count elements or an empty iterable if the count is greater than the length of the iterable.
    
    Specified by:
    
    drop in interface MutableSortedMap<K,V>
    
    Specified by:
    
    drop in interface SortedMapIterable<K,V>
    
    Specified by:
    
    drop in interface ReversibleIterable<V>
    
    Parameters:
    
    count - the number of items to drop.
  - dropWhile
```
public MutableSortedMap<K,V> dropWhile(Predicate<? super V> predicate)
```
    Description copied from interface: ReversibleIterable
    
    Returns the final elements that do not satisfy the Predicate. Short circuits at the first element which does satisfy the Predicate.
    
    Specified by:
    
    dropWhile in interface MutableSortedMap<K,V>
    
    Specified by:
    
    dropWhile in interface SortedMapIterable<K,V>
    
    Specified by:
    
    dropWhile in interface OrderedIterable<V>
    
    Specified by:
    
    dropWhile in interface ReversibleIterable<V>
  - partitionWhile
```
public PartitionMutableList<V> partitionWhile(Predicate<? super V> predicate)
```
    Description copied from interface: OrderedIterable
    
    Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements. Short circuits at the first element which does satisfy the Predicate.
    
    Specified by:
    
    partitionWhile in interface MutableSortedMap<K,V>
    
    Specified by:
    
    partitionWhile in interface SortedMapIterable<K,V>
    
    Specified by:
    
    partitionWhile in interface OrderedIterable<V>
    
    Specified by:
    
    partitionWhile in interface ReversibleIterable<V>
  - distinct
```
public MutableList<V> distinct()
```
    Description copied from interface: OrderedIterable
    
    Returns a new OrderedIterable containing the distinct elements in this iterable.
    Conceptually similar to RichIterable.toSet().RichIterable.toList() but retains the original order. If an element appears multiple times in this iterable, the first one will be copied into the result.
    
    Specified by:
    
    distinct in interface MutableSortedMap<K,V>
    
    Specified by:
    
    distinct in interface SortedMapIterable<K,V>
    
    Specified by:
    
    distinct in interface OrderedIterable<V>
    
    Specified by:
    
    distinct in interface ReversibleIterable<V>
    
    Returns:
    
    OrderedIterable of distinct elements
  - toString
```
public String toString()
```
    Description copied from class: AbstractRichIterable
    
    Returns a string representation of this collection. The string representation consists of a list of the collection's elements in the order they are returned by its iterator, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (comma and space). Elements are converted to strings as by String.valueOf(Object).
    
    This implementation creates an empty string buffer, appends a left square bracket, and iterates over the collection appending the string representation of each element in turn. After appending each element except the last, the string ", " is appended. Finally a right bracket is appended. A string is obtained from the string buffer, and returned.
    
    Specified by:
    
    toString in interface MapIterable<K,V>
    
    Specified by:
    
    toString in interface RichIterable<V>
    
    Overrides:
    
    toString in class AbstractRichIterable<V>
    
    Returns:
    
    a string representation of this collection.
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException

Class TreeSortedMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.collections.impl.map.sorted.mutable.AbstractMutableSortedMap

Methods inherited from class org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable

Methods inherited from class org.eclipse.collections.impl.map.AbstractMapIterable

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.collections.api.map.sorted.MutableSortedMap

Methods inherited from interface org.eclipse.collections.api.map.MutableMapIterable

Methods inherited from interface org.eclipse.collections.api.map.MapIterable

Methods inherited from interface org.eclipse.collections.api.ordered.OrderedIterable

Methods inherited from interface org.eclipse.collections.api.RichIterable

Methods inherited from interface org.eclipse.collections.api.InternalIterable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.Map

Constructor Detail

TreeSortedMap

TreeSortedMap

TreeSortedMap

TreeSortedMap

TreeSortedMap

TreeSortedMap

Method Detail

newMap

newMap

newMap

newMap

newMapWith

newMapWith

newMapWith

newMapWith

newMapWith

newMapWith

newMapWith

newMapWith

newMapWith

newMapWith

with

with

with

with

with

size

newEmpty

removeKey

clone

equals

hashCode

forEachKeyValue

firstKey

lastKey

entrySet

keySet

values

comparator

get

put

remove

putAll

clear

containsKey

headMap

tailMap

subMap

containsValue

toReversed

take

takeWhile

drop

dropWhile

partitionWhile

distinct

toString

writeExternal

readExternal