【问题标题】:how to change Map<String,String> to Map<String,Ratio> with ratio being x/y如何将 Map<String,String> 更改为 Map<String,Ratio> 比率为 x/y
【发布时间】:2013-12-18 15:58:59
【问题描述】:

我有一串混合数据,一些单词和数字。这些数字可以是整数、整数的比率或整数前面的百分号。我试图在程序运行期间(而不是数据库)将此信息存储在 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&lt;String,String&gt;,第二个是Map&lt;String,Ratio&gt;。如果有比我自制的比例更好的选择,我很乐意使用它。

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

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 类几乎不变,如何改进填充mapStringToRatioratios 方法?

【问题讨论】:

    标签: java regex generics map integer-arithmetic


    【解决方案1】:

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

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

    另一种可能的解决方案是将密钥存储在 Ratio 本身内。因此,您的 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”方法,它们将分别返回一个布尔值和一个比率。布尔值,指示这是否是要使用的正确处理器,对象是处理后的比率。

    【讨论】:

    • 感谢您的反馈。是的,我将使用数据,如果不清楚,请原谅。它是静态的,就像示例代码一样。我更多地关注重复的正则表达式,并认为可能有某种方法可以通过一个正则表达式一步完成。然而,可能需要一些难以维护的巨大的、难以理解的(嗯,对我来说)正则表达式。就是那条if (ratio == null) 行看起来有点尴尬或令人费解。
    • 我在答案中添加了一个使用命名组的正则表达式的解决方案。这使其可读性和清洁度更高!我希望这会有所帮助!
    • 我花了一段时间才发现 matcher = pattern.matcher() 是一种 if 语句。我在下面添加了自己的答案。
    【解决方案2】:

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

    结果:

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

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2013-05-24
      • 2014-01-29
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多