選擇了以下數據的完美數據結構在java中

Question

我必須選擇我需要一個數據結構，下面我我解釋的條件有以下值

abc,def,rty,ytr,dft which all are map to row R1B1 (actully key is combination of R1+B1) 
abEERc,dFFFef,rGGty which all are map to row R1B2 (actully key is combination of R1+B2) 

KEY      VALUE 
abc,def,rty,ytr,dft ---> R1B1 
abEERc,dFFFef,rGGty ---> R1B2 

現在例如，假設我獲得ytr，那麼我將能夠檢索R1B1 或者，比方說，我得到的價值rGGty然後我將能夠檢索R1B2

現在的情況是，問題是搜索，複雜性和取東西的時候有順序去

例如，它會先挑第一線搜索ytr，它會先匹配它與abc這將不匹配，那麼將不得不匹配def不會再匹配，那麼它將匹配rty，不會也匹配，那麼它最終將匹配ytr最後它會找到問題的關鍵R1B1終於

相似如果需要搜索的第二個字符串讓sa ŸrGGty然後將掃描第一行，它會找不到值，那麼搜索將繼續第二行並在第二行中的第三個元素，將得到rGGty的元素，則其將檢索R1B2作爲價值

讓我們說，如果把這個東西在地圖上，然後序列搜索將繼續關鍵，然後只有我們將能夠找到相應的值

民衆請告知哪個將是我可以在java中實現的最好的數據結構，其中我將不得不搜索的鍵項目在非常快的時間內也找到相應的值，這也不會影響性能太高，那種數據結構的性能應該很高

名

請告知人們

Answer 1

鍵值對可以在O（1），使用HashMap進行訪問。但是，如果您使用HashMap<String, String>，那麼更新該值將會很痛苦，因爲字符串是不可變的。這意味着您將不得不檢查所有條目集，並且如果值匹配，則更新它。所以你可以爲這個值創建一個幫助類，讓所有的鍵指向這個類的一個實例。這裏有一個最重要功能的存根，我想你可以自己添加剩下的東西。

public class MyDataStructure { 

    private Map<String, MyValue> key_value = new HashMap<String, MyValue>(); 
    private Map<String, MyValue> value_MyValue = new HashMap<String, MyValue>(); 

    public void set(String key, String value) { 
    MyValue v = value_MyValue.get(value); 
    if (v == null) { // should rarely happen, could check with containsKey 
     v = new MyValue(value); 
     value_MyValue.put(v); 
    } 
    key_value.put(key, v); 
    } 

    public String get(String key) { 
    return key_value.get(key).getValue(); // key might not exist 
    } 

    public String changeValue(String oldValue, String newValue) { 
    MyValue v = value_MyValue.remove(oldValue); // oldValue might not exist 
    v.setValue(newValue); 
    value_MyValue.put(newValue, v); 
    // will not work if newValue already exists... then you will have to merge 
    } 

    private class MyValue() { 
    private String value; 
    public MyValue(String value) { 
     this.value = value; 
    } 
    public String getValue() { 
     return value; 
    } 
    public void setValue(String value) { 
     this.value = value; 
    } 
    } 
} 

Answer 2

我認爲最好保持簡單，直到性能差表明需要某種改進。即使許多映射值是相同的字符串，也應該可以，因爲Java只在堆中存儲一個副本。如果映射到單個字符串的密鑰集變得非常大，則可以通過執行兩次查找來實現某些性能提升 - 首先確定集合成員資格，然後再檢索與集合關聯的密鑰值。這將很容易實施。現在這裏是一個直接的方法：

import java.util.*; 

public class HashMapDemo { 

    static HashMap<String, String> map = new HashMap<String, String>(); 

    public static void lookup(String key, String value) { 
     if (map.get(key) == value) { 
      System.out.println(key + " lookup ok"); 
     } else { 
      System.out.println(key + " lookup produced" + map.get(key)); 
     } 
    } 

    public static void main(String[] args) { 
     // requirements: 
     // abc,def,rty,ytr,dft ---> R1B1 
     // abEERc,dFFFef,rGGty ---> abEERc 

     Set<String> kset1 = new HashSet<String>(Arrays.asList("abc", "def", 
       "rty", "ytr", "dft")); 

     Set<String> kset2 = new HashSet<String>(Arrays.asList("abEERc", 
       "dFFFef", "rGGty")); 

     for (String s : kset1) { 
      map.put(s, "R1B1"); 
     } 

     for (String s : kset2) { 
      map.put(s, "abEERc"); 
     } 

     // testing value lookup with key 

     for (String s : kset1) { 
      lookup(s, "R1B1"); 
     } 

     // prints: 
     // abc lookup ok 
     // dft lookup ok 
     // def lookup ok 
     // rty lookup ok 
     // ytr lookup ok 

     for (String s : kset2) { 
      lookup(s, "abEERc"); 
     } 

     // prints: 
     // rGGty lookup ok 
     // abEERc lookup ok 
     // dFFFef lookup ok 

     // change key "R1B1" to "XYZ" 

     for (String s : kset1) { 
      map.put(s, "XYZ"); 
     } 

     // test the change 

     for (String s : kset1) { 
      lookup(s, "XYZ"); 
     } 

     // prints: 
     // abc lookup ok 
     // dft lookup ok 
     // def lookup ok 
     // rty lookup ok 
     // ytr lookup ok 

    } 
}