Java 使用正则表达式生成字符串而不是匹配字符串

我正在编写一个Java实用程序，它可以帮助我生成性能测试所需的数据负载。如果能够为字符串指定一个正则表达式，那么我的生成器将输出与此匹配的内容，这将非常酷。有没有什么东西已经烤好了，我可以用它来做这个？还是有一个图书馆能让我大部分时间都在那里

---

谢谢

您必须像String:：Random（Perl）的作者那样编写自己的解析器。事实上，他在该模块的任何地方都没有使用正则表达式，这正是perl程序员所习惯的

另一方面，也许你可以看看，得到一些指针

---

编辑：该死，布莱尔以15秒的优势击败了我。

编辑：

关于此问题的建议图书馆的完整列表：

*-爪哇

*-爪哇

-爪哇

-C#

*-取决于dk.brics.automaton

编辑： 如评论中所述，谷歌代码中提供了一个库来实现这一点：

另请参见

原始消息：

---

首先，对于足够复杂的regexp，我相信这是不可能的。但是您应该能够为简单的regexp组合一些东西

如果您查看java.util.regex.Pattern类的源代码，就会发现它使用了节点实例的内部表示。每个不同的模式组件都有自己的节点子类实现。这些节点被组织成一棵树

---

通过生成一个遍历此树的访问者，您应该能够调用一个重载的生成器方法或某种将某些内容拼凑在一起的生成器。

关于stackoverflow播客11：

斯波尔斯基：是的。还有一个新产品，如果你不想使用那里的团队系统，我们在Redgate的朋友有一个叫做SQL数据生成器的产品[.295美元，它只是生成一些真实的测试数据。它会在城市栏中生成真实存在的城市，然后当它生成这些城市时，它会正确地显示州，而不是错误地显示州，或者将州放在德国城市中，诸如此类……你知道，它会生成非常真实的城市查看数据。我不确定所有的功能是什么

这可能不是你想要的，但它可能是一个很好的起点，而不是创造你自己的

我似乎在google中找不到任何东西，因此我建议通过将给定的正则表达式解析为最小的工作单元（\w、[x-x]、\d等）并编写一些基本方法来支持这些正则表达式短语来解决这个问题

---

因此，对于\w，您将有一个方法getRandomLetter（），它返回任何随机字母，还有一个getRandomLetter（char startedter，char endLetter），它在两个值之间提供一个随机字母。

我知道已经有一个可接受的答案，但我一直在使用RedGate的数据生成器（Craig的回答中提到的一个）它对我抛出的所有东西都非常有效。它很快，这让我想使用相同的正则表达式来生成注册码之类的东西的真实数据

它需要一个正则表达式，如：

[A-Z0-9]{3,3}-[A-Z0-9]{3,3}

它会生成大量独特的代码，如：

LLK-32U

---

这是RedGate发现的一个大秘密算法，我们都没有运气，还是我们这些凡人都能做到？

它远不支持完整的PCRE regexp，但我编写了下面的Ruby方法来获取一个类似regexp的字符串并在其上生成一个变体（用于基于语言的验证码）

---

为此，我已经开始使用我的库（在c#中，但对于Java开发人员来说应该很容易理解）

Rxrdg一开始是为了解决为实际项目创建测试数据的问题。其基本思想是利用现有（正则表达式）验证模式创建符合此类模式的随机数据。通过这种方式创建有效的随机数据

为简单的正则表达式模式编写解析器并不困难。使用抽象语法树生成字符串应该更容易。

也能够做到这一点：

String regex = "[ab]{4,6}c";
Xeger generator = new Xeger(regex);
String result = generator.generate();
assert result.matches(regex);

---

我在飞机上看到了一个问题：我已经编写了最简单但效率低下且不完整的解决方案。我希望它可以帮助您开始编写自己的解析器：

public static void main(String[] args) {

    String line = "[A-Z0-9]{16}";
    String[] tokens = line.split(line);
    char[] pattern = new char[100];
    int i = 0;
    int len = tokens.length;
    String sep1 = "[{";
    StringTokenizer st = new StringTokenizer(line, sep1);

    while (st.hasMoreTokens()) {
        String token = st.nextToken();
        System.out.println(token);

        if (token.contains("]")) {
            char[] endStr = null;

            if (!token.endsWith("]")) {
                String[] subTokens = token.split("]");
                token = subTokens[0];

                if (!subTokens[1].equalsIgnoreCase("*")) {
                    endStr = subTokens[1].toCharArray();
                }
            }

            if (token.startsWith("^")) {
                String subStr = token.substring(1, token.length() - 1);
                char[] subChar = subStr.toCharArray();
                Set set = new HashSet<Character>();

                for (int p = 0; p < subChar.length; p++) {
                    set.add(subChar[p]);
                }

                int asci = 1;

                while (true) {
                    char newChar = (char) (subChar[0] + (asci++));

                    if (!set.contains(newChar)) {
                        pattern[i++] = newChar;
                        break;
                    }
                }
                if (endStr != null) {
                    for (int r = 0; r < endStr.length; r++) {
                        pattern[i++] = endStr[r];
                    }
                }

            } else {
                pattern[i++] = token.charAt(0);
            }
        } else if (token.contains("}")) {
            char[] endStr = null;

            if (!token.endsWith("}")) {
                String[] subTokens = token.split("}");
                token = subTokens[0];

                if (!subTokens[1].equalsIgnoreCase("*")) {
                    endStr = subTokens[1].toCharArray();
                }
            }

            int length = Integer.parseInt((new StringTokenizer(token, (",}"))).nextToken());
            char element = pattern[i - 1];

            for (int j = 0; j < length - 1; j++) {
                pattern[i++] = element;
            }

            if (endStr != null) {
                for (int r = 0; r < endStr.length; r++) {
                    pattern[i++] = endStr[r];
                }
            }
        } else {
            char[] temp = token.toCharArray();

            for (int q = 0; q < temp.length; q++) {
                pattern[i++] = temp[q];
            }
        }
    }

    String result = "";

    for (int j = 0; j < i; j++) {
        result += pattern[j];
    }

    System.out.print(result);
}

publicstaticvoidmain（字符串[]args）{
字符串行=“[A-Z0-9]{16}”；
字符串[]标记=行。拆分（行）；
char[]模式=新字符[100]；
int i=0；
int len=tokens.length；
字符串sep1=“[{”；
StringTokenizer st=新的StringTokenizer（行，sep1）；
而（st.hasMoreTokens（））{
字符串标记=st.nextToken（）；
System.out.println（令牌）；
if（标记.包含（“]））{
char[]endStr=null；
如果（！token.endsWith（“]））{
String[]subTokens=token.split（“]”）；
令牌=子令牌[0]；
如果（！subTokens[1].equalsIgnoreCase（“*”）{
endStr=subTokens[1]。toCharArray（）；
}
}
if（token.startsWith（“^”））{
String subStr=token.substring（1，token.length（）-1）；
char[]subChar=subStr.toCharArray（）；
Set=newhashset（）；
对于（int p=0；ppublic static void main(String[] args) {

    String line = "[A-Z0-9]{16}";
    String[] tokens = line.split(line);
    char[] pattern = new char[100];
    int i = 0;
    int len = tokens.length;
    String sep1 = "[{";
    StringTokenizer st = new StringTokenizer(line, sep1);

    while (st.hasMoreTokens()) {
        String token = st.nextToken();
        System.out.println(token);

        if (token.contains("]")) {
            char[] endStr = null;

            if (!token.endsWith("]")) {
                String[] subTokens = token.split("]");
                token = subTokens[0];

                if (!subTokens[1].equalsIgnoreCase("*")) {
                    endStr = subTokens[1].toCharArray();
                }
            }

            if (token.startsWith("^")) {
                String subStr = token.substring(1, token.length() - 1);
                char[] subChar = subStr.toCharArray();
                Set set = new HashSet<Character>();

                for (int p = 0; p < subChar.length; p++) {
                    set.add(subChar[p]);
                }

                int asci = 1;

                while (true) {
                    char newChar = (char) (subChar[0] + (asci++));

                    if (!set.contains(newChar)) {
                        pattern[i++] = newChar;
                        break;
                    }
                }
                if (endStr != null) {
                    for (int r = 0; r < endStr.length; r++) {
                        pattern[i++] = endStr[r];
                    }
                }

            } else {
                pattern[i++] = token.charAt(0);
            }
        } else if (token.contains("}")) {
            char[] endStr = null;

            if (!token.endsWith("}")) {
                String[] subTokens = token.split("}");
                token = subTokens[0];

                if (!subTokens[1].equalsIgnoreCase("*")) {
                    endStr = subTokens[1].toCharArray();
                }
            }

            int length = Integer.parseInt((new StringTokenizer(token, (",}"))).nextToken());
            char element = pattern[i - 1];

            for (int j = 0; j < length - 1; j++) {
                pattern[i++] = element;
            }

            if (endStr != null) {
                for (int r = 0; r < endStr.length; r++) {
                    pattern[i++] = endStr[r];
                }
            }
        } else {
            char[] temp = token.toCharArray();

            for (int q = 0; q < temp.length; q++) {
                pattern[i++] = temp[q];
            }
        }
    }

    String result = "";

    for (int j = 0; j < i; j++) {
        result += pattern[j];
    }

    System.out.print(result);
}

Generex generex = new Generex("[0-3]([a-c]|[e-g]{1,2})");

// generate the second String in lexicographical order that matches the given Regex.
String secondString = generex.getMatchedString(2);
System.out.println(secondString);// it print '0b'

// Generate all String that matches the given Regex.
List<String> matchedStrs = generex.getAllMatchedStrings();

// Using Generex iterator
Iterator iterator = generex.iterator();
while (iterator.hasNext()) {
    System.out.print(iterator.next() + " ");
}
// it prints 0a 0b 0c 0e 0ee 0e 0e 0f 0fe 0f 0f 0g 0ge 0g 0g 1a 1b 1c 1e
// 1ee 1e 1e 1f 1fe 1f 1f 1g 1ge 1g 1g 2a 2b 2c 2e 2ee 2e 2e 2f 2fe 2f 2f 2g
// 2ge 2g 2g 3a 3b 3c 3e 3ee 3e 3e 3f 3fe 3f 3f 3g 3ge 3g 3g 1ee

// Generate random String
String randomStr = generex.random();
System.out.println(randomStr);// a random value from the previous String list

RgxGen rgxGen = new RgxGen(aRegex);                     // Create generator
String s = rgxGen.generate();                           // Generate new random value