blocks|key|431080|text|map的键集没有特殊的结构，所以我认为您无论如何都必须检查每个键。所以你找不到比单次循环更快的方法...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|431081|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

map's keyset has no a special structure so I think you have to check each of the keys anyway. So you can't find a way which will be faster than a single loop...

blocks|key|212722|text|我最近写了一个MapFilter就是为了满足这样的需要。你也可以过滤过滤后的地图，这让它变得非常有用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|212723|如果您的表达式有像"some.byte“和"some.string”这样的公共根，那么首先按公共根过滤(“Some.在这种情况下)将为您节省大量时间。有关一些简单的示例，请参阅main。|212724|请注意，对过滤后的地图进行更改会更改底层地图。|212725|public+class+MapFilter<T>+implements+Map<String,+T>+{

++++//+The+enclosed+map+--+could+also+be+a+MapFilter.
++++final+private+Map<String,+T>+map;

++++//+Use+a+TreeMap+for+predictable+iteration+order.
++++//+Store+Map.Entry+to+reflect+changes+down+into+the+underlying+map.
++++//+The+Key+is+the+shortened+string.+The+entry.key+is+the+full+string.
++++final+private+Map<String,+Map.Entry<String,+T>>+entries+=+new+TreeMap<>();
++++//+The+prefix+they+are+looking+for+in+this+map.
++++final+private+String+prefix;

++++public+MapFilter(Map<String,+T>+map,+String+prefix)+{
++++++++//+Store+my+backing+map.
++++++++this.map+=+map;
++++++++//+Record+my+prefix.
++++++++this.prefix+=+prefix;
++++++++//+Build+my+entries.
++++++++rebuildEntries();
++++}

++++public+MapFilter(Map<String,+T>+map)+{
++++++++this(map,+"");
++++}

++++private+synchronized+void+rebuildEntries()+{
++++++++//+Start+empty.
++++++++entries.clear();
++++++++//+Build+my+entry+set.
++++++++for+(Map.Entry<String,+T>+e+:+map.entrySet())+{
++++++++++++String+key+=+e.getKey();
++++++++++++//+Retain+each+one+that+starts+with+the+specified+prefix.
++++++++++++if+(key.startsWith(prefix))+{
++++++++++++++++//+Key+it+on+the+remainder.
++++++++++++++++String+k+=+key.substring(prefix.length());
++++++++++++++++//+Entries+k+always+contains+the+LAST+occurrence+if+there+are+multiples.
++++++++++++++++entries.put(k,+e);
++++++++++++}
++++++++}

++++}

++++@Override
++++public+String+toString()+{
++++++++return+"MapFilter("+%2B+prefix+%2B+")+of+"+%2B+map+%2B+"+containing+"+%2B+entrySet();
++++}

++++//+Constructor+from+a+properties+file.
++++public+MapFilter(Properties+p,+String+prefix)+{
++++++++//+Properties+extends+HashTable<Object,Object>+so+it+implements+Map.
++++++++//+I+need+Map<String,T>+so+I+wrap+it+in+a+HashMap+for+simplicity.
++++++++//+Java-8+breaks+if+we+use+diamond+inference.
++++++++this(new+HashMap<>((Map)+p),+prefix);
++++}

++++//+Helper+to+fast+filter+the+map.
++++public+MapFilter<T>+filter(String+prefix)+{
++++++++//+Wrap+me+in+a+new+filter.
++++++++return+new+MapFilter<>(this,+prefix);
++++}

++++//+Count+my+entries.
++++@Override
++++public+int+size()+{
++++++++return+entries.size();
++++}

++++//+Are+we+empty.
++++@Override
++++public+boolean+isEmpty()+{
++++++++return+entries.isEmpty();
++++}

++++//+Is+this+key+in+me?
++++@Override
++++public+boolean+containsKey(Object+key)+{
++++++++return+entries.containsKey(key);
++++}

++++//+Is+this+value+in+me.
++++@Override
++++public+boolean+containsValue(Object+value)+{
++++++++//+Walk+the+values.
++++++++for+(Map.Entry<String,+T>+e+:+entries.values())+{
++++++++++++if+(value.equals(e.getValue()))+{
++++++++++++++++//+Its+there!
++++++++++++++++return+true;
++++++++++++}
++++++++}
++++++++return+false;
++++}

++++//+Get+the+referenced+value+-+if+present.
++++@Override
++++public+T+get(Object+key)+{
++++++++return+get(key,+null);
++++}

++++//+Get+the+referenced+value+-+if+present.
++++public+T+get(Object+key,+T+dflt)+{
++++++++Map.Entry<String,+T>+e+=+entries.get((String)+key);
++++++++return+e+!=+null+?+e.getValue()+:+dflt;
++++}

++++//+Add+to+the+underlying+map.
++++@Override
++++public+T+put(String+key,+T+value)+{
++++++++T+old+=+null;
++++++++//+Do+I+have+an+entry+for+it+already?
++++++++Map.Entry<String,+T>+entry+=+entries.get(key);
++++++++//+Was+it+already+there?
++++++++if+(entry+!=+null)+{
++++++++++++//+Yes.+Just+update+it.
++++++++++++old+=+entry.setValue(value);
++++++++}+else+{
++++++++++++//+Add+it+to+the+map.
++++++++++++map.put(prefix+%2B+key,+value);
++++++++++++//+Rebuild.
++++++++++++rebuildEntries();
++++++++}
++++++++return+old;
++++}

++++//+Get+rid+of+that+one.
++++@Override
++++public+T+remove(Object+key)+{
++++++++//+Do+I+have+an+entry+for+it?
++++++++Map.Entry<String,+T>+entry+=+entries.get((String)+key);
++++++++if+(entry+!=+null)+{
++++++++++++entries.remove(key);
++++++++++++//+Change+the+underlying+map.
++++++++++++return+map.remove(prefix+%2B+key);
++++++++}
++++++++return+null;
++++}

++++//+Add+all+of+them.
++++@Override
++++public+void+putAll(Map<?+extends+String,+?+extends+T>+m)+{
++++++++for+(Map.Entry<?+extends+String,+?+extends+T>+e+:+m.entrySet())+{
++++++++++++put(e.getKey(),+e.getValue());
++++++++}
++++}

++++//+Clear+everything+out.
++++@Override
++++public+void+clear()+{
++++++++//+Just+remove+mine.
++++++++//+This+does+not+clear+the+underlying+map+-+perhaps+it+should+remove+the+filtered+entries.
++++++++for+(String+key+:+entries.keySet())+{
++++++++++++map.remove(prefix+%2B+key);
++++++++}
++++++++entries.clear();
++++}

++++@Override
++++public+Set<String>+keySet()+{
++++++++return+entries.keySet();
++++}

++++@Override
++++public+Collection<T>+values()+{
++++++++//+Roll+them+all+out+into+a+new+ArrayList.
++++++++List<T>+values+=+new+ArrayList<>();
++++++++for+(Map.Entry<String,+T>+v+:+entries.values())+{
++++++++++++values.add(v.getValue());
++++++++}
++++++++return+values;
++++}

++++@Override
++++public+Set<Map.Entry<String,+T>>+entrySet()+{
++++++++//+Roll+them+all+out+into+a+new+TreeSet.
++++++++Set<Map.Entry<String,+T>>+entrySet+=+new+TreeSet<>();
++++++++for+(Map.Entry<String,+Map.Entry<String,+T>>+v+:+entries.entrySet())+{
++++++++++++entrySet.add(new+Entry<>(v));
++++++++}
++++++++return+entrySet;
++++}

++++/**
+++++*+An+entry.
+++++*
+++++*+@param+<T>+The+type+of+the+value.
+++++*/
++++private+static+class+Entry<T>+implements+Map.Entry<String,+T>,+Comparable<Entry<T>>+{

++++++++//+Note+that+entry+in+the+entry+is+an+entry+in+the+underlying+map.

++++++++private+final+Map.Entry<String,+Map.Entry<String,+T>>+entry;

++++++++Entry(Map.Entry<String,+Map.Entry<String,+T>>+entry)+{
++++++++++++this.entry+=+entry;
++++++++}

++++++++@Override
++++++++public+String+getKey()+{
++++++++++++return+entry.getKey();
++++++++}

++++++++@Override
++++++++public+T+getValue()+{
++++++++++++//+Remember+that+the+value+is+the+entry+in+the+underlying+map.
++++++++++++return+entry.getValue().getValue();
++++++++}

++++++++@Override
++++++++public+T+setValue(T+newValue)+{
++++++++++++//+Remember+that+the+value+is+the+entry+in+the+underlying+map.
++++++++++++return+entry.getValue().setValue(newValue);
++++++++}

++++++++@Override
++++++++public+boolean+equals(Object+o)+{
++++++++++++if+(!(o+instanceof+Entry))+{
++++++++++++++++return+false;
++++++++++++}
++++++++++++Entry+e+=+(Entry)+o;
++++++++++++return+getKey().equals(e.getKey())+&&+getValue().equals(e.getValue());
++++++++}

++++++++@Override
++++++++public+int+hashCode()+{
++++++++++++return+getKey().hashCode()+%5E+getValue().hashCode();
++++++++}

++++++++@Override
++++++++public+String+toString()+{
++++++++++++return+getKey()+%2B+"="+%2B+getValue();
++++++++}

++++++++@Override
++++++++public+int+compareTo(Entry<T>+o)+{
++++++++++++return+getKey().compareTo(o.getKey());
++++++++}

++++}

++++//+Simple+tests.
++++public+static+void+main(String[]+args)+{
++++++++String[]+samples+=+{
++++++++++++++++"Some.For.Me",
++++++++++++++++"Some.For.You",
++++++++++++++++"Some.More",
++++++++++++++++"Yet.More"};
++++++++Map+map+=+new+HashMap();
++++++++for+(String+s+:+samples)+{
++++++++++++map.put(s,+s);
++++++++}
++++++++Map+all+=+new+MapFilter(map);
++++++++Map+some+=+new+MapFilter(map,+"Some.");
++++++++Map+someFor+=+new+MapFilter(some,+"For.");
++++++++System.out.println("All:+"+%2B+all);
++++++++System.out.println("Some:+"+%2B+some);
++++++++System.out.println("Some.For:+"+%2B+someFor);

++++++++Properties+props+=+new+Properties();
++++++++props.setProperty("namespace.prop1",+"value1");
++++++++props.setProperty("namespace.prop2",+"value2");
++++++++props.setProperty("namespace.iDontKnowThisNameAtCompileTime",+"anothervalue");
++++++++props.setProperty("someStuff.morestuff",+"stuff");
++++++++Map<String,+String>+filtered+=+new+MapFilter(props,+"namespace.");
++++++++System.out.println("namespace+props+"+%2B+filtered);
++++}

}|code-block|syntax|javascript|212726|entityMap^0|7|9|0|2G|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|W|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|X|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

I wrote a <code>MapFilter</code> recently for just such a need. You can also filter filtered maps which makes then really useful.

If your expressions have common roots like "some.byte" and "some.string" then filtering by the common root first ("some." in this case) will save you a great deal of time. See <code>main</code> for some trivial examples.

Note that making changes to the filtered map changes the underlying map.

<pre><code>public class MapFilter&lt;T&gt; implements Map&lt;String, T&gt; {

 // The enclosed map -- could also be a MapFilter.
 final private Map&lt;String, T&gt; map;

 // Use a TreeMap for predictable iteration order.
 // Store Map.Entry to reflect changes down into the underlying map.
 // The Key is the shortened string. The entry.key is the full string.
 final private Map&lt;String, Map.Entry&lt;String, T&gt;&gt; entries = new TreeMap&lt;&gt;();
 // The prefix they are looking for in this map.
 final private String prefix;

 public MapFilter(Map&lt;String, T&gt; map, String prefix) {
 // Store my backing map.
 this.map = map;
 // Record my prefix.
 this.prefix = prefix;
 // Build my entries.
 rebuildEntries();
 }

 public MapFilter(Map&lt;String, T&gt; map) {
 this(map, "");
 }

 private synchronized void rebuildEntries() {
 // Start empty.
 entries.clear();
 // Build my entry set.
 for (Map.Entry&lt;String, T&gt; e : map.entrySet()) {
 String key = e.getKey();
 // Retain each one that starts with the specified prefix.
 if (key.startsWith(prefix)) {
 // Key it on the remainder.
 String k = key.substring(prefix.length());
 // Entries k always contains the LAST occurrence if there are multiples.
 entries.put(k, e);
 }
 }

 }

 @Override
 public String toString() {
 return "MapFilter(" + prefix + ") of " + map + " containing " + entrySet();
 }

 // Constructor from a properties file.
 public MapFilter(Properties p, String prefix) {
 // Properties extends HashTable&lt;Object,Object&gt; so it implements Map.
 // I need Map&lt;String,T&gt; so I wrap it in a HashMap for simplicity.
 // Java-8 breaks if we use diamond inference.
 this(new HashMap&lt;&gt;((Map) p), prefix);
 }

 // Helper to fast filter the map.
 public MapFilter&lt;T&gt; filter(String prefix) {
 // Wrap me in a new filter.
 return new MapFilter&lt;&gt;(this, prefix);
 }

 // Count my entries.
 @Override
 public int size() {
 return entries.size();
 }

 // Are we empty.
 @Override
 public boolean isEmpty() {
 return entries.isEmpty();
 }

 // Is this key in me?
 @Override
 public boolean containsKey(Object key) {
 return entries.containsKey(key);
 }

 // Is this value in me.
 @Override
 public boolean containsValue(Object value) {
 // Walk the values.
 for (Map.Entry&lt;String, T&gt; e : entries.values()) {
 if (value.equals(e.getValue())) {
 // Its there!
 return true;
 }
 }
 return false;
 }

 // Get the referenced value - if present.
 @Override
 public T get(Object key) {
 return get(key, null);
 }

 // Get the referenced value - if present.
 public T get(Object key, T dflt) {
 Map.Entry&lt;String, T&gt; e = entries.get((String) key);
 return e != null ? e.getValue() : dflt;
 }

 // Add to the underlying map.
 @Override
 public T put(String key, T value) {
 T old = null;
 // Do I have an entry for it already?
 Map.Entry&lt;String, T&gt; entry = entries.get(key);
 // Was it already there?
 if (entry != null) {
 // Yes. Just update it.
 old = entry.setValue(value);
 } else {
 // Add it to the map.
 map.put(prefix + key, value);
 // Rebuild.
 rebuildEntries();
 }
 return old;
 }

 // Get rid of that one.
 @Override
 public T remove(Object key) {
 // Do I have an entry for it?
 Map.Entry&lt;String, T&gt; entry = entries.get((String) key);
 if (entry != null) {
 entries.remove(key);
 // Change the underlying map.
 return map.remove(prefix + key);
 }
 return null;
 }

 // Add all of them.
 @Override
 public void putAll(Map&lt;? extends String, ? extends T&gt; m) {
 for (Map.Entry&lt;? extends String, ? extends T&gt; e : m.entrySet()) {
 put(e.getKey(), e.getValue());
 }
 }

 // Clear everything out.
 @Override
 public void clear() {
 // Just remove mine.
 // This does not clear the underlying map - perhaps it should remove the filtered entries.
 for (String key : entries.keySet()) {
 map.remove(prefix + key);
 }
 entries.clear();
 }

 @Override
 public Set&lt;String&gt; keySet() {
 return entries.keySet();
 }

 @Override
 public Collection&lt;T&gt; values() {
 // Roll them all out into a new ArrayList.
 List&lt;T&gt; values = new ArrayList&lt;&gt;();
 for (Map.Entry&lt;String, T&gt; v : entries.values()) {
 values.add(v.getValue());
 }
 return values;
 }

 @Override
 public Set&lt;Map.Entry&lt;String, T&gt;&gt; entrySet() {
 // Roll them all out into a new TreeSet.
 Set&lt;Map.Entry&lt;String, T&gt;&gt; entrySet = new TreeSet&lt;&gt;();
 for (Map.Entry&lt;String, Map.Entry&lt;String, T&gt;&gt; v : entries.entrySet()) {
 entrySet.add(new Entry&lt;&gt;(v));
 }
 return entrySet;
 }

 /**
 * An entry.
 *
 * @param &lt;T&gt; The type of the value.
 */
 private static class Entry&lt;T&gt; implements Map.Entry&lt;String, T&gt;, Comparable&lt;Entry&lt;T&gt;&gt; {

 // Note that entry in the entry is an entry in the underlying map.

 private final Map.Entry&lt;String, Map.Entry&lt;String, T&gt;&gt; entry;

 Entry(Map.Entry&lt;String, Map.Entry&lt;String, T&gt;&gt; entry) {
 this.entry = entry;
 }

 @Override
 public String getKey() {
 return entry.getKey();
 }

 @Override
 public T getValue() {
 // Remember that the value is the entry in the underlying map.
 return entry.getValue().getValue();
 }

 @Override
 public T setValue(T newValue) {
 // Remember that the value is the entry in the underlying map.
 return entry.getValue().setValue(newValue);
 }

 @Override
 public boolean equals(Object o) {
 if (!(o instanceof Entry)) {
 return false;
 }
 Entry e = (Entry) o;
 return getKey().equals(e.getKey()) &amp;&amp; getValue().equals(e.getValue());
 }

 @Override
 public int hashCode() {
 return getKey().hashCode() ^ getValue().hashCode();
 }

 @Override
 public String toString() {
 return getKey() + "=" + getValue();
 }

 @Override
 public int compareTo(Entry&lt;T&gt; o) {
 return getKey().compareTo(o.getKey());
 }

 }

 // Simple tests.
 public static void main(String[] args) {
 String[] samples = {
 "Some.For.Me",
 "Some.For.You",
 "Some.More",
 "Yet.More"};
 Map map = new HashMap();
 for (String s : samples) {
 map.put(s, s);
 }
 Map all = new MapFilter(map);
 Map some = new MapFilter(map, "Some.");
 Map someFor = new MapFilter(some, "For.");
 System.out.println("All: " + all);
 System.out.println("Some: " + some);
 System.out.println("Some.For: " + someFor);

 Properties props = new Properties();
 props.setProperty("namespace.prop1", "value1");
 props.setProperty("namespace.prop2", "value2");
 props.setProperty("namespace.iDontKnowThisNameAtCompileTime", "anothervalue");
 props.setProperty("someStuff.morestuff", "stuff");
 Map&lt;String, String&gt; filtered = new MapFilter(props, "namespace.");
 System.out.println("namespace props " + filtered);
 }

}
</code></pre>

blocks|key|212774|text|我用这段代码做了一个速度测试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|212775|public+class+KeyFinder+{

++++private+static+Random+random+=+new+Random();

++++private+interface+Receiver+{
++++++++void+receive(String+value);
++++}

++++public+static+void+main(String[]+args)+{
++++++++for+(int+trials+=+0;+trials+<+10;+trials%2B%2B)+{
++++++++++++doTrial();
++++++++}
++++}

++++private+static+void+doTrial()+{

++++++++final+Map<String,+String>+map+=+new+HashMap<String,+String>();
++++++++giveRandomElements(new+Receiver()+{
++++++++++++public+void+receive(String+value)+{
++++++++++++++++map.put(value,+null);
++++++++++++}
++++++++},+10000);

++++++++final+Set<String>+expressions+=+new+HashSet<String>();
++++++++giveRandomElements(new+Receiver()+{
++++++++++++public+void+receive(String+value)+{
++++++++++++++++expressions.add(value);
++++++++++++}
++++++++},+1000);

++++++++int+hits+=+0;
++++++++long+start+=+System.currentTimeMillis();
++++++++for+(String+expression+:+expressions)+{
++++++++++++for+(String+key+:+map.keySet())+{
++++++++++++++++if+(key.startsWith(expression))+{
++++++++++++++++++++hits%2B%2B;
++++++++++++++++}
++++++++++++}
++++++++}
++++++++long+stop+=+System.currentTimeMillis();
++++++++System.out.printf("Found+%25s+hits+in+%25s+ms\n",+hits,+stop+-+start);
++++}

++++private+static+void+giveRandomElements(Receiver+receiver,+int+count)+{
++++++++for+(int+i+=+0;+i+<+count;+i%2B%2B)+{
++++++++++++String+value+=+String.valueOf(random.nextLong());
++++++++++++receiver.receive(value);
++++++++}

++++}
}|code-block|syntax|javascript|212776|输出结果为：|212777|Found+0+hits+in+1649+ms
Found+0+hits+in+1626+ms
Found+0+hits+in+1389+ms
Found+0+hits+in+1396+ms
Found+0+hits+in+1417+ms
Found+0+hits+in+1388+ms
Found+0+hits+in+1377+ms
Found+0+hits+in+1395+ms
Found+0+hits+in+1399+ms
Found+0+hits+in+1357+ms|212778|这将计算10000个随机密钥中有多少个以1000个随机字符串值中的任何一个开始(10M次检查)。|212779|所以在一台简单的双核笔记本电脑上大约需要1.4秒；这对你来说是不是太慢了？|212780|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I used this code to do a speed trial:

<pre><code>public class KeyFinder {

 private static Random random = new Random();

 private interface Receiver {
 void receive(String value);
 }

 public static void main(String[] args) {
 for (int trials = 0; trials &lt; 10; trials++) {
 doTrial();
 }
 }

 private static void doTrial() {

 final Map&lt;String, String&gt; map = new HashMap&lt;String, String&gt;();
 giveRandomElements(new Receiver() {
 public void receive(String value) {
 map.put(value, null);
 }
 }, 10000);

 final Set&lt;String&gt; expressions = new HashSet&lt;String&gt;();
 giveRandomElements(new Receiver() {
 public void receive(String value) {
 expressions.add(value);
 }
 }, 1000);

 int hits = 0;
 long start = System.currentTimeMillis();
 for (String expression : expressions) {
 for (String key : map.keySet()) {
 if (key.startsWith(expression)) {
 hits++;
 }
 }
 }
 long stop = System.currentTimeMillis();
 System.out.printf("Found %s hits in %s ms\n", hits, stop - start);
 }

 private static void giveRandomElements(Receiver receiver, int count) {
 for (int i = 0; i &lt; count; i++) {
 String value = String.valueOf(random.nextLong());
 receiver.receive(value);
 }

 }
}
</code></pre>

The output was:

<pre><code>Found 0 hits in 1649 ms
Found 0 hits in 1626 ms
Found 0 hits in 1389 ms
Found 0 hits in 1396 ms
Found 0 hits in 1417 ms
Found 0 hits in 1388 ms
Found 0 hits in 1377 ms
Found 0 hits in 1395 ms
Found 0 hits in 1399 ms
Found 0 hits in 1357 ms
</code></pre>

This counts how many of 10000 random keys start with any one of 1000 random String values (10M checks).

So about 1.4 seconds on a simple dual core laptop; is that too slow for you?

blocks|key|431205|text|删除所有不以所需前缀开头的键：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|431206|yourMap.keySet().removeIf(key+->+!key.startsWith(keyPrefix));|code-block|syntax|javascript|431207|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Remove all keys which does not start with your desired prefix:

<pre><code>yourMap.keySet().removeIf(key -&gt; !key.startsWith(keyPrefix));
</code></pre>

blocks|key|212943|text|公认的答案在99%25的情况下都有效，但关键在于细节。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|212944|具体地说，当映射的关键字以前缀开头，然后是Character.MAX_VALUE，然后是其他任何内容时，接受的答案将不起作用。发表在被接受的答案上的评论会带来一些小的改进，但仍然不能涵盖所有情况。|offset|length|style|CODE|212945|下面的解决方案还使用NavigableMap来挑选一个给定关键字前缀的子映射。解决方案是subMapFrom()方法，技巧是不撞/递增前缀的最后一个字符，而是不是MAX_VALUE的最后一个字符，同时去掉所有尾随的MAX_VALUEs。但是如果前缀是"ab“%2B+MAX_VALUE，我们丢弃最后一个字符，而不是前面的字符，结果是"ac”。|212946|import+static+java.lang.Character.MAX_VALUE;

public+class+App
{
++++public+static+void+main(String[]+args)+{
++++++++NavigableMap<String,+String>+map+=+new+TreeMap<>();
++++++++
++++++++String[]+keys+=+{
++++++++++++++++"a",
++++++++++++++++"b",
++++++++++++++++"b"+%2B+MAX_VALUE,
++++++++++++++++"b"+%2B+MAX_VALUE+%2B+"any",
++++++++++++++++"c"
++++++++};
++++++++
++++++++//+Populate+map
++++++++Stream.of(keys).forEach(k+->+map.put(k,+""));
++++++++
++++++++//+For+each+key+that+starts+with+'b',+find+the+sub+map
++++++++Stream.of(keys).filter(s+->+s.startsWith("b")).forEach(p+->+{
++++++++++++System.out.println("Looking+for+sub+map+using+prefix+\""+%2B+p+%2B+"\".");
++++++++++++
++++++++++++//+Always+returns+expected+sub+maps+with+no+misses
++++++++++++//+[b,+b,+bany],+[b,+bany]+and+[bany]
++++++++++++System.out.println("My+solution:+"+%2B
++++++++++++++++++++subMapFrom(map,+p).keySet());
++++++++++++
++++++++++++//+WRONG!+Prefix+"b"+misses+"bany"
++++++++++++System.out.println("SO+answer:+++"+%2B
++++++++++++++++++++map.subMap(p,+true,+p+%2B+MAX_VALUE,+true).keySet());
++++++++++++
++++++++++++//+WRONG!+Prefix+"b"+misses+"b"+and+"bany"
++++++++++++System.out.println("SO+comment:++"+%2B
++++++++++++++++++++map.subMap(p,+true,+tryIncrementLastChar(p),+false).keySet());
++++++++++++
++++++++++++System.out.println();
++++++++});
++++}
++++
++++private+static+<V>+NavigableMap<String,+V>+subMapFrom(
++++++++++++NavigableMap<String,+V>+map,+String+keyPrefix)
++++{
++++++++final+String+fromKey+=+keyPrefix,+toKey;+//+undefined
++++++++
++++++++//+Alias
++++++++String+p+=+keyPrefix;
++++++++
++++++++if+(p.isEmpty())+{
++++++++++++//+No+need+for+a+sub+map
++++++++++++return+map;
++++++++}
++++++++
++++++++//+("ab"+%2B+MAX_VALUE+%2B+MAX_VALUE+%2B+...)+returns+index+1
++++++++final+int+i+=+lastIndexOfNonMaxChar(p);
++++++++
++++++++if+(i+==+-1)+{
++++++++++++//+Prefix+is+all+MAX_VALUE+through+and+through,+so+grab+rest+of+map
++++++++++++return+map.tailMap(p,+true);
++++++++}
++++++++
++++++++if+(i+<+p.length()+-+1)+{
++++++++++++//+Target+char+for+bumping+is+not+last+char;+cut+out+the+residue
++++++++++++//+("ab"+%2B+MAX_VALUE+%2B+MAX_VALUE+%2B+...)+becomes+"ab"
++++++++++++p+=+p.substring(0,+i+%2B+1);
++++++++}
++++++++toKey+=+bumpChar(p,+i);
++++++++
++++++++return+map.subMap(fromKey,+true,+toKey,+false);
++++}
++++
++++private+static+int+lastIndexOfNonMaxChar(String+str)+{
++++++++int+i+=+str.length();
++++++++
++++++++//+Walk+backwards,+while+we+have+a+valid+index
++++++++while+(--i+>=+0)+{
++++++++++++if+(str.charAt(i)+<+MAX_VALUE)+{
++++++++++++++++return+i;
++++++++++++}
++++++++}
++++++++
++++++++return+-1;
++++}
++++
++++private+static+String+bumpChar(String+str,+int+pos)+{
++++++++assert+!str.isEmpty();
++++++++assert+pos+>=+0+&&+pos+<+str.length();
++++++++
++++++++final+char+c+=+str.charAt(pos);
++++++++assert+c+<+MAX_VALUE;
++++++++
++++++++StringBuilder+b+=+new+StringBuilder(str);
++++++++b.setCharAt(pos,+(char)+(c+%2B+1));
++++++++return+b.toString();
++++}
++++
++++private+static+String+tryIncrementLastChar(String+p)+{
++++++++char+l+=+p.charAt(p.length()+-+1);
++++++++return+l+==+MAX_VALUE+?
++++++++++++++++//+Last+character+already+max,+do+nothing
++++++++++++++++p+:
++++++++++++++++//+Bump+last+character
++++++++++++++++p.substring(0,+p.length()+-+1)+%2B+%2B%2Bl;
++++}
}|code-block|syntax|javascript|212947|输出：|212948|Looking+for+sub+map+using+prefix+"b".
My+solution:+[b,+b,+bany]
SO+answer:+++[b,+b]
SO+comment:++[b,+b,+bany]

Looking+for+sub+map+using+prefix+"b".
My+solution:+[b,+bany]
SO+answer:+++[b,+bany]
SO+comment:++[]

Looking+for+sub+map+using+prefix+"bany".
My+solution:+[bany]
SO+answer:+++[bany]
SO+comment:++[bany]|212949|也许应该补充的是，我还尝试了其他各种方法，包括我在互联网上其他地方找到的代码。它们都因产生不正确的结果而失败，或者由于各种异常而崩溃。|212950|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/util/NavigableMap.html^0|0|L|J|0|18|C|29|9|2Z|9|3N|9|A|C|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@$D|17|E|18|F|G]|$D|19|E|1A|F|G]|$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]]|9|@$D|1F|E|1G|1|1H]]|A|$]]|$1|J|3|K|5|L|7|1I|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1J|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1K|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1L|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

The accepted answer works in 99% of all the cases, but the devil is in the details.
Specifically, the accepted answer does not work when the map has a key which begins with the prefix, followed by <code>Character.MAX_VALUE</code> followed by anything else. Comments posted to the accepted answer yields small improvements, but still does not cover all of the cases.
The following solution also uses <a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/util/NavigableMap.html" rel="nofollow noreferrer">NavigableMap</a> to pick out a sub map given a key prefix. The solution is the <code>subMapFrom()</code> method and the trick is to not bump/increment the last char of the prefix, rather, the last char which is not <code>MAX_VALUE</code> whilst cutting off all trailing <code>MAX_VALUE</code>s. So for example, if the prefix is &quot;abc&quot; we increment it to &quot;abd&quot;. But if the prefix is &quot;ab&quot; + <code>MAX_VALUE</code> we drop the last char and bump the preceding char instead, resulting in &quot;ac&quot;.
<pre><code>import static java.lang.Character.MAX_VALUE;

public class App
{
 public static void main(String[] args) {
 NavigableMap&lt;String, String&gt; map = new TreeMap&lt;&gt;();
 
 String[] keys = {
 &quot;a&quot;,
 &quot;b&quot;,
 &quot;b&quot; + MAX_VALUE,
 &quot;b&quot; + MAX_VALUE + &quot;any&quot;,
 &quot;c&quot;
 };
 
 // Populate map
 Stream.of(keys).forEach(k -&gt; map.put(k, &quot;&quot;));
 
 // For each key that starts with 'b', find the sub map
 Stream.of(keys).filter(s -&gt; s.startsWith(&quot;b&quot;)).forEach(p -&gt; {
 System.out.println(&quot;Looking for sub map using prefix \&quot;&quot; + p + &quot;\&quot;.&quot;);
 
 // Always returns expected sub maps with no misses
 // [b, b, bany], [b, bany] and [bany]
 System.out.println(&quot;My solution: &quot; +
 subMapFrom(map, p).keySet());
 
 // WRONG! Prefix &quot;b&quot; misses &quot;bany&quot;
 System.out.println(&quot;SO answer: &quot; +
 map.subMap(p, true, p + MAX_VALUE, true).keySet());
 
 // WRONG! Prefix &quot;b&quot; misses &quot;b&quot; and &quot;bany&quot;
 System.out.println(&quot;SO comment: &quot; +
 map.subMap(p, true, tryIncrementLastChar(p), false).keySet());
 
 System.out.println();
 });
 }
 
 private static &lt;V&gt; NavigableMap&lt;String, V&gt; subMapFrom(
 NavigableMap&lt;String, V&gt; map, String keyPrefix)
 {
 final String fromKey = keyPrefix, toKey; // undefined
 
 // Alias
 String p = keyPrefix;
 
 if (p.isEmpty()) {
 // No need for a sub map
 return map;
 }
 
 // (&quot;ab&quot; + MAX_VALUE + MAX_VALUE + ...) returns index 1
 final int i = lastIndexOfNonMaxChar(p);
 
 if (i == -1) {
 // Prefix is all MAX_VALUE through and through, so grab rest of map
 return map.tailMap(p, true);
 }
 
 if (i &lt; p.length() - 1) {
 // Target char for bumping is not last char; cut out the residue
 // (&quot;ab&quot; + MAX_VALUE + MAX_VALUE + ...) becomes &quot;ab&quot;
 p = p.substring(0, i + 1);
 }
 toKey = bumpChar(p, i);
 
 return map.subMap(fromKey, true, toKey, false);
 }
 
 private static int lastIndexOfNonMaxChar(String str) {
 int i = str.length();
 
 // Walk backwards, while we have a valid index
 while (--i &gt;= 0) {
 if (str.charAt(i) &lt; MAX_VALUE) {
 return i;
 }
 }
 
 return -1;
 }
 
 private static String bumpChar(String str, int pos) {
 assert !str.isEmpty();
 assert pos &gt;= 0 &amp;&amp; pos &lt; str.length();
 
 final char c = str.charAt(pos);
 assert c &lt; MAX_VALUE;
 
 StringBuilder b = new StringBuilder(str);
 b.setCharAt(pos, (char) (c + 1));
 return b.toString();
 }
 
 private static String tryIncrementLastChar(String p) {
 char l = p.charAt(p.length() - 1);
 return l == MAX_VALUE ?
 // Last character already max, do nothing
 p :
 // Bump last character
 p.substring(0, p.length() - 1) + ++l;
 }
}
</code></pre>
Output:
<pre><code>Looking for sub map using prefix &quot;b&quot;.
My solution: [b, b, bany]
SO answer: [b, b]
SO comment: [b, b, bany]

Looking for sub map using prefix &quot;b&quot;.
My solution: [b, bany]
SO answer: [b, bany]
SO comment: []

Looking for sub map using prefix &quot;bany&quot;.
My solution: [bany]
SO answer: [bany]
SO comment: [bany]
</code></pre>
Should perhaps be added that I also tried various other approaches including code I found elsewhere on the internet. All of them failed by yielding an incorrect result or out right crashed with various exceptions.

Consider you have a <code>map&lt;String, Object&gt; myMap</code>.

Given the expression <code>"some.string.*"</code>, I have to retrieve all the values from <code>myMap</code> whose keys starts with this expression.

I am trying to avoid <code>for loop</code>s because <code>myMap</code> will be given a set of expressions not only one and using <code>for loop</code> for each expression becomes cumbersome performance wise.

What is the fastest way to do this?

Fastest way to get all values from a Map where the key starts with a certain expression

Java

假设您有一个map<String, Object> myMap。给定表达式"some.string.*"，我必须从myMap中检索其键以该表达式开头的所有值。我尽量避免使用for loops，因为myMap会被赋予一组表达式，而不是只有一个，而且在性能方面，为每个表达式使用for loop会变得很麻烦。完成此操作的最快...

问从键以某个表达式开始的Map中获取所有值的最快方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从键以某个表达式开始的Map中获取所有值的最快方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从键以某个表达式开始的Map中获取所有值的最快方法
EN