不區分大小寫的字符串作為 HashMap 鍵
[英]Case insensitive string as HashMap key
問題描述
由於以下原因，我想使用不區分大小寫的字符串作為 HashMap 鍵。
- 在初始化期間，我的程序使用用戶定義的字符串創建 HashMap
- 在處理事件（在我的情況下是網絡流量）時，我可能會在不同的情況下收到 String，但我應該能夠從 HashMap 中找到
<key, value>忽略我從流量中收到的情況。
我遵循了這種方法
不區分大小寫的字符串
public final class CaseInsensitiveString {
private String s;
public CaseInsensitiveString(String s) {
if (s == null)
throw new NullPointerException();
this.s = s;
}
public boolean equals(Object o) {
return o instanceof CaseInsensitiveString &&
((CaseInsensitiveString)o).s.equalsIgnoreCase(s);
}
private volatile int hashCode = 0;
public int hashCode() {
if (hashCode == 0)
hashCode = s.toUpperCase().hashCode();
return hashCode;
}
public String toString() {
return s;
}
}
查找代碼.java
node = nodeMap.get(new CaseInsensitiveString(stringFromEvent.toString()));
因此，我為每個事件創建了一個新的 CaseInsensitiveString 對象。 因此，它可能會影響性能。
有沒有其他方法可以解決這個問題？
13 個解決方案
解決方案1
358 2014-03-11 21:04:18
Map<String, String> nodeMap =
new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
這就是你所需要的。
解決方案2
60 2011-11-23 03:36:10
正如 Guido García 在他們的回答中所建議的：
import java.util.HashMap;
public class CaseInsensitiveMap extends HashMap<String, String> {
@Override
public String put(String key, String value) {
return super.put(key.toLowerCase(), value);
}
// not @Override because that would require the key parameter to be of type Object
public String get(String key) {
return super.get(key.toLowerCase());
}
}
或者
解決方案3
16 2011-11-23 03:35:49
一種方法是創建 Apache Commons AbstractHashedMap類的自定義子類，覆蓋hash和isEqualKeys方法來執行不區分大小寫的散列和鍵的比較。 （注意 - 我自己從來沒有試過這個......）
這避免了每次需要進行地圖查找或更新時創建新對象的開銷。 並且常見的Map操作應該是 O(1) ...就像常規的HashMap 。
如果您准備接受他們所做的實現選擇，Apache Commons CaseInsensitiveMap會為您完成定制/專門化AbstractHashedMap的工作。
但是如果 O(logN) 的get和put操作是可以接受的，那么帶有不區分大小寫字符串比較器的TreeMap是一個選項； 例如使用String.CASE_INSENSITIVE_ORDER 。
如果您不介意每次執行put或get時創建一個新的臨時 String 對象，那么 Vishal 的答案就很好。 （不過，我注意到如果你這樣做了，你就不會保留鑰匙的原始大小寫......）
解決方案4
6 2011-11-23 03:26:40
子類化HashMap並創建一個版本，該版本將put和get上的鍵小寫（可能還有其他面向鍵的方法）。
或者將HashMap組合到新類中並將所有內容委托給映射，但轉換鍵。
如果您需要保留原始密鑰，您可以維護雙映射，或將原始密鑰與值一起存儲。
解決方案5
5 2011-11-23 03:32:26
我想到了兩個選擇：
- 您可以直接使用
s.toUpperCase().hashCode();作為Map的鍵。 - 您可以將
TreeMap<String>與忽略大小寫的自定義Comparator一起使用。
否則，如果您更喜歡您的解決方案，而不是定義一種新的 String，我寧願實現一個具有所需大小寫不敏感功能的新 Map。
解決方案6
3 2013-08-21 13:43:15
為了記住哈希代碼，“包裝”字符串不是更好嗎？ 在普通的 String 類中，hashCode() 第一次是 O(N)，然后是 O(1)，因為它被保留以備將來使用。
public class HashWrap {
private final String value;
private final int hash;
public String get() {
return value;
}
public HashWrap(String value) {
this.value = value;
String lc = value.toLowerCase();
this.hash = lc.hashCode();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o instanceof HashWrap) {
HashWrap that = (HashWrap) o;
return value.equalsIgnoreCase(that.value);
} else {
return false;
}
}
@Override
public int hashCode() {
return this.hash;
}
//might want to implement compare too if you want to use with SortedMaps/Sets.
}
這將允許您在 Java 中使用 Hashtable 的任何實現並擁有 O(1) hasCode()。
解決方案7
3 2016-03-25 21:31:08
您可以使用Eclipse Collections 中基於HashingStrategy的Map
HashingStrategy<String> hashingStrategy =
HashingStrategies.fromFunction(String::toUpperCase);
MutableMap<String, String> node = HashingStrategyMaps.mutable.of(hashingStrategy);
注意：我是 Eclipse Collections 的貢獻者。
解決方案8
2 2013-08-21 14:10:13
基於其他答案，基本上有兩種方法：子類化HashMap或包裝String 。 第一個需要更多的工作。 事實上，如果你想正確地做到這一點，你必須覆蓋幾乎所有的方法（ containsKey, entrySet, get, put, putAll and remove ）。
無論如何，它有問題。 如果要避免將來出現問題，則必須在String大小寫操作中指定Locale 。 因此，您將創建新方法（ get(String, Locale) ，...）。 一切都更簡單、更清晰地包裝字符串：
public final class CaseInsensitiveString {
private final String s;
public CaseInsensitiveString(String s, Locale locale) {
this.s = s.toUpperCase(locale);
}
// equals, hashCode & toString, no need for memoizing hashCode
}
好吧，關於你對性能的擔憂：過早的優化是萬惡之源:)
解決方案9
1 2015-05-17 18:04:56
對於健壯的CaseInsensitiveMap / CaseInsensitiveSet實現，請查看java-util（ https://github.com/jdereg/java-util ）。
這些Map在標准O（1）查找時間內執行，保留添加項的大小寫，支持所有Map API（例如putAll（），retainAll（），removeAll（）），並允許將異構項放入密鑰集中。
此外，由.keySet（）和.entrySet（）返回的java.util.Set具有不區分大小寫的特性（許多實現都不如此）。 最后，如果在迭代時從鍵/條目集中獲取鍵，則會返回一個String，而不是CaseInsensitiveString包裝器類。
解決方案10
0 2016-04-12 01:34:04
這是我為最近的一個項目實現的 HashMaps 適配器。 以類似於@SandyR 的方式工作，但封裝了轉換邏輯，因此您無需手動將字符串轉換為包裝對象。
我使用了 Java 8 的特性，但有一些變化，你可以適應以前的版本。 除了新的 Java 8 流函數之外，我針對大多數常見場景對其進行了測試。
基本上它包裝了一個 HashMap，將所有函數指向它，同時將字符串轉換為包裝對象或從包裝對象轉換。 但我還必須調整 KeySet 和 EntrySet，因為它們將一些函數轉發給地圖本身。 所以我返回兩個新的鍵和條目集，它們實際上包裝了原始的 keySet() 和 entrySet()。
一個注意事項：Java 8 更改了 putAll 方法的實現，我找不到一種簡單的方法來覆蓋它。 因此，當前的實現可能會降低性能，尤其是當您對大型數據集使用 putAll() 時。
如果您發現錯誤或有改進代碼的建議，請告訴我。
包 webbit.collections;
import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public class CaseInsensitiveMapAdapter<T> implements Map<String,T>
{
private Map<CaseInsensitiveMapKey,T> map;
private KeySet keySet;
private EntrySet entrySet;
public CaseInsensitiveMapAdapter()
{
}
public CaseInsensitiveMapAdapter(Map<String, T> map)
{
this.map = getMapImplementation();
this.putAll(map);
}
@Override
public int size()
{
return getMap().size();
}
@Override
public boolean isEmpty()
{
return getMap().isEmpty();
}
@Override
public boolean containsKey(Object key)
{
return getMap().containsKey(lookupKey(key));
}
@Override
public boolean containsValue(Object value)
{
return getMap().containsValue(value);
}
@Override
public T get(Object key)
{
return getMap().get(lookupKey(key));
}
@Override
public T put(String key, T value)
{
return getMap().put(lookupKey(key), value);
}
@Override
public T remove(Object key)
{
return getMap().remove(lookupKey(key));
}
/***
* I completely ignore Java 8 implementation and put one by one.This will be slower.
*/
@Override
public void putAll(Map<? extends String, ? extends T> m)
{
for (String key : m.keySet()) {
getMap().put(lookupKey(key),m.get(key));
}
}
@Override
public void clear()
{
getMap().clear();
}
@Override
public Set<String> keySet()
{
if (keySet == null)
keySet = new KeySet(getMap().keySet());
return keySet;
}
@Override
public Collection<T> values()
{
return getMap().values();
}
@Override
public Set<Entry<String, T>> entrySet()
{
if (entrySet == null)
entrySet = new EntrySet(getMap().entrySet());
return entrySet;
}
@Override
public boolean equals(Object o)
{
return getMap().equals(o);
}
@Override
public int hashCode()
{
return getMap().hashCode();
}
@Override
public T getOrDefault(Object key, T defaultValue)
{
return getMap().getOrDefault(lookupKey(key), defaultValue);
}
@Override
public void forEach(final BiConsumer<? super String, ? super T> action)
{
getMap().forEach(new BiConsumer<CaseInsensitiveMapKey, T>()
{
@Override
public void accept(CaseInsensitiveMapKey lookupKey, T t)
{
action.accept(lookupKey.key,t);
}
});
}
@Override
public void replaceAll(final BiFunction<? super String, ? super T, ? extends T> function)
{
getMap().replaceAll(new BiFunction<CaseInsensitiveMapKey, T, T>()
{
@Override
public T apply(CaseInsensitiveMapKey lookupKey, T t)
{
return function.apply(lookupKey.key,t);
}
});
}
@Override
public T putIfAbsent(String key, T value)
{
return getMap().putIfAbsent(lookupKey(key), value);
}
@Override
public boolean remove(Object key, Object value)
{
return getMap().remove(lookupKey(key), value);
}
@Override
public boolean replace(String key, T oldValue, T newValue)
{
return getMap().replace(lookupKey(key), oldValue, newValue);
}
@Override
public T replace(String key, T value)
{
return getMap().replace(lookupKey(key), value);
}
@Override
public T computeIfAbsent(String key, final Function<? super String, ? extends T> mappingFunction)
{
return getMap().computeIfAbsent(lookupKey(key), new Function<CaseInsensitiveMapKey, T>()
{
@Override
public T apply(CaseInsensitiveMapKey lookupKey)
{
return mappingFunction.apply(lookupKey.key);
}
});
}
@Override
public T computeIfPresent(String key, final BiFunction<? super String, ? super T, ? extends T> remappingFunction)
{
return getMap().computeIfPresent(lookupKey(key), new BiFunction<CaseInsensitiveMapKey, T, T>()
{
@Override
public T apply(CaseInsensitiveMapKey lookupKey, T t)
{
return remappingFunction.apply(lookupKey.key, t);
}
});
}
@Override
public T compute(String key, final BiFunction<? super String, ? super T, ? extends T> remappingFunction)
{
return getMap().compute(lookupKey(key), new BiFunction<CaseInsensitiveMapKey, T, T>()
{
@Override
public T apply(CaseInsensitiveMapKey lookupKey, T t)
{
return remappingFunction.apply(lookupKey.key,t);
}
});
}
@Override
public T merge(String key, T value, BiFunction<? super T, ? super T, ? extends T> remappingFunction)
{
return getMap().merge(lookupKey(key), value, remappingFunction);
}
protected Map<CaseInsensitiveMapKey,T> getMapImplementation() {
return new HashMap<>();
}
private Map<CaseInsensitiveMapKey,T> getMap() {
if (map == null)
map = getMapImplementation();
return map;
}
private CaseInsensitiveMapKey lookupKey(Object key)
{
return new CaseInsensitiveMapKey((String)key);
}
public class CaseInsensitiveMapKey {
private String key;
private String lookupKey;
public CaseInsensitiveMapKey(String key)
{
this.key = key;
this.lookupKey = key.toUpperCase();
}
@Override
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
CaseInsensitiveMapKey that = (CaseInsensitiveMapKey) o;
return lookupKey.equals(that.lookupKey);
}
@Override
public int hashCode()
{
return lookupKey.hashCode();
}
}
private class KeySet implements Set<String> {
private Set<CaseInsensitiveMapKey> wrapped;
public KeySet(Set<CaseInsensitiveMapKey> wrapped)
{
this.wrapped = wrapped;
}
private List<String> keyList() {
return stream().collect(Collectors.toList());
}
private Collection<CaseInsensitiveMapKey> mapCollection(Collection<?> c) {
return c.stream().map(it -> lookupKey(it)).collect(Collectors.toList());
}
@Override
public int size()
{
return wrapped.size();
}
@Override
public boolean isEmpty()
{
return wrapped.isEmpty();
}
@Override
public boolean contains(Object o)
{
return wrapped.contains(lookupKey(o));
}
@Override
public Iterator<String> iterator()
{
return keyList().iterator();
}
@Override
public Object[] toArray()
{
return keyList().toArray();
}
@Override
public <T> T[] toArray(T[] a)
{
return keyList().toArray(a);
}
@Override
public boolean add(String s)
{
return wrapped.add(lookupKey(s));
}
@Override
public boolean remove(Object o)
{
return wrapped.remove(lookupKey(o));
}
@Override
public boolean containsAll(Collection<?> c)
{
return keyList().containsAll(c);
}
@Override
public boolean addAll(Collection<? extends String> c)
{
return wrapped.addAll(mapCollection(c));
}
@Override
public boolean retainAll(Collection<?> c)
{
return wrapped.retainAll(mapCollection(c));
}
@Override
public boolean removeAll(Collection<?> c)
{
return wrapped.removeAll(mapCollection(c));
}
@Override
public void clear()
{
wrapped.clear();
}
@Override
public boolean equals(Object o)
{
return wrapped.equals(lookupKey(o));
}
@Override
public int hashCode()
{
return wrapped.hashCode();
}
@Override
public Spliterator<String> spliterator()
{
return keyList().spliterator();
}
@Override
public boolean removeIf(Predicate<? super String> filter)
{
return wrapped.removeIf(new Predicate<CaseInsensitiveMapKey>()
{
@Override
public boolean test(CaseInsensitiveMapKey lookupKey)
{
return filter.test(lookupKey.key);
}
});
}
@Override
public Stream<String> stream()
{
return wrapped.stream().map(it -> it.key);
}
@Override
public Stream<String> parallelStream()
{
return wrapped.stream().map(it -> it.key).parallel();
}
@Override
public void forEach(Consumer<? super String> action)
{
wrapped.forEach(new Consumer<CaseInsensitiveMapKey>()
{
@Override
public void accept(CaseInsensitiveMapKey lookupKey)
{
action.accept(lookupKey.key);
}
});
}
}
private class EntrySet implements Set<Map.Entry<String,T>> {
private Set<Entry<CaseInsensitiveMapKey,T>> wrapped;
public EntrySet(Set<Entry<CaseInsensitiveMapKey,T>> wrapped)
{
this.wrapped = wrapped;
}
private List<Map.Entry<String,T>> keyList() {
return stream().collect(Collectors.toList());
}
private Collection<Entry<CaseInsensitiveMapKey,T>> mapCollection(Collection<?> c) {
return c.stream().map(it -> new CaseInsensitiveEntryAdapter((Entry<String,T>)it)).collect(Collectors.toList());
}
@Override
public int size()
{
return wrapped.size();
}
@Override
public boolean isEmpty()
{
return wrapped.isEmpty();
}
@Override
public boolean contains(Object o)
{
return wrapped.contains(lookupKey(o));
}
@Override
public Iterator<Map.Entry<String,T>> iterator()
{
return keyList().iterator();
}
@Override
public Object[] toArray()
{
return keyList().toArray();
}
@Override
public <T> T[] toArray(T[] a)
{
return keyList().toArray(a);
}
@Override
public boolean add(Entry<String,T> s)
{
return wrapped.add(null );
}
@Override
public boolean remove(Object o)
{
return wrapped.remove(lookupKey(o));
}
@Override
public boolean containsAll(Collection<?> c)
{
return keyList().containsAll(c);
}
@Override
public boolean addAll(Collection<? extends Entry<String,T>> c)
{
return wrapped.addAll(mapCollection(c));
}
@Override
public boolean retainAll(Collection<?> c)
{
return wrapped.retainAll(mapCollection(c));
}
@Override
public boolean removeAll(Collection<?> c)
{
return wrapped.removeAll(mapCollection(c));
}
@Override
public void clear()
{
wrapped.clear();
}
@Override
public boolean equals(Object o)
{
return wrapped.equals(lookupKey(o));
}
@Override
public int hashCode()
{
return wrapped.hashCode();
}
@Override
public Spliterator<Entry<String,T>> spliterator()
{
return keyList().spliterator();
}
@Override
public boolean removeIf(Predicate<? super Entry<String, T>> filter)
{
return wrapped.removeIf(new Predicate<Entry<CaseInsensitiveMapKey, T>>()
{
@Override
public boolean test(Entry<CaseInsensitiveMapKey, T> entry)
{
return filter.test(new FromCaseInsensitiveEntryAdapter(entry));
}
});
}
@Override
public Stream<Entry<String,T>> stream()
{
return wrapped.stream().map(it -> new Entry<String, T>()
{
@Override
public String getKey()
{
return it.getKey().key;
}
@Override
public T getValue()
{
return it.getValue();
}
@Override
public T setValue(T value)
{
return it.setValue(value);
}
});
}
@Override
public Stream<Map.Entry<String,T>> parallelStream()
{
return StreamSupport.stream(spliterator(), true);
}
@Override
public void forEach(Consumer<? super Entry<String, T>> action)
{
wrapped.forEach(new Consumer<Entry<CaseInsensitiveMapKey, T>>()
{
@Override
public void accept(Entry<CaseInsensitiveMapKey, T> entry)
{
action.accept(new FromCaseInsensitiveEntryAdapter(entry));
}
});
}
}
private class EntryAdapter implements Map.Entry<String,T> {
private Entry<String,T> wrapped;
public EntryAdapter(Entry<String, T> wrapped)
{
this.wrapped = wrapped;
}
@Override
public String getKey()
{
return wrapped.getKey();
}
@Override
public T getValue()
{
return wrapped.getValue();
}
@Override
public T setValue(T value)
{
return wrapped.setValue(value);
}
@Override
public boolean equals(Object o)
{
return wrapped.equals(o);
}
@Override
public int hashCode()
{
return wrapped.hashCode();
}
}
private class CaseInsensitiveEntryAdapter implements Map.Entry<CaseInsensitiveMapKey,T> {
private Entry<String,T> wrapped;
public CaseInsensitiveEntryAdapter(Entry<String, T> wrapped)
{
this.wrapped = wrapped;
}
@Override
public CaseInsensitiveMapKey getKey()
{
return lookupKey(wrapped.getKey());
}
@Override
public T getValue()
{
return wrapped.getValue();
}
@Override
public T setValue(T value)
{
return wrapped.setValue(value);
}
}
private class FromCaseInsensitiveEntryAdapter implements Map.Entry<String,T> {
private Entry<CaseInsensitiveMapKey,T> wrapped;
public FromCaseInsensitiveEntryAdapter(Entry<CaseInsensitiveMapKey, T> wrapped)
{
this.wrapped = wrapped;
}
@Override
public String getKey()
{
return wrapped.getKey().key;
}
@Override
public T getValue()
{
return wrapped.getValue();
}
@Override
public T setValue(T value)
{
return wrapped.setValue(value);
}
}
}
解決方案11
0 2016-05-23 11:39:35
因此，我為每個事件創建了一個新的 CaseInsensitiveString 對象。 因此，它可能會影響性能。
在查找之前創建包裝器或將鍵轉換為小寫都會創建新對象。 編寫自己的 java.util.Map 實現是避免這種情況的唯一方法。 這不是太難，IMO 值得。 我發現以下哈希函數工作得很好，最多有幾百個鍵。
static int ciHashCode(String string)
{
// length and the low 5 bits of hashCode() are case insensitive
return (string.hashCode() & 0x1f)*33 + string.length();
}
解決方案12
0 2020-08-11 15:15:21
我喜歡使用 ICU4J 的 CaseInsensitiveString 封裝 Map 鍵，因為它負責處理 hash\\equals 和 issue，並且它適用於 unicode\\i18n。
HashMap<CaseInsensitiveString, String> caseInsensitiveMap = new HashMap<>();
caseInsensitiveMap.put("tschüß", "bye");
caseInsensitiveMap.containsKey("TSCHÜSS"); # true
解決方案13
0 2020-10-05 09:50:18
您可以使用：
- LinkedCaseInsensitiveMap包裝了一個LinkedHashMap，它是一個基於哈希表和鏈表的Map。 與 LinkedHashMap 不同的是，它不允許插入空鍵。 LinkedCaseInsensitiveMap 保留原始順序以及鍵的原始大小寫，同時允許在任何情況下調用 get 和 remove 等函數。
例如：
Map<String, Integer> linkedHashMap = new LinkedCaseInsensitiveMap<>();
linkedHashMap.put("abc", 1);
linkedHashMap.put("AbC", 2);
System.out.println(linkedHashMap);
輸出：{AbC=2}
MVN 依賴：
Spring Core 是一個 Spring Framework 模塊，它還提供實用程序類，包括 LinkedCaseInsensitiveMap。
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
- CaseInsensitiveMap是一種基於哈希的 Map，它在添加或檢索鍵之前將鍵轉換為小寫。 與 TreeMap 不同，CaseInsensitiveMap 允許插入空鍵。
例如：
Map<String, Integer> commonsHashMap = new CaseInsensitiveMap<>();
commonsHashMap.put("ABC", 1);
commonsHashMap.put("abc", 2);
commonsHashMap.put("aBc", 3);
System.out.println(commonsHashMap);
輸出：{abc=3}
依賴：
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.4</version>
</dependency>
- TreeMap是 NavigableMap 的實現，這意味着它總是在插入后根據給定的 Comparator 對條目進行排序。 此外，TreeMap 使用 Comparator 來查找插入的鍵是重復的還是新的。
因此，如果我們提供一個不區分大小寫的字符串比較器，我們將得到一個不區分大小寫的 TreeMap。
例如：
Map<String, Integer> treeMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
treeMap.put("ABC", 1);
treeMap.put("ABc", 2);
treeMap.put("cde", 1);
System.out.println(treeMap);
輸出：{ABC=2, cde=1}
解決方案14
0 2021-01-22 23:09:07
您可以使用CollationKey對象而不是字符串：
Locale locale = ...;
Collator collator = Collator.getInstance(locale);
collator.setStrength(Collator.SECONDARY); // Case-insensitive.
collator.setDecomposition(Collator.FULL_DECOMPOSITION);
CollationKey collationKey = collator.getCollationKey(stringKey);
hashMap.put(collationKey, value);
hashMap.get(collationKey);
使用Collator.PRIMARY忽略重音差異。
CollationKey API 不保證實現hashCode()和equals() ，但在實踐中您將使用RuleBasedCollationKey ，它確實實現了這些。 如果你是偏執狂，你可以使用TreeMap代替，它保證以 O(log n) 時間而不是 O(1) 為代價工作。
解決方案15
-3 2018-03-01 07:05:36
由於以下原因，我想使用不區分大小寫的字符串作為HashMap鍵。
- 在初始化期間，我的程序使用用戶定義的String創建HashMap。
- 在處理事件（在我的情況下為網絡流量）時，我可能會在其他情況下收到String，但我應該能夠從HashMap中找到
<key, value>，而忽略我從流量收到的情況。
我遵循了這種方法
CaseInsensitiveString.java
public final class CaseInsensitiveString {
private String s;
public CaseInsensitiveString(String s) {
if (s == null)
throw new NullPointerException();
this.s = s;
}
public boolean equals(Object o) {
return o instanceof CaseInsensitiveString &&
((CaseInsensitiveString)o).s.equalsIgnoreCase(s);
}
private volatile int hashCode = 0;
public int hashCode() {
if (hashCode == 0)
hashCode = s.toUpperCase().hashCode();
return hashCode;
}
public String toString() {
return s;
}
}
LookupCode.java
node = nodeMap.get(new CaseInsensitiveString(stringFromEvent.toString()));
因此，我為每個事件創建一個CaseInsensitiveString新對象。 因此，它可能會影響性能。
還有其他方法可以解決此問題嗎？
不區分大小寫的HashMap保留原始密鑰嗎？
聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.