java - 如何将 Map<String,String> 更改为 Map<String,Ratio> ，比率为 x/y

Question

我有一串混合数据，一些单词和数字。这些数字可以是整数、整数比或整数前面的百分号。我试图在程序运行期间(而不是数据库)将此信息存储在 Map (可能是另一种类型的对象，如果有意义的话)中。撇开百分号不谈，其余数据都可以解析。我总是可以期望数据采用这种带有冒号的变量的精确形式。

正确的输出(制表符给出有趣的缩进):

AB: 272/272  CD: 204/529  EFGH: 105 HIJKL: 105  MN: 0 OPQ: 0%
AB      272/272
HIJKL       105
CD      204/529
MN      0
EFGH        105
OPQ     0%
-----------
AB      272/272
CD      204/529
HIJKL       105/1
MN      0/1
EFGH        105/1
OPQ     0/1

第一个打印是 Map<String,String> ，第二个是 Map<String,Ratio> 。如果有比我自制的比例更好的选择，我会很乐意使用它。

笨拙的代码，是的，过度使用静态，只是为了易于复制/粘贴:

package regex;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static java.lang.System.out;

class Ratio {

    private int numerator;
    private int denominator;

    private Ratio() {
    }

    public Ratio(int numerator, int denominator) {
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public int getNumerator() {
        return numerator;
    }

    public int getDenominator() {
        return denominator;
    }

    public String toString() {


        return numerator + "/" + denominator;
    }
}

public class Ratios {

    private static String line = "AB: 272/272  CD: 204/529  EFGH: 105 HIJKL: 105  MN: 0 OPQ: 0%";
    private static Map<String, String> rawMapStringToString = new HashMap<>();
    private static Map<String, Ratio> mapStringToRatio = new HashMap<>();

    public static void main(String[] args) {
        out.println(line);
        populateMap();
        printMap(rawMapStringToString);
        out.println("-----------");
        ratios();
        printMap(mapStringToRatio);
    }

    private static void populateMap() {
        Pattern pattern = Pattern.compile("(\\w+): +(\\S+)");
        Matcher matcher = pattern.matcher(line);
        while (matcher.find()) {
            rawMapStringToString.put(matcher.group(1), matcher.group(2));
        }
    }

    private static void printMap(Map<?, ?> m) {
        for (Map.Entry<?, ?> e : m.entrySet()) {
            String key = e.getKey().toString();
            String val = e.getValue().toString();
            out.println(key + "\t\t" + val);
        }
    }

    private static void ratios() {
        Pattern pattern = Pattern.compile("(\\d+)/(\\d+)");
        Pattern p2 = Pattern.compile("(\\w+)");
        Matcher m2;
        int num, den;
        Ratio ratio = null;
        for (Map.Entry<String, String> e : rawMapStringToString.entrySet()) {
            ratio = null;
            num = 0;
            den = 1;
            Matcher matcher = pattern.matcher(e.getValue());
            while (matcher.find()) {
                num = Integer.parseInt(matcher.group(1));
                den = Integer.parseInt(matcher.group(2));
                ratio = new Ratio(num, den);
            }
            if (ratio == null) {
                m2 = p2.matcher(e.getValue());
                while (m2.find()) {
                    num = Integer.parseInt(m2.group());
                    den = 1;
                    ratio = new Ratio(num, den);
                }
            }
            mapStringToRatio.put(e.getKey(), ratio);
        }
    }
}

我只是在寻找一种存储这些数据的好方法。当然，百分比可以表示为比率，x/y，只需将分母更改为 100。先不说这个，Map 是一个不错的选择吗？

ratios方法和整个正则表达式似乎脆弱、尴尬且难以(对我来说)遵循，但我不确定如何改进代码。保留Ratio类几乎未受影响，我该如何改进ratios方法，填充 mapStringToRatio ？

Answer 1

您要如何处理数据对于决定将其存储到哪种数据结构非常重要。如果您只是打印它们，存储它们会浪费时间。但我很确定您不只是打印这些数据，对吗？

只要你的按键不重复， map 就可以了。否则，您将用具有相同键的新值替换现有值。如果您认为这不是问题，那么您可以保留 map 。

另一种可能的解决方案是将 key 存储在 Ratio 本身内。因此，您的 Ratio 对象将有一个“name”成员，然后您可以将数据存储在比率列表中。

我喜欢你的 Ratio 对象，并且我认为没有太多可以添加(或删除)的内容。我确实同意正则表达式很复杂并且难以阅读和理解代码的作用。但我也认为你给出的解决方案很好而且干净。为了使代码更简单、更具可读性，您可以使用具有命名组的模式，并将所有内容仅放在一个模式中。我编写了以下代码:

Pattern pattern = Pattern.compile("(?<key>\\w+)\\s*:\\s*(?<numerator>\\d+)/*(?<denominator>\\d*)%*");
Matcher matcher = pattern.matcher(INPUT);
while (matcher.find()) {
    System.out.printf("Key: %s, Numerator: %s, Denominator: %s\n",
        matcher.group("key"), 
        matcher.group("numerator"), 
        matcher.group("denominator"));
}

如果组不存在，它将返回一个空字符串。这样你就可以使用 isEmpty 来测试它:

matcher.group("denominator").isEmpty()

我要做的一件事就是将此逻辑放入一个单独的类中，这样更容易测试。不建议将所有内容都作为从主方法运行的静态变量。

如果您正在寻找与正则表达式不同的解决方案，您可以使用 StringTokenizer使用空格/制表符分隔它们。然后使用 split 作为冒号来断开字符串。然后检查右侧字符串中的 % 或/并以不同的方式处理它们。

类似于:

StringTokenizer tokenizer = new StringTokenizer(input);
while (tokenizer.hasMoreTokens()) {
    String [] nameValuePair = tokenizer.nextToken().split(":");
    if (nameValuePair[1].contains("/")) {
        // process ratio here
    } else if (nameValurPair[1].contains("%")) {
        // Process percentage here
    } else {
        // Process String here
    }
}

这段代码的缺点是，如果你为值添加新类型，你最终会得到很长的 if/else 链。它也更难测试，因为其中会有许多不同的分支。如果您不打算添加新的值类型，那就没问题了。

如果您打算对此进行大量扩展，我会采用更抽象的方法，创建一个 RatioProcessor 接口(interface)及其不同的实现，例如 PercentageRatioProcessor 和 DivisionRatioProcessor。该接口(interface)将有一个“canProcess”方法和一个“process”方法，分别返回 boolean 值和比率。 boolean 值指示这是否是要使用的正确处理器以及对象是否是已处理的 Ratio。