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

我正试图从简短、不统一的产品描述中提取数据，以便部分自动化为我公司的在线商店制作产品网页。不幸的是，这些描述并不统一。多亏了这个网站，我对regex有了足够的了解，可以尝试一下

在产品测量方法中，有一个失败的测试

w。本产品为68厘米乘22厘米乘73厘米--
长：68厘米宽：73厘米高：

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

x。本产品为68厘米x22厘米x73厘米--
长：68厘米宽：22厘米高：73厘米

这是测试课。作为一个RegexNoob，我肯定我做的不是很有效率，所以关于效率的建议会很好。如果你能想到其他失败的测试用例，请告诉我

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

import java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类测试类{
公共静态最终字符串[]testArray=
{
“a.Dynabrade 4 \”光盘34-333-102“，
“b.美世4英寸光盘”，
“c.美世4英寸光盘”，
“d.Carbo CleanAir 6\'真空管附件”，
“e.4英尺”，
“f.4英尺”，
“g.4英尺”，
“h.碳化硅2-3/4 \”胶带4码卷97580”，
“i.我想要5英寸，然后是6英尺”，
“j.我不想要这个pyrex 9”，
“k.这是4英寸x 5英寸x 6英尺的尺寸”，
“l.这个是6 x 5英寸”，
“m.这是4\'x5\'x6\'的尺寸”，
“4-3/4”长的东西，
“哦，我不想要9件极端的东西”，
“p.我不想要9个人”，
“问题6.74亿”，
“r.4英寸”，
“s.5x8”，
“t.P58\”，
“u.5 x 7”，
“六码”，
“w.本产品为68厘米乘22厘米乘73厘米”，
“x.本产品为68厘米x22厘米x73厘米”
};
公共静态最终字符串[]字段名={“长度：”、“宽度：”、“高度：”}；
公共静态最终字符串
MEASURE=“（f（ee）？（oo）？t|in（ch）？（es）？？y（ar）？d（s）？？cm？m？米）？？\”，
也许_MEASURE=MEASURE+“？”，
NUMBER=“（[0-9\\-/]）”，
X=“[（X）（通过）]”，
空格=“\\s”，
可能是\u SPACE=“\\s？”，
空格_或_END=“（\\s |$）”，
START=“^”，
END=“$”，
TAB=“\t”；
公共静态最终模式
regular=Pattern.compile（数字+可能是空格+度量+空格或结尾，Pattern.CASE不区分大小写），
lengthXwidth=Pattern.compile（数字+可能大小写+可能大小写+可能大小写+可能大小写+X+可能大小写+可能大小写+数字+可能大小写，Pattern.CASE不区分大小写），
beforeX=Pattern.compile（NUMBER+MAYBE\u SPACE+MAYBE\u MEASURE+MAYBE\u SPACE+END，Pattern.CASE\u不区分大小写），
afterX=Pattern.compile（START+MAYBE\u SPACE+NUMBER+MAYBE\u SPACE+MAYBE\u MEASURE，Pattern.CASE\u不区分大小写），
measure=Pattern.compile（可能是空间+度量，Pattern.CASE不区分大小写）；
公共静态void main（字符串[]args）
{
用于（字符串testString:testArray）
{
字符串[]字段={“”，“”}；
int匹配=0；
匹配器lengthXwidthMatcher=lengthXwidth.Matcher（测试字符串）；
Matcher regularMatcher=regular.Matcher（testString）；
if（lengthXwidthMatcher.find（））
{
String[]split=testString.split（X）；
对于（int i=0；i，您的
X
产品似乎被指定为字符类，而不是替代品。请尝试：

X = "(x|by)"