sample/java.util.concurrent.ConcurrentNavigableMap.txt

   1 *java.util.concurrent.ConcurrentNavigableMap* *ConcurrentNavigableMap* AConcurre
   2
   3 public interface interface ConcurrentNavigableMap<K,V>
   4
   5   implements |java.util.concurrent.ConcurrentMap|
   6              |java.util.NavigableMap|
   7
   8 |java.util.concurrent.ConcurrentNavigableMap_Description|
   9 |java.util.concurrent.ConcurrentNavigableMap_Fields|
  10 |java.util.concurrent.ConcurrentNavigableMap_Constructors|
  11 |java.util.concurrent.ConcurrentNavigableMap_Methods|
  12
  13 ================================================================================
  14
  15 *java.util.concurrent.ConcurrentNavigableMap_Methods*
  16 |java.util.concurrent.ConcurrentNavigableMap.descendingKeySet()|Returns a rever
  17 |java.util.concurrent.ConcurrentNavigableMap.descendingMap()|Returns a reverse
  18 |java.util.concurrent.ConcurrentNavigableMap.headMap(K)|
  19 |java.util.concurrent.ConcurrentNavigableMap.headMap(K,boolean)|
  20 |java.util.concurrent.ConcurrentNavigableMap.keySet()|Returns aNavigableSetview
  21 |java.util.concurrent.ConcurrentNavigableMap.navigableKeySet()|Returns aNavigab
  22 |java.util.concurrent.ConcurrentNavigableMap.subMap(K,boolean,K,boolean)|
  23 |java.util.concurrent.ConcurrentNavigableMap.subMap(K,K)|
  24 |java.util.concurrent.ConcurrentNavigableMap.tailMap(K)|
  25 |java.util.concurrent.ConcurrentNavigableMap.tailMap(K,boolean)|
  26
  27 *java.util.concurrent.ConcurrentNavigableMap_Description*
  28
  29 A (|java.util.concurrent.ConcurrentMap|) supporting (|java.util.NavigableMap|)
  30 operations, and recursively so for its navigable sub-maps.
  31
  32 This interface is a member of the <a
  33 href="/../technotes/guides/collections/index.html"> Java Collections Framework.
  34
  35
  36
  37 *java.util.concurrent.ConcurrentNavigableMap.descendingKeySet()*
  38
  39 public |java.util.NavigableSet|<K> descendingKeySet()
  40
  41 Returns a reverse order (|java.util.NavigableSet|) view of the keys contained
  42 in this map. The set's iterator returns the keys in descending order. The set
  43 is backed by the map, so changes to the map are reflected in the set, and
  44 vice-versa. The set supports element removal, which removes the corresponding
  45 mapping from the map, via theIterator.remove,Set.remove,removeAll,retainAll,
  46 andclearoperations. It does not support theaddoraddAlloperations.
  47
  48 The view'siteratoris a "weakly consistent" iterator that will never throw
  49 (|java.util.ConcurrentModificationException|) , and guarantees to traverse
  50 elements as they existed upon construction of the iterator, and may (but is not
  51 guaranteed to) reflect any modifications subsequent to construction.
  52
  53
  54
  55     Returns: a reverse order navigable set view of the keys in this map
  56
  57 *java.util.concurrent.ConcurrentNavigableMap.descendingMap()*
  58
  59 public |java.util.concurrent.ConcurrentNavigableMap|<K,V> descendingMap()
  60
  61 Returns a reverse order view of the mappings contained in this map. The
  62 descending map is backed by this map, so changes to the map are reflected in
  63 the descending map, and vice-versa.
  64
  65 The returned map has an ordering equivalent to
  66 Collections.reverseOrder(|java.util.Collections|) (comparator()). The
  67 expressionm.descendingMap().descendingMap()returns a view ofmessentially
  68 equivalent tom.
  69
  70
  71
  72     Returns: a reverse order view of this map
  73
  74 *java.util.concurrent.ConcurrentNavigableMap.headMap(K)*
  75
  76 public |java.util.concurrent.ConcurrentNavigableMap|<K,V> headMap(K toKey)
  77
  78
  79
  80
  81
  82 *java.util.concurrent.ConcurrentNavigableMap.headMap(K,boolean)*
  83
  84 public |java.util.concurrent.ConcurrentNavigableMap|<K,V> headMap(
  85   K toKey,
  86   boolean inclusive)
  87
  88
  89
  90
  91
  92 *java.util.concurrent.ConcurrentNavigableMap.keySet()*
  93
  94 public |java.util.NavigableSet|<K> keySet()
  95
  96 Returns a (|java.util.NavigableSet|) view of the keys contained in this map.
  97 The set's iterator returns the keys in ascending order. The set is backed by
  98 the map, so changes to the map are reflected in the set, and vice-versa. The
  99 set supports element removal, which removes the corresponding mapping from the
 100 map, via theIterator.remove,Set.remove,removeAll,retainAll, andclearoperations.
 101 It does not support theaddoraddAlloperations.
 102
 103 The view'siteratoris a "weakly consistent" iterator that will never throw
 104 (|java.util.ConcurrentModificationException|) , and guarantees to traverse
 105 elements as they existed upon construction of the iterator, and may (but is not
 106 guaranteed to) reflect any modifications subsequent to construction.
 107
 108 This method is equivalent to methodnavigableKeySet.
 109
 110
 111
 112     Returns: a navigable set view of the keys in this map
 113
 114 *java.util.concurrent.ConcurrentNavigableMap.navigableKeySet()*
 115
 116 public |java.util.NavigableSet|<K> navigableKeySet()
 117
 118 Returns a (|java.util.NavigableSet|) view of the keys contained in this map.
 119 The set's iterator returns the keys in ascending order. The set is backed by
 120 the map, so changes to the map are reflected in the set, and vice-versa. The
 121 set supports element removal, which removes the corresponding mapping from the
 122 map, via theIterator.remove,Set.remove,removeAll,retainAll, andclearoperations.
 123 It does not support theaddoraddAlloperations.
 124
 125 The view'siteratoris a "weakly consistent" iterator that will never throw
 126 (|java.util.ConcurrentModificationException|) , and guarantees to traverse
 127 elements as they existed upon construction of the iterator, and may (but is not
 128 guaranteed to) reflect any modifications subsequent to construction.
 129
 130
 131
 132     Returns: a navigable set view of the keys in this map
 133
 134 *java.util.concurrent.ConcurrentNavigableMap.subMap(K,boolean,K,boolean)*
 135
 136 public |java.util.concurrent.ConcurrentNavigableMap|<K,V> subMap(
 137   K fromKey,
 138   boolean fromInclusive,
 139   K toKey,
 140   boolean toInclusive)
 141
 142
 143
 144
 145
 146 *java.util.concurrent.ConcurrentNavigableMap.subMap(K,K)*
 147
 148 public |java.util.concurrent.ConcurrentNavigableMap|<K,V> subMap(
 149   K fromKey,
 150   K toKey)
 151
 152
 153
 154
 155
 156 *java.util.concurrent.ConcurrentNavigableMap.tailMap(K)*
 157
 158 public |java.util.concurrent.ConcurrentNavigableMap|<K,V> tailMap(K fromKey)
 159
 160
 161
 162
 163
 164 *java.util.concurrent.ConcurrentNavigableMap.tailMap(K,boolean)*
 165
 166 public |java.util.concurrent.ConcurrentNavigableMap|<K,V> tailMap(
 167   K fromKey,
 168   boolean inclusive)
 169
 170
 171
 172
 173
 174