A Regular Expression HashMap Implementation in Java

Below is an implementation of a Regular Expression HashMap. It works with key-value pairs which the key is a regular expression. It compiles the key (regular expression) while adding (i.e. putting), so there is no compile time while getting. Once getting an element, you don't give regular expression; you give any possible value of a regular expression. 

As a result, this behaviour provides to map numerous values of a regular expression into the same value. The class does not depend to any external libraries, uses only default java.util. So, it will be used simply when a behaviour like that is required. 

1. import java.util.ArrayList;
2. import java.util.HashMap;
3. import java.util.regex.Pattern;
5. /**
6.  * This class is an extended version of Java HashMap
7.  * and includes pattern-value lists which are used to
8.  * evaluate regular expression values. If given item
9.  * is a regular expression, it is saved in regexp lists.
10.  * If requested item matches with a regular expression,
11.  * its value is get from regexp lists.
12.  *
13.  * @author cb
14.  *
15.  * @param <K> : Key of the map item.
16.  * @param <V> : Value of the map item.
17.  */
18. public class RegExHashMap<K, V> extends HashMap<K, V> {
20.     // list of regular expression patterns
21.     private ArrayList<Pattern> regExPatterns = new ArrayList<Pattern>();
22.     // list of regular expression values which match patterns
23.     private ArrayList<V> regExValues = new ArrayList<V>();
25.     /**
26.      * Compile regular expression and add it to the regexp list as key.
27.      */
28.     @Override
29.     public V put(K key, V value) {
30.        
31.         regExPatterns.add(Pattern.compile(key.toString()));
32.         regExValues.add(value);
33.         return value;
34.     }
36.     /**
37.      * If requested value matches with a regular expression,
38.      * returns it from regexp lists.
39.      */
40.     @Override
41.     public V get(Object key) {
43.         CharSequence cs = new String(key.toString());
44.        
45.         for (int i = 0; i < regExPatterns.size(); i++) {
46.             if (regExPatterns.get(i).matcher(cs).matches()) {
47.                
48.                 return regExValues.get(i);
49.             }
50.         }
51.         return super.get(key);
52.     }
53. }