当键是字符串时如何在Java中创建范围映射

Question

我想创建一个大范围的地图，将根据他们的数字映射到存储桶的键，例如：

            NavigableMap<String, String> map = new TreeMap<>();

            map.put("var2#" + 0L,   "out0");      // "var2#0..100        => out0
            map.put("var2#" + 100L, "out1");    // "var2#100..200"     => out1
            map.put("var2#" + 200L, "out2");    // "var2#200..300"     => out2
            map.put("var2#" + 300L, "out3");    // "var2#300..+"       => out3

这意味着如果一个新键将到达，值 res 应该是"var2#150" ==> "out1"

我试图做的是使用排序地图，一切都在地图内的数字范围内工作

类似：

String out1 = map.floorEntry("var2#" + 150L).getValue(); //out1 , works!

，但是如果发送 var2#2000 ，而不是获取 res "out3" ，我得到了 "out2" ，依此类推...

String res = map.floorEntry("var2#" + 2000L).getValue(); 
Syso(res)  ==> out2 , BUT I expected result => "out3"
// because it is bigger that the range.

PS：

It is very large map with prefix of some "string" and comes after typed
 long number . Eg. "var1#100, var1#200 , ...bla1#1000 , bla5#2000....

另一个问题 - 当我在不同的键上具有相同的长值时，我希望在字符串上进行第一次匹配，然后在数字上进行 ...

    map.put("var1#" + 200L, "out0");
    map.put("var2#" + 200L, "out1");
    map.put("var3#" + 200L, "out2");
    map.put("var4#" + 200L, "out3");

    String out1 = map.floorEntry("var2#" + 150L).getValue();
    System.out.println("====> " + out1); //expected  out1 , because only match of "var2
    String out3 = map.floorEntry("var2#" + 250L).getValue(); //expected  out1 , because only match of "var2
    System.out.println("====> " + out3);" ....

请有任何建议，也许是一些算法？

Answer 1

比较前缀字符串，然后比较后缀数字的一种方法是：

public static int compareParts(String a, String b) {
    String[] aa = a.split("#", 2), ba = b.split("#", 2);
    int c = aa[0].compareTo(ba[0]);
    return c != 0? c: Integer.compare(Integer.parseInt(aa[1]), Integer.parseInt(ba[1]));
}

但由于比较方法可能会被非常频繁地调用，即使是一次查找也可能涉及多次比较，因此值得研究一些时间来提高性能，即使代码看起来会更复杂：

public static int compareParts(String a, String b) {
    final int aLen = a.length(), bLen = b.length(), l = Math.min(aLen, bLen);
    int ix = 0;
    stringPart: {
        for(; ix < l; ix++) {
            char aCh = a.charAt(ix), bCh = b.charAt(ix);
            int cmp = Character.compare(aCh, bCh);
            if(cmp != 0)
                return aCh == '#'? -1: bCh == '#'? +1: cmp;
            if(aCh == '#') break stringPart;
        }
        return 0;
    }
    // number part
    int aIx = ix+1, bIx = aIx;
    while(aIx < aLen && a.charAt(aIx)=='0') aIx++;
    while(bIx < bLen && b.charAt(bIx)=='0') bIx++;
    int cmp = Integer.compare(aLen-aIx, bLen-bIx);
    for(; cmp == 0 && aIx < aLen; aIx++, bIx++) {
        cmp = Character.compare(a.charAt(aIx), b.charAt(bIx));
    }
    return cmp;
}

这只会对字符串进行一次传递。首先，它像String.compareTo 那样遍历字符串的第一个字符，在第一个不匹配字符或'#' 字符处停止。如果只有一个字符串遇到'#'，另一个字符串有更长的前缀，我们必须考虑结果。

只有当两个字符串具有相同的前缀时，'#' 之后的数字部分才会被处理。如果有的话，我们跳过所有前导零，而不是进行完整的整数解析。然后，如果剩余有效部分的长度不同，它已经表明哪个数字更大。只有重要部分的长度相同时，我们才需要迭代它们。但是在这种情况下，我们可以逐字比较数字而不需要将它们解释为数字，因为迭代顺序已经是从最高有效位到最低有效位。

任何一种方法都可以使用

NavigableMap<String, String> map = new TreeMap<>(MyClass::compareParts);

map.put("var2#" + 0L,   "out0");
map.put("var2#" + 100L, "out1");
map.put("var2#" + 200L, "out2");
map.put("var2#" + 300L, "out3");

String out1 = map.floorEntry("var2#" + 150L).getValue();
System.out.println("out1 = "+out1);
String out3 = map.floorEntry("var2#" + 2000L).getValue();
System.out.println("res = "+out3);

Answer 2

问题是TreeMap 使用字符串进行比较。所以它按字母顺序排序，var2#2000 介于var2#200 和var2#300 之间。您应该使用specify a custom comparator，或者使用Long 或Integer 作为TreeMap 的键。所以，这应该工作：

NavigableMap<Long, String> map = new TreeMap<>();
map.put(0L,   "out0");      // "var2#0..100        => out0
map.put(100L, "out1");    // "var2#100..200"     => out1
map.put(200L, "out2");    // "var2#200..300"     => out2
map.put(300L, "out3");    // "var2#300..+"       => out3

Answer 3

您可以提取密钥的第二部分并将其用作可导航地图的比较器：

Comparator.comparingLong(key -> Long.parseLong(key.split("#")[1]))

所以：

NavigableMap<String, String> map =
    new TreeMap<>(Comparator.comparingLong(key -> Long.parseLong(key.split("#")[1])));

map.put("var2#" + 0L,   "out0");    // "var2#0..100        => out0
map.put("var2#" + 100L, "out1");    // "var2#100..200"     => out1
map.put("var2#" + 200L, "out2");    // "var2#200..300"     => out2
map.put("var2#" + 300L, "out3");    // "var2#300..+"       => out3

assertThat(map.floorEntry("var2#" + 150L).getValue()).isEqualTo("out1");
assertThat(map.floorEntry("var2#" + 2000L).getValue()).isEqualTo("out3");

Answer 4

我会拆分密钥以获得每个变量的Map 范围：

Map<String, Ranges> map;

我们在哪里实现Ranges，因为我们需要映射值和结果，就像Hari Menon 提出的那样。

class Ranges {

    NavigableMap<Long, String> map = new TreeMap<>();

    public String setFloor(long l, String s){
        return map.put(l, s);
    }

    public String getFloor(long l){
        return map.floorEntry(l).getValue();
    }
}

这将很容易填充：

Map<String, Ranges> map = new HashMap<>();

Ranges r = new Ranges();
r.setFloor(0L, "out1");
r.setFloor(100L, "out2");   
map.put("var1", r);

r = new Ranges();
r.setFloor(0L, "out3");
r.setFloor(100L, "out4");
map.put("var2", r);

System.out.println(map.get("var1").getFloor(50L));
System.out.println(map.get("var2").getFloor(150L));

输出1
输出4

我们可以使用NavigableMap 代替HashMap，但我没有看到这里的重点。

请注意，这不是 NPE 安全的，这不是保证解决方案简短易读的安全措施。