0

我有一串混合数据,一些单词和数字。这些数字要么是整数,要么是整数的比率,要么是整数前面的百分号。我试图在程序运行期间(而不是数据库)将此信息存储在 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

第一个打印是 with Map<String,String>,第二个是 with 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?

4

2 回答 2

1

您将如何处理数据对于帮助决定将其存储到哪种数据结构中非常重要。如果您只是打印它们,存储它们将是浪费时间。但我很确定你不只是打印这些数据,对吧?

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

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

我喜欢您的 Ratio 对象,我认为没有更多可以添加(或删除)的内容。我确实同意 Regexp 复杂且难以阅读和理解代码在做什么。但我也认为您提供的解决方案既好又干净。为了使代码更简单、更具可读性,您可以使用带有命名组的模式并将所有内容仅放在一个模式中。我写了以下代码:

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()

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

如果您正在寻找与 Regexp 不同的解决方案,则可以使用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 接口和不同的实现,例如 PercentageRatioProcessor 和 DivisionRatioProcessor。这个接口将有一个“canProcess”方法和一个“process”方法,它们将分别返回一个布尔值和一个比率。布尔值,指示这是否是要使用的正确处理器,对象是处理后的比率。

于 2013-12-18T16:52:07.890 回答
0

这行得通。我不太确定它是否正确,但我不认为这太糟糕了。

结果:

thufir@dur:~/NetBeansProjects/StackOverflow$ 
thufir@dur:~/NetBeansProjects/StackOverflow$ java -jar dist/StackOverflow.jar 
AB      272/272
CD      204/529
HIJKL       105/1
MN      0/1
EFGH        105/1
OPQ     0/100
thufir@dur:~/NetBeansProjects/StackOverflow$ 

代码:

package ratios;

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

public class Ratios {

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

    public Ratios() {
        firstMap();
        secondMap();
        printMap(stringsToRatios);
    }

    public static void main(String[] args) {
        new Ratios();
    }

    private void secondMap() {
        Pattern fraction = Pattern.compile("(\\d+)/(\\d+)");
        Pattern whole = Pattern.compile("(\\d+)");
        Pattern percent = Pattern.compile("(\\d+)%");
        Matcher matcher;
        int num, den;
        Ratio ratio = null;
        for (Map.Entry<String, String> e : strings.entrySet()) {

            matcher = whole.matcher(e.getValue());
            while (matcher.find()) {
                num = Integer.parseInt(matcher.group(1));
                den = 1;
                ratio = new Ratio(num, den);
            }

            matcher = fraction.matcher(e.getValue());
            while (matcher.find()) {
                num = Integer.parseInt(matcher.group(1));
                den = Integer.parseInt(matcher.group(2));
                ratio = new Ratio(num, den);
            }


            matcher = percent.matcher(e.getValue());
            while (matcher.find()) {
                num = Integer.parseInt(matcher.group(1));
                den = 100;
                ratio = new Ratio(num, den);
            }

            stringsToRatios.put(e.getKey(), ratio);
        }
    }

    private void firstMap() {
        Pattern pattern = Pattern.compile("(\\w+): +(\\S+)");
        Matcher matcher = pattern.matcher(input);
        while (matcher.find()) {
            strings.put(matcher.group(1), matcher.group(2));
        }
    }

    private 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);
        }
    }
}
于 2013-12-18T21:06:16.837 回答