RegexpKeyedMap
http://wiki.apache.org/jakarta/RegexpKeyedMap
RegexHashMap
https://heideltime.googlecode.com/hg-history/a354341d349e75262884706b830f237fd9eeb269/src/de/unihd/dbs/uima/annotator/heideltime/resources/RegexHashMap.java
原理基本都是get的时候去遍历key值，逐个正则匹配，效率不高。
nginx有支持通配符的实现，有时间可以了解下实现。
RegexHashMap
package de.unihd.dbs.uima.annotator.heideltime.resources; import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern; /**
* Implements a HashMap extended with regular expression keys and caching functionality.
*
* @author Julian Zell
*
*/
public class RegexHashMap<T> implements Map<String, T> { private HashMap<String, T> container = new HashMap<String, T>();
private HashMap<String, T> cache = new HashMap<String, T>(); /**
* clears both the container and the cache hashmaps
*/
public void clear() {
container.clear();
cache.clear();
} /**
* checks whether the cache or container contain a specific key, then evaluates the
* container's keys as regexes and checks whether they match the specific key.
*/
public boolean containsKey(Object key) {
// the key is a direct hit from our cache
if(cache.containsKey(key))
return true;
// the key is a direct hit from our hashmap
if(container.containsKey(key))
return true; // check if the requested key is a matching string of a regex key from our container
Iterator<String> regexKeys = container.keySet().iterator();
while(regexKeys.hasNext()) {
if(Pattern.matches(regexKeys.next(), (String) key))
return true;
} // if the three previous tests yield no result, the key does not exist
return false;
} /**
* checks whether a specific value is container within either container or cache
*/
public boolean containsValue(Object value) {
// the value is a direct hit from our cache
if(cache.containsValue(value))
return true;
// the value is a direct hit from our hashmap
if(container.containsValue(value))
return true; // otherwise, the value isn't within this object
return false;
} /**
* returns a merged entryset containing within both the container and cache entrysets
*/
public Set<Entry<String, T>> entrySet() {
// prepare the container
HashSet<Entry<String, T>> set = new HashSet<Entry<String, T>>();
// add the set from our container
set.addAll(container.entrySet());
// add the set from our cache
set.addAll(cache.entrySet()); return set;
} /**
* checks whether the requested key has a direct match in either cache or container, and if it
* doesn't, also evaluates the container's keyset as regexes to match against the input key and
* if any of those methods yield a value, returns that value
* if a value is found doing regex evaluation, use that regex-key's match as a non-regex
* key with the regex's value to form a new entry in the cache.
*/
public T get(Object key) {
// output for requested key null is the value null; normal Map behavior
if(key == null) return null; T result = null;
if((result = cache.get(key)) != null) {
// if the requested key maps to a value in the cache
return result;
} else if((result = container.get(key)) != null) {
// if the requested key maps to a value in the container
return result;
} else {
// check if the requested key is a matching string of a regex key from our container
Iterator<Entry<String, T>> regexKeys = container.entrySet().iterator();
while(regexKeys.hasNext()) {
// prepare current entry
Entry<String, T> entry = regexKeys.next();
// check if the key is a regex matching the input key
if(Pattern.matches(entry.getKey(), (String) key)) {
putCache((String) key, entry.getValue());
return entry.getValue();
}
}
} // no value for the given key was found in any of container/cache/regexkey-container
return null;
} /**
* checks whether both container and cache are empty
*/
public boolean isEmpty() {
return container.isEmpty() && cache.isEmpty();
} /**
* returns the keysets of both the container and cache hashmaps
*/
public Set<String> keySet() {
// prepare container
HashSet<String> set = new HashSet<String>();
// add container keys
set.addAll(container.keySet());
// add cache keys
set.addAll(cache.keySet()); return set;
} /**
* associates a key with a value in the container hashmap
*/
public T put(String key, T value) {
return container.put(key, value);
} /**
* associates a key with a value in the cache hashmap.
* @param key Key to map from
* @param value Value to map to
* @return previous value associated with the key, or null if unassociated before
*/
public T putCache(String key, T value) {
return cache.put(key, value);
} /**
* adds a map to the container
*/
public void putAll(Map<? extends String, ? extends T> m) {
container.putAll(m);
} /**
* removes a specific key's association from the container
*/
public T remove(Object key) {
return container.remove(key);
} /**
* returns the combined size of container and cache
*/
public int size() {
return container.size() + cache.size();
} /**
* returns the combined collection of both the values of the container as well as
* the cache.
*/
public Collection<T> values() {
// prepare set
HashSet<T> set = new HashSet<T>();
// add all container values
set.addAll(container.values());
// add all cache values
set.addAll(cache.values()); return set;
}
}
RegexpKeyedMap
package org.apache.regexp.collections; import java.util.HashMap;
import java.util.Iterator; import org.apache.regexp.RE;
import org.apache.regexp.RESyntaxException; /**
* This map implementation uses a hashmap as the underlying storage.
* Note that the keySet() method will return a set of regular expressions rather than actual keys.
* The put() method uses a regexp as a key.
* The get() method gets any value that matches one of the regexps. If there is more than one matching regexp, the first one
* encountered is returned - and hence could be indeterminate!
*
* @author Manik Surtani
*
*/
public class RegexpKeyedMap extends HashMap
{
public Object put(Object key, Object value)
{
if (key instanceof String)
return super.put(key, value);
else
throw new RuntimeException("RegexpKeyedMap - only accepts Strings as keys.");
} /**
* The key passed in should always be a String. The map will return the first element whose key, treated as a regular expression, matches the key passed in
* NOTE: It is possible for this map to have more than one return value, for example, if a key is passed into get() which matches more than one regexp.
*
* E.g., consider the following keys in the map - '[A-Za-z]*' and 'Hello'. Passing in 'Hello' as a key to the get() method would match either of the regexps,
* and whichever apears first in the map (which is indeterminate) will be returned.
*
*/
public Object get(Object key)
{
Iterator regexps = keySet().iterator();
String keyString;
Object result = null; String stringToMatch = cleanKey( key ); while (regexps.hasNext())
{
keyString = regexps.next().toString();
try
{
RE regexp = new RE(keyString);
if (regexp.match(stringToMatch))
{
result = super.get(keyString);
break;
}
}
catch (RESyntaxException e)
{
// invalid regexp. ignore?
}
}
return result;
} /**
* Strip any 'dirty' chars from the key we are searching for,
* otherwise we end up with funny results from the RE
*
* @param obj
* @return
*/
private String cleanKey( Object obj )
{
String retVal = obj.toString(); // remove any '^' from start of key - prevents the RE from matching !?!?
return ( retVal.charAt(0) == '^' ) ? retVal.substring(1) : retVal;
} }