在java中为以下数据选择完美的数据结构

我必须根据我的需要选择一种数据结构，我在下面解释存在以下值的条件

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)

现在，比如说，如果我得到

ytr

，那么我将能够检索

R1B1

或者，假设我得到值

rGGty

，那么我就能够检索

R1B2

现在的情况是，问题在于搜索、复杂性以及事情按顺序进行所需的时间

例如，它将首先选择要搜索的第一行

ytr

，它将首先与不匹配的

abc

匹配，然后必须与

def

匹配，它将不再匹配，然后它将与不匹配的

rty

匹配，然后它将最终与

ytr

匹配，最后它将找到键

R1B1

类似地，如果需要搜索第二个字符串，比如说

rGGty

，那么它将扫描第一行，在其中它将找不到值，然后搜索将继续到第二行，并且在第三个元素的第二行，它将获得

rGGty

作为元素，然后它将检索

R1B2

作为值

比方说，如果把这个东西放在地图上，那么序列搜索将在键上进行，然后只有我们才能找到相应的值

各位朋友，请告诉我，哪种数据结构是我用java实现的最好的数据结构，在java中，我必须搜索键项以在非常快的时间内找到相应的值，这也不会影响性能 ，这种数据结构的性能应该非常高

---

请告知大家

可以使用

HashMap

在O（1）中访问键值对。但是，如果使用

HashMap

，则更新该值将非常痛苦，因为字符串是不可变的。这意味着您必须检查所有条目集，如果值匹配，则更新它。因此，您可以为该值创建一个helper类，并让所有键指向该类的一个实例。这是一个包含最重要函数的存根，我想您可以自己添加其余的函数

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;
    }
  }
}

公共类MyDataStructure{
私有映射密钥_值=新HashMap（）；
私有映射值_MyValue=newhashmap（）；
公共无效集（字符串键、字符串值）{
MyValue v=value\u MyValue.get（value）；
如果（v==null）{//应该很少发生，可以使用containsKey进行检查
v=新的MyValue（值）；
价值(v);；
}
键_值put（键，v）；
}
公共字符串获取（字符串键）{
返回key_value.get（key）.getValue（）；//键可能不存在
}
公共字符串changeValue（字符串oldValue、字符串newValue）{
MyValue v=value\u MyValue.remove（oldValue）；//oldValue可能不存在
v、 设置值（新值）；
value_MyValue.put（newValue，v）；
//如果newValue已经存在，则将不起作用…然后必须合并
}
私有类MyValue（）{
私有字符串值；
公共MyValue（字符串值）{
这个值=值；
}
公共字符串getValue（）{
返回值；
}
公共void设置值（字符串值）{
这个值=值；
}
}
}

我认为最好保持简单，直到性能不佳表明需要某种改进。即使许多映射值是相同的字符串，这也应该是可以的，因为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

    }
}

import java.util.*；
公共类HashMapDemo{
静态HashMap map=newhashmap（）；
公共静态无效查找（字符串键、字符串值）{
if（map.get（key）=值）{
System.out.println（key+“lookup ok”）；
}否则{
System.out.println（key+“lookup producted”+map.get（key））；
}
}
公共静态void main（字符串[]args）{
//要求：
//abc、def、rty、ytr、dft->R1B1
//abEERc，dFFFef，rGGty--->abEERc
Set kset1=newhashset（Arrays.asList（“abc”、“def”），
“rty”、“ytr”、“dft”）；
Set kset2=newhashset（Arrays.asList（“abEERc”），
“dFFFef”、“rGGty”）；
for（字符串s:kset1）{
地图放置（s，“R1B1”）；
}
for（字符串s:kset2）{
图.put（s，“abEERc”）；
}
//使用键进行测试值查找
for（字符串s:kset1）{
查阅（s，“R1B1”）；
}
//印刷品：
//abc查找ok
//dft查找正常
//def查找正常
//好的
//ytr查找正常
for（字符串s:kset2）{
查找（s，“abEERc”）；
}
//印刷品：
//rGGty查找正常
//abEERc查找正常
//dFFFef查找ok
//将键“R1B1”更改为“XYZ”
for（字符串s:kset1）{
地图放置（s，“XYZ”）；
}
//测试变化
for（字符串s:kset1）{
查找（s，“XYZ”）；
}
//印刷品：
//abc查找ok
//dft查找正常
//def查找正常
//好的
//ytr查找正常
}
}

为什么你不能有一个带有简单（一个单词）键的

哈希表呢？@PM77-1仍然不能理解请详细解释存储以下几对：
abc
-
R1B1
，
def
-
R1B1
，等等。不要使用CSV格式存储。我会使用哈希图。如果使用它演示了性能问题，我会根据需要改进它。@ TrIS NefZGER非常感谢，你也可以展示你将如何存储这些元素并检索它们。
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

    }
}