Java正则表达式从字符串中提取测量值

Question

我正在尝试从简短的、不一致的产品描述中提取数据，以便部分自动化地为我公司的在线商店制作产品网页。不幸的是，描述并不统一。感谢这个网站，我对正则表达式有了足够的了解，可以对其进行公平的尝试。

在产品测量方法中，这里是一个失败的测试。

w。本产品尺寸为 68 厘米 x 22 厘米 x 73 厘米 --
长度:68 厘米宽度:73 厘米高度:

但是这个非常相似的测试并没有失败。为什么？

x。本产品尺寸为 68 厘米 x 22 厘米 x 73 厘米 --
长度:68 厘米宽度:22 厘米高度:73 厘米

这是测试类。作为一个正则表达式菜鸟，我确信我做得不是很有效，所以关于效率的建议会很棒。如果您能想到任何其他失败的测试用例，请告诉我。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TesterClass {
    public static final String[] testArray = 
    {
        "a. Dynabrade 4\" Discs 34-333-102",
        "b. Mercer 4 Inch Discs",
        "c. Mercer 4in Discs",
        "d. Carbo CleanAir 6\' Vacuum Tube Attachment",
        "e. 4 feet",
        "f. 4 Ft",
        "g. 4 foot",
        "h. Carborundum 2-3/4\" Tape 4 yd Roll 97580",
        "i. I want 5 Inches and later 6 Feet",
        "j. I don't want this one pyrex 9",
        "k. This is 4 Inches x 5 Inches x 6 Feet in Size",
        "l. This one is 6 x 5 Inches",
        "m. This is 4\" x 5\" x 6\' in size",
        "n. Something 4-3/4\" Long",
        "o. I don't want 9 xtreme things",
        "p. I don't want 9 men",
        "q. 674m",
        "r. 4 Inches",
        "s. 5x8",
        "t. P58\"",
        "u. 5 x 7",
        "v. 6 yards",
        "w. This product is 68 cm by 22 cm by 73 cm",
        "x. This product is 68 cm x 22 cm x 73 cm"
    };
    public static final String[] FIELDNAMES = {"Length: ","Width: ","Height: "};

    public static final String 
        MEASURE = "(f(ee)?(oo)?t|in(ch)?(es)?|y(ar)?d(s)?|cm|m|meter(s)?|\"|\')",
        MAYBE_MEASURE = MEASURE + "?",
        NUMBER = "([0-9\\-/]+)",
        X = "[(x)(by)]",
        SPACE = "\\s",
        MAYBE_SPACE = "\\s?",
        SPACE_OR_END = "(\\s|$)",
        START = "^",
        END = "$",
        TAB = "\t";

    public static final Pattern 
        regular = Pattern.compile(NUMBER + MAYBE_SPACE + MEASURE + SPACE_OR_END, Pattern.CASE_INSENSITIVE),
        lengthXwidth = Pattern.compile(NUMBER + MAYBE_SPACE + MAYBE_MEASURE + MAYBE_SPACE + X + MAYBE_SPACE + NUMBER + MAYBE_MEASURE, Pattern.CASE_INSENSITIVE),
        beforeX = Pattern.compile(NUMBER + MAYBE_SPACE + MAYBE_MEASURE + MAYBE_SPACE + END, Pattern.CASE_INSENSITIVE),
        afterX = Pattern.compile(START + MAYBE_SPACE + NUMBER + MAYBE_SPACE + MAYBE_MEASURE, Pattern.CASE_INSENSITIVE),
        measure = Pattern.compile(MAYBE_SPACE + MEASURE, Pattern.CASE_INSENSITIVE);


    public static void main(String[] args)
    {
        for (String testString:testArray)
        {
            String[] fields = {"","",""};
            int match = 0;
            Matcher lengthXwidthMatcher = lengthXwidth.matcher(testString);
            Matcher regularMatcher = regular.matcher(testString);

            if (lengthXwidthMatcher.find())
            {
                String[] split = testString.split(X);
                for (int i = 0; i<split.length; i++)
                {
                    Matcher beforeXMatcher = beforeX.matcher(split[i]);
                    Matcher afterXMatcher = afterX.matcher(split[i]);
                    if (beforeXMatcher.find() && match==0)
                    {
                        fields[0] = beforeXMatcher.group();
                        match++;
                    }
                    if (afterXMatcher.find())
                    {
                        if (match==1)
                        {
                            fields[1] = afterXMatcher.group();
                            match++;
                        }
                        else if (match==2)
                        {
                            fields[2] = afterXMatcher.group();
                            match++;
                        }
                    }
                }
                Matcher lengthHasMeasure = measure.matcher(fields[0]);
                Matcher widthHasMeasure = measure.matcher(fields[1]);
                Matcher heightHasMeasure = measure.matcher(fields[2]);
                if (heightHasMeasure.find()==true)
                {
                    if (lengthHasMeasure.find()==false)
                    {
                        fields[0] = fields[0] + heightHasMeasure.group();
                    }
                    if (widthHasMeasure.find()==false)
                    {
                        fields[1] = fields[1] + heightHasMeasure.group();
                    }
                }
                else if (widthHasMeasure.find()==true)
                {
                    if (lengthHasMeasure.find()==false)
                    {
                        fields[0] = fields[0] + widthHasMeasure.group();
                    }
                }
            }
            else if(regularMatcher.find())
            {
                fields[0] = regularMatcher.group();
                match++;
                while (regularMatcher.find() && match<3)
                {
                    fields[match] = regularMatcher.group();
                }
            }

            System.out.println(testString + " -- " + TAB + FIELDNAMES[0] + fields[0] + TAB + FIELDNAMES[1] + fields[1] + TAB + FIELDNAMES[2] + fields[2]);
        }
    }
}

Answer 1

看起来您的 X 产品被指定为字符类，而不是交替。尝试:

X = "(x|by)"