Question

Is it possible to obtain values that match a range of keys in Java Map. Suppose I have,

Map<Key,Value> //size 10,000
Key   - 9.0, 9.1, 9.5, 4.2, 4.3, 6.1, 6.6
Value - 10 , 20 , 30 , 40 , 20 , 60 , 10  

ArrayList alMatch = {1.0,4.0,6.0}

In this case, for the value 4.0 I want to get 40(key 4.2) and 20(key 4.3). So I want to get all the values mapping to the key 5.0 >= key>=4.0 in the Map. Is it possible to do this through Map or similar data structure.

The size of the map is huge. Or is there any other better way to achieve the same with minimum complexity.

Answer 1

You can use an implementation of NavigableMap (example TreeMap). This method in particular might interest you :

/**
 * Returns a view of the portion of this map whose keys range from
 * {@code fromKey} to {@code toKey}.  If {@code fromKey} and
 * {@code toKey} are equal, the returned map is empty unless
 * {@code fromExclusive} and {@code toExclusive} are both true.  The
 * returned map is backed by this map, so changes in the returned map are
 * reflected in this map, and vice-versa.  The returned map supports all
 * optional map operations that this map supports.
 *
 * <p>The returned map will throw an {@code IllegalArgumentException}
 * on an attempt to insert a key outside of its range, or to construct a
 * submap either of whose endpoints lie outside its range.
 *
 * @param fromKey low endpoint of the keys in the returned map
 * @param fromInclusive {@code true} if the low endpoint
 *        is to be included in the returned view
 * @param toKey high endpoint of the keys in the returned map
 * @param toInclusive {@code true} if the high endpoint
 *        is to be included in the returned view
 * @return a view of the portion of this map whose keys range from
 *         {@code fromKey} to {@code toKey}
 * @throws ClassCastException if {@code fromKey} and {@code toKey}
 *         cannot be compared to one another using this map's comparator
 *         (or, if the map has no comparator, using natural ordering).
 *         Implementations may, but are not required to, throw this
 *         exception if {@code fromKey} or {@code toKey}
 *         cannot be compared to keys currently in the map.
 * @throws NullPointerException if {@code fromKey} or {@code toKey}
 *         is null and this map does not permit null keys
 * @throws IllegalArgumentException if {@code fromKey} is greater than
 *         {@code toKey}; or if this map itself has a restricted
 *         range, and {@code fromKey} or {@code toKey} lies
 *         outside the bounds of the range
 */
NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                         K toKey,   boolean toInclusive);

The underlying data structure for a TreeMap is red and black tree and all the complexity is abstracted by the NavigableMap interface thereby making it quite simple to use.