[cvs] / jsr166 / src / main / java / util / NavigableMap.java Repository:
ViewVC logotype

Diff of /jsr166/src/main/java/util/NavigableMap.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.13, Mon Mar 27 18:23:13 2006 UTC revision 1.14, Wed Apr 19 15:07:14 2006 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166   * Written by Doug Lea and Josh Bloch with assistance from members of JCP
3   * Expert Group and released to the public domain, as explained at   * JSR-166 Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/licenses/publicdomain   * http://creativecommons.org/licenses/publicdomain
5   */   */
6    
# Line 9  Line 9 
9  /**  /**
10   * A {@link SortedMap} extended with navigation methods returning the   * A {@link SortedMap} extended with navigation methods returning the
11   * closest matches for given search targets. Methods   * closest matches for given search targets. Methods
12   * <tt>lowerEntry</tt>, <tt>floorEntry</tt>, <tt>ceilingEntry</tt>,   * {@code lowerEntry}, {@code floorEntry}, {@code ceilingEntry},
13   * and <tt>higherEntry</tt> return <tt>Map.Entry</tt> objects   * and {@code higherEntry} return {@code Map.Entry} objects
14   * associated with keys respectively less than, less than or equal,   * associated with keys respectively less than, less than or equal,
15   * greater than or equal, and greater than a given key, returning   * greater than or equal, and greater than a given key, returning
16   * <tt>null</tt> if there is no such key.  Similarly, methods   * {@code null} if there is no such key.  Similarly, methods
17   * <tt>lowerKey</tt>, <tt>floorKey</tt>, <tt>ceilingKey</tt>, and   * {@code lowerKey}, {@code floorKey}, {@code ceilingKey}, and
18   * <tt>higherKey</tt> return only the associated keys. All of these   * {@code higherKey} return only the associated keys. All of these
19   * methods are designed for locating, not traversing entries.   * methods are designed for locating, not traversing entries.
20   *   *
21   * <p>A <tt>NavigableMap</tt> may be viewed and traversed in either   * <p>A {@code NavigableMap} may be accessed and traversed in either
22   * ascending or descending key order.  The <tt>Map</tt> methods   * ascending or descending key order.  The {@code descendingMap}
23   * <tt>keySet</tt> and <tt>entrySet</tt> return ascending views, and   * method returns a view of the map with the senses of all relational
24   * the additional methods <tt>descendingKeySet</tt> and   * and directional methods inverted. The performance of ascending
25   * <tt>descendingEntrySet</tt> return descending views. The   * operations and views is likely to be faster than that of descending
26   * performance of ascending traversals is likely to be faster than   * ones.  Methods {@code navigableSubMap}, {@code navigableHeadMap},
27   * descending traversals.  Notice that it is possible to perform   * and {@code navigableTailMap} differ from the similarly named {@code
28   * subrange traversals in either direction using <tt>navigableSubMap</tt>.   * SortedMap} methods in accepting additional arguments describing
29   * Methods <tt>navigableSubMap</tt>, <tt>navigableHeadMap</tt>, and   * whether lower and upper bounds are inclusive versus exclusive.
30   * <tt>navigableTailMap</tt> differ from the similarly named   * Submaps of any {@code NavigableMap} must implement the {@code
31   * <tt>SortedMap</tt> methods only in their declared return types.   * NavigableMap} interface.
32   * Submaps of any <tt>NavigableMap</tt> must implement the   *
33   * <tt>NavigableMap</tt> interface.   * <p>This interface additionally defines methods {@code firstEntry},
34   *   * {@code pollFirstEntry}, {@code lastEntry}, and
35   * <p>This interface additionally defines methods <tt>firstEntry</tt>,   * {@code pollLastEntry} that return and/or remove the least and
36   * <tt>pollFirstEntry</tt>, <tt>lastEntry</tt>, and   * greatest mappings, if any exist, else returning {@code null}.
  * <tt>pollLastEntry</tt> that return and/or remove the least and  
  * greatest mappings, if any exist, else returning <tt>null</tt>.  
37   *   *
38   * <p> Implementations of entry-returning methods are expected to   * <p> Implementations of entry-returning methods are expected to
39   * return <tt>Map.Entry</tt> pairs representing snapshots of mappings   * return {@code Map.Entry} pairs representing snapshots of mappings
40   * at the time they were produced, and thus generally do <em>not</em>   * at the time they were produced, and thus generally do <em>not</em>
41   * support the optional <tt>Entry.setValue</tt> method. Note however   * support the optional {@code Entry.setValue} method. Note however
42   * that it is possible to change mappings in the associated map using   * that it is possible to change mappings in the associated map using
43   * method <tt>put</tt>.   * method {@code put}.
44   *   *
45   * <p>This interface is a member of the   * <p>This interface is a member of the
46   * <a href="{@docRoot}/../guide/collections/index.html">   * <a href="{@docRoot}/../guide/collections/index.html">
47   * Java Collections Framework</a>.   * Java Collections Framework</a>.
48   *   *
49   * @author Doug Lea   * @author Doug Lea
50     * @author Josh Bloch
51   * @param <K> the type of keys maintained by this map   * @param <K> the type of keys maintained by this map
52   * @param <V> the type of mapped values   * @param <V> the type of mapped values
53   * @since 1.6   * @since 1.6
# Line 56  Line 55 
55  public interface NavigableMap<K,V> extends SortedMap<K,V> {  public interface NavigableMap<K,V> extends SortedMap<K,V> {
56      /**      /**
57       * Returns a key-value mapping associated with the greatest key       * Returns a key-value mapping associated with the greatest key
58       * strictly less than the given key, or <tt>null</tt> if there is       * strictly less than the given key, or {@code null} if there is
59       * no such key.       * no such key.
60       *       *
61       * @param key the key       * @param key the key
62       * @return an entry with the greatest key less than <tt>key</tt>,       * @return an entry with the greatest key less than {@code key},
63       *         or <tt>null</tt> if there is no such key       *         or {@code null} if there is no such key
64       * @throws ClassCastException if the specified key cannot be compared       * @throws ClassCastException if the specified key cannot be compared
65       *         with the keys currently in the map       *         with the keys currently in the map
66       * @throws NullPointerException if the specified key is null       * @throws NullPointerException if the specified key is null
# Line 71  Line 70 
70    
71      /**      /**
72       * Returns the greatest key strictly less than the given key, or       * Returns the greatest key strictly less than the given key, or
73       * <tt>null</tt> if there is no such key.       * {@code null} if there is no such key.
74       *       *
75       * @param key the key       * @param key the key
76       * @return the greatest key less than <tt>key</tt>,       * @return the greatest key less than {@code key},
77       *         or <tt>null</tt> if there is no such key       *         or {@code null} if there is no such key
78       * @throws ClassCastException if the specified key cannot be compared       * @throws ClassCastException if the specified key cannot be compared
79       *         with the keys currently in the map       *         with the keys currently in the map
80       * @throws NullPointerException if the specified key is null       * @throws NullPointerException if the specified key is null
# Line 85  Line 84 
84    
85      /**      /**
86       * Returns a key-value mapping associated with the greatest key       * Returns a key-value mapping associated with the greatest key
87       * less than or equal to the given key, or <tt>null</tt> if there       * less than or equal to the given key, or {@code null} if there
88       * is no such key.       * is no such key.
89       *       *
90       * @param key the key       * @param key the key
91       * @return an entry with the greatest key less than or equal to       * @return an entry with the greatest key less than or equal to
92       *         <tt>key</tt>, or <tt>null</tt> if there is no such key       *         {@code key}, or {@code null} if there is no such key
93       * @throws ClassCastException if the specified key cannot be compared       * @throws ClassCastException if the specified key cannot be compared
94       *         with the keys currently in the map       *         with the keys currently in the map
95       * @throws NullPointerException if the specified key is null       * @throws NullPointerException if the specified key is null
# Line 100  Line 99 
99    
100      /**      /**
101       * Returns the greatest key less than or equal to the given key,       * Returns the greatest key less than or equal to the given key,
102       * or <tt>null</tt> if there is no such key.       * or {@code null} if there is no such key.
103       *       *
104       * @param key the key       * @param key the key
105       * @return the greatest key less than or equal to <tt>key</tt>,       * @return the greatest key less than or equal to {@code key},
106       *         or <tt>null</tt> if there is no such key       *         or {@code null} if there is no such key
107       * @throws ClassCastException if the specified key cannot be compared       * @throws ClassCastException if the specified key cannot be compared
108       *         with the keys currently in the map       *         with the keys currently in the map
109       * @throws NullPointerException if the specified key is null       * @throws NullPointerException if the specified key is null
# Line 114  Line 113 
113    
114      /**      /**
115       * Returns a key-value mapping associated with the least key       * Returns a key-value mapping associated with the least key
116       * greater than or equal to the given key, or <tt>null</tt> if       * greater than or equal to the given key, or {@code null} if
117       * there is no such key.       * there is no such key.
118       *       *
119       * @param key the key       * @param key the key
120       * @return an entry with the least key greater than or equal to       * @return an entry with the least key greater than or equal to
121       *         <tt>key</tt>, or <tt>null</tt> if there is no such key       *         {@code key}, or {@code null} if there is no such key
122       * @throws ClassCastException if the specified key cannot be compared       * @throws ClassCastException if the specified key cannot be compared
123       *         with the keys currently in the map       *         with the keys currently in the map
124       * @throws NullPointerException if the specified key is null       * @throws NullPointerException if the specified key is null
# Line 129  Line 128 
128    
129      /**      /**
130       * Returns the least key greater than or equal to the given key,       * Returns the least key greater than or equal to the given key,
131       * or <tt>null</tt> if there is no such key.       * or {@code null} if there is no such key.
132       *       *
133       * @param key the key       * @param key the key
134       * @return the least key greater than or equal to <tt>key</tt>,       * @return the least key greater than or equal to {@code key},
135       *         or <tt>null</tt> if there is no such key       *         or {@code null} if there is no such key
136       * @throws ClassCastException if the specified key cannot be compared       * @throws ClassCastException if the specified key cannot be compared
137       *         with the keys currently in the map       *         with the keys currently in the map
138       * @throws NullPointerException if the specified key is null       * @throws NullPointerException if the specified key is null
# Line 143  Line 142 
142    
143      /**      /**
144       * Returns a key-value mapping associated with the least key       * Returns a key-value mapping associated with the least key
145       * strictly greater than the given key, or <tt>null</tt> if there       * strictly greater than the given key, or {@code null} if there
146       * is no such key.       * is no such key.
147       *       *
148       * @param key the key       * @param key the key
149       * @return an entry with the least key greater than <tt>key</tt>,       * @return an entry with the least key greater than {@code key},
150       *         or <tt>null</tt> if there is no such key       *         or {@code null} if there is no such key
151       * @throws ClassCastException if the specified key cannot be compared       * @throws ClassCastException if the specified key cannot be compared
152       *         with the keys currently in the map       *         with the keys currently in the map
153       * @throws NullPointerException if the specified key is null       * @throws NullPointerException if the specified key is null
# Line 158  Line 157 
157    
158      /**      /**
159       * Returns the least key strictly greater than the given key, or       * Returns the least key strictly greater than the given key, or
160       * <tt>null</tt> if there is no such key.       * {@code null} if there is no such key.
161       *       *
162       * @param key the key       * @param key the key
163       * @return the least key greater than <tt>key</tt>,       * @return the least key greater than {@code key},
164       *         or <tt>null</tt> if there is no such key       *         or {@code null} if there is no such key
165       * @throws ClassCastException if the specified key cannot be compared       * @throws ClassCastException if the specified key cannot be compared
166       *         with the keys currently in the map       *         with the keys currently in the map
167       * @throws NullPointerException if the specified key is null       * @throws NullPointerException if the specified key is null
# Line 172  Line 171 
171    
172      /**      /**
173       * Returns a key-value mapping associated with the least       * Returns a key-value mapping associated with the least
174       * key in this map, or <tt>null</tt> if the map is empty.       * key in this map, or {@code null} if the map is empty.
175       *       *
176       * @return an entry with the least key,       * @return an entry with the least key,
177       *         or <tt>null</tt> if this map is empty       *         or {@code null} if this map is empty
178       */       */
179      Map.Entry<K,V> firstEntry();      Map.Entry<K,V> firstEntry();
180    
181      /**      /**
182       * Returns a key-value mapping associated with the greatest       * Returns a key-value mapping associated with the greatest
183       * key in this map, or <tt>null</tt> if the map is empty.       * key in this map, or {@code null} if the map is empty.
184       *       *
185       * @return an entry with the greatest key,       * @return an entry with the greatest key,
186       *         or <tt>null</tt> if this map is empty       *         or {@code null} if this map is empty
187       */       */
188      Map.Entry<K,V> lastEntry();      Map.Entry<K,V> lastEntry();
189    
190      /**      /**
191       * Removes and returns a key-value mapping associated with       * Removes and returns a key-value mapping associated with
192       * the least key in this map, or <tt>null</tt> if the map is empty.       * the least key in this map, or {@code null} if the map is empty.
193       *       *
194       * @return the removed first entry of this map,       * @return the removed first entry of this map,
195       *         or <tt>null</tt> if this map is empty       *         or {@code null} if this map is empty
196       */       */
197      Map.Entry<K,V> pollFirstEntry();      Map.Entry<K,V> pollFirstEntry();
198    
199      /**      /**
200       * Removes and returns a key-value mapping associated with       * Removes and returns a key-value mapping associated with
201       * the greatest key in this map, or <tt>null</tt> if the map is empty.       * the greatest key in this map, or {@code null} if the map is empty.
202       *       *
203       * @return the removed last entry of this map,       * @return the removed last entry of this map,
204       *         or <tt>null</tt> if this map is empty       *         or {@code null} if this map is empty
205       */       */
206      Map.Entry<K,V> pollLastEntry();      Map.Entry<K,V> pollLastEntry();
207    
208      /**      /**
209       * Returns a {@link Set} view of the keys contained in this map.       * Returns a {@link NavigableMap} view of the mappings contained in this
210         * map in descending order.  The descending map is backed by this map, so
211         * changes to the map are reflected in the descending set, and vice-versa.
212         * If either map is modified while an iteration over a collection view of
213         * the other map is in progress (except through the iterator's own
214         * {@code remove} operation), the results of the iteration are undefined.
215         *
216         * @return a navigable map view of the mappings contained in this map,
217         *     sorted in descending order
218         */
219        NavigableMap<K,V> descendingMap();
220    
221        /**
222         * Returns a navigable set view of the keys contained in this navigable
223         * map.  The set is backed by the map, so changes to the map are reflected
224         * in the set, and vice-versa.  If the map is modified while an iteration
225         * over the set is in progress (except through the iterator's own
226         * {@code remove} operation), the results of the iteration are undefined.
227         * The set supports element removal, which removes the corresponding
228         * mapping from the map, via the {@code Iterator.remove},
229         * {@code Set.remove}, {@code removeAll} {@code retainAll}, and
230         * {@code clear} operations.  It does not support the {@code add} or
231         * {@code addAll} operations.
232         *
233         * @return a navigable set view of the keys contained in this navigable map
234         */
235        NavigableSet<K> navigableKeySet();
236    
237        /**
238         * Returns a {@link NavigableSet} view of the keys contained in this map.
239       * The set's iterator returns the keys in descending order.       * The set's iterator returns the keys in descending order.
240       * The set is backed by the map, so changes to the map are       * The set is backed by the map, so changes to the map are
241       * reflected in the set, and vice-versa.  If the map is modified       * reflected in the set, and vice-versa.  If the map is modified
# Line 223  Line 251 
251       * @return a set view of the keys contained in this map, sorted in       * @return a set view of the keys contained in this map, sorted in
252       *         descending order       *         descending order
253       */       */
254      Set<K> descendingKeySet();      NavigableSet<K> descendingKeySet();
   
     /**  
      * Returns a {@link Set} view of the mappings contained in this map.  
      * The set's iterator returns the entries in descending key order.  
      * The set is backed by the map, so changes to the map are  
      * reflected in the set, and vice-versa.  If the map is modified  
      * while an iteration over the set is in progress (except through  
      * the iterator's own <tt>remove</tt> operation, or through the  
      * <tt>setValue</tt> operation on a map entry returned by the  
      * iterator) the results of the iteration are undefined.  The set  
      * supports element removal, which removes the corresponding  
      * mapping from the map, via the <tt>Iterator.remove</tt>,  
      * <tt>Set.remove</tt>, <tt>removeAll</tt>, <tt>retainAll</tt> and  
      * <tt>clear</tt> operations.  It does not support the  
      * <tt>add</tt> or <tt>addAll</tt> operations.  
      *  
      * @return a set view of the mappings contained in this map,  
      *         sorted in descending key order  
      */  
     Set<Map.Entry<K, V>> descendingEntrySet();  
255    
256      /**      /**
257       * Returns a view of the portion of this map whose keys range from       * Returns a view of the portion of this map whose keys range from
258       * <tt>fromKey</tt>, inclusive, to <tt>toKey</tt>, exclusive.  (If       * {@code fromKey} to {@code toKey}.  If {@code fromKey} and
259       * <tt>fromKey</tt> and <tt>toKey</tt> are equal, the returned map       * {@code toKey} are equal, the returned map is empty unless
260       * is empty.)  The returned map is backed by this map, so changes       * {@code fromExclusive} and {@code toExclusive} are both true.  The
261       * in the returned map are reflected in this map, and vice-versa.       * returned map is backed by this map, so changes in the returned map are
262       * The returned map supports all optional map operations that this       * reflected in this map, and vice-versa.  The returned map supports all
263       * map supports.       * optional map operations that this map supports.
      *  
      * <p>The returned map will throw an <tt>IllegalArgumentException</tt>  
      * on an attempt to insert a key outside its range.  
264       *       *
265       * @param fromKey low endpoint (inclusive) of the keys in the returned map       * <p>The returned map will throw an {@code IllegalArgumentException}
266       * @param toKey high endpoint (exclusive) of the keys in the returned map       * on an attempt to insert a key outside of its range, or to construct a
267         * submap either of whose endpoints lie outside its range.
268         *
269         * @param fromKey low endpoint of the keys in the returned map
270         * @param fromInclusive true if the low endpoint ({@code fromKey}) is
271         *        to be included in the the returned view
272         * @param toKey high endpoint of the keys in the returned map
273         * @param toInclusive true if the high endpoint ({@code toKey}) is
274         *        to be included in the the returned view
275       * @return a view of the portion of this map whose keys range from       * @return a view of the portion of this map whose keys range from
276       *         <tt>fromKey</tt>, inclusive, to <tt>toKey</tt>, exclusive       *         {@code fromKey} to {@code toKey}
277       * @throws ClassCastException if <tt>fromKey</tt> and <tt>toKey</tt>       * @throws ClassCastException if {@code fromKey} and {@code toKey}
278       *         cannot be compared to one another using this map's comparator       *         cannot be compared to one another using this map's comparator
279       *         (or, if the map has no comparator, using natural ordering).       *         (or, if the map has no comparator, using natural ordering).
280       *         Implementations may, but are not required to, throw this       *         Implementations may, but are not required to, throw this
281       *         exception if <tt>fromKey</tt> or <tt>toKey</tt>       *         exception if {@code fromKey} or {@code toKey}
282       *         cannot be compared to keys currently in the map.       *         cannot be compared to keys currently in the map.
283       * @throws NullPointerException if <tt>fromKey</tt> or <tt>toKey</tt>       * @throws NullPointerException if {@code fromKey} or {@code toKey}
284       *         is null and this map does not permit null keys       *         is null and this map does not permit null keys
285       * @throws IllegalArgumentException if <tt>fromKey</tt> is greater than       * @throws IllegalArgumentException if {@code fromKey} is greater than
286       *         <tt>toKey</tt>; or if this map itself has a restricted       *         {@code toKey}; or if this map itself has a restricted
287       *         range, and <tt>fromKey</tt> or <tt>toKey</tt> lies       *         range, and {@code fromKey} or {@code toKey} lies
288       *         outside the bounds of the range       *         outside the bounds of the range
289       */       */
290      NavigableMap<K,V> navigableSubMap(K fromKey, K toKey);      NavigableMap<K,V> navigableSubMap(K fromKey, boolean fromInclusive,
291                                          K toKey,   boolean toInclusive);
292    
293      /**      /**
294       * Returns a view of the portion of this map whose keys are       * Returns a view of the portion of this map whose keys are less than (or
295       * strictly less than <tt>toKey</tt>.  The returned map is backed       * equal to, if {@code inclusive} is true) {@code toKey}.  The returned
296       * by this map, so changes in the returned map are reflected in       * map is backed by this map, so changes in the returned map are reflected
297       * this map, and vice-versa.  The returned map supports all       * in this map, and vice-versa.  The returned map supports all optional
298       * optional map operations that this map supports.       * map operations that this map supports.
299       *       *
300       * <p>The returned map will throw an <tt>IllegalArgumentException</tt>       * <p>The returned map will throw an {@code IllegalArgumentException}
301       * on an attempt to insert a key outside its range.       * on an attempt to insert a key outside its range.
302       *       *
303       * @param toKey high endpoint (exclusive) of the keys in the returned map       * @param toKey high endpoint of the keys in the returned map
304       * @return a view of the portion of this map whose keys are strictly       * @param inclusive true if the high endpoint ({@code toKey}) is
305       *         less than <tt>toKey</tt>       *        to be included in the the returned view
306       * @throws ClassCastException if <tt>toKey</tt> is not compatible       * @return a view of the portion of this map whose keys are less than
307         *         (or equal to, if {@code inclusive} is true) {@code toKey}
308         * @throws ClassCastException if {@code toKey} is not compatible
309       *         with this map's comparator (or, if the map has no comparator,       *         with this map's comparator (or, if the map has no comparator,
310       *         if <tt>toKey</tt> does not implement {@link Comparable}).       *         if {@code toKey} does not implement {@link Comparable}).
311       *         Implementations may, but are not required to, throw this       *         Implementations may, but are not required to, throw this
312       *         exception if <tt>toKey</tt> cannot be compared to keys       *         exception if {@code toKey} cannot be compared to keys
313       *         currently in the map.       *         currently in the map.
314       * @throws NullPointerException if <tt>toKey</tt> is null       * @throws NullPointerException if {@code toKey} is null
315       *         and this map does not permit null keys       *         and this map does not permit null keys
316       * @throws IllegalArgumentException if this map itself has a       * @throws IllegalArgumentException if this map itself has a
317       *         restricted range, and <tt>toKey</tt> lies outside the       *         restricted range, and {@code toKey} lies outside the
318       *         bounds of the range       *         bounds of the range
319       */       */
320      NavigableMap<K,V> navigableHeadMap(K toKey);      NavigableMap<K,V> navigableHeadMap(K toKey, boolean inclusive);
321    
322      /**      /**
323       * Returns a view of the portion of this map whose keys are       * Returns a view of the portion of this map whose keys are greater than (or
324       * greater than or equal to <tt>fromKey</tt>.  The returned map is       * equal to, if {@code inclusive} is true) {@code fromKey}.  The returned
325       * backed by this map, so changes in the returned map are       * map is backed by this map, so changes in the returned map are reflected
326       * reflected in this map, and vice-versa.  The returned map       * in this map, and vice-versa.  The returned map supports all optional
327       * supports all optional map operations that this map supports.       * map operations that this map supports.
328       *       *
329       * <p>The returned map will throw an <tt>IllegalArgumentException</tt>       * <p>The returned map will throw an {@code IllegalArgumentException}
330       * on an attempt to insert a key outside its range.       * on an attempt to insert a key outside its range.
331       *       *
332       * @param fromKey low endpoint (inclusive) of the keys in the returned map       * @param fromKey low endpoint of the keys in the returned map
333       * @return a view of the portion of this map whose keys are greater       * @param inclusive true if the low endpoint ({@code fromKey}) is
334       *         than or equal to <tt>fromKey</tt>       *        to be included in the the returned view
335       * @throws ClassCastException if <tt>fromKey</tt> is not compatible       * @return a view of the portion of this map whose keys are greater than
336         *         (or equal to, if {@code inclusive} is true) {@code fromKey}
337         * @throws ClassCastException if {@code fromKey} is not compatible
338       *         with this map's comparator (or, if the map has no comparator,       *         with this map's comparator (or, if the map has no comparator,
339       *         if <tt>fromKey</tt> does not implement {@link Comparable}).       *         if {@code fromKey} does not implement {@link Comparable}).
340       *         Implementations may, but are not required to, throw this       *         Implementations may, but are not required to, throw this
341       *         exception if <tt>fromKey</tt> cannot be compared to keys       *         exception if {@code fromKey} cannot be compared to keys
342       *         currently in the map.       *         currently in the map.
343       * @throws NullPointerException if <tt>fromKey</tt> is null       * @throws NullPointerException if {@code fromKey} is null
344       *         and this map does not permit null keys       *         and this map does not permit null keys
345       * @throws IllegalArgumentException if this map itself has a       * @throws IllegalArgumentException if this map itself has a
346       *         restricted range, and <tt>fromKey</tt> lies outside the       *         restricted range, and {@code fromKey} lies outside the
347       *         bounds of the range       *         bounds of the range
348       */       */
349      NavigableMap<K,V> navigableTailMap(K fromKey);      NavigableMap<K,V> navigableTailMap(K fromKey, boolean inclusive);
350  }  }

Legend:
Removed from v.1.13  
changed lines
  Added in v.1.14

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8