Java regex, comma separated only if not in quotation marks or brackets

Question

I would like to do java split through regex. I would like to split my line into each comma when it is NOT in single quotes or brackets. Example:

Hello, 'my,',friend,(how ,are, you),(,)


 should give:
    hello
    my,
    friend
    how, are, you
    ,

I tried this:

(?i),(?=([^\'|\(]*\'|\([^\'|\(]*\'|\()*[^\'|\)]*$)

But I can't get it to work (I tested through http://java-regex-tester.appspot.com/ )

Any ideas?

Answer 1

Nested parenteses cannot be separated by regular expression. It’s easier to break them manually.

public static List<String> split(String orig) {
    List<String> splitted = new ArrayList<String>();
    int nextingLevel = 0;
    StringBuilder result = new StringBuilder();
    for (char c : orig.toCharArray()) {
        if (c == ',' && nextingLevel == 0) {
            splitted.add(result.toString());
            result.setLength(0);// clean buffer
        } else {
            if (c == '(')
                nextingLevel++;
            if (c == ')')
                nextingLevel--;
            result.append(c);
        }
    }
    // Thanks PoeHah for pointing it out. This adds the last element to it.
    splitted.add(result.toString());
    return splitted;
}

Hope this helps.

Answer 2

Java CSV , : http://sourceforge.net/projects/javacsv/

Answer 3

, (),

",(?=(?:[^']*'[^']*')*[^']*$)(?=(?:[^()]*\\([^()]*\\))*[^()]*$)"

, ' .

, .

Answer 4

@Balthus, CSV Parser. smart RexEx replacement, . :

String str = "Hello, 'my,',friend,(how ,are, you),(,)"; // input string

// prepare String for CSV parser: replace left/right brackets OR ' by a "
CsvReader reader = CsvReader.parse(str.replaceAll("[(')]", "\""));
reader.readRecord(); // read the CSV input
for (int i=0; i<reader.getColumnCount(); i++)
   System.out.printf("col[%d]: [%s]%n", i, reader.get(i));

OUTPUT

col[0]: [Hello]
col[1]: [my,]
col[2]: [friend]
col[3]: [how ,are, you]
col[4]: [,]

Answer 5

.

After searching for all the related answers on SO, I realized that in this case a lexer is needed, and I wrote a general implementation for myself. It supports a delimiter, multiple quotes, and multiple brackets as regular expressions.

public static List<String> split(String string, String regex, String[] quotesRegex, String[] leftBracketsRegex,
                                 String[] rightBracketsRegex) {

    if (leftBracketsRegex.length != rightBracketsRegex.length) {
        throw new IllegalArgumentException("Bracket count mismatch, left: " + leftBracketsRegex.length + ", right: "
                + rightBracketsRegex.length);
    }

    // Prepare all delimiters.
    String[] delimiters = new String[1 + quotesRegex.length + leftBracketsRegex.length + rightBracketsRegex.length];
    delimiters[0] = regex;
    System.arraycopy(quotesRegex, 0, delimiters, 1, quotesRegex.length);
    System.arraycopy(leftBracketsRegex, 0, delimiters, 1 + quotesRegex.length, leftBracketsRegex.length);
    System.arraycopy(rightBracketsRegex, 0, delimiters, 1 + quotesRegex.length + leftBracketsRegex.length,
            rightBracketsRegex.length);

    // Build delimiter regex.
    StringBuilder delimitersRegexBuilder = new StringBuilder("(?:");
    boolean first = true;
    for (String delimiter : delimiters) {
        if (delimiter.endsWith("\\") && !delimiter.endsWith("\\\\")) {
            throw new IllegalArgumentException("Delimiter contains trailing single \\: " + delimiter);
        }
        if (first) {
            first = false;
        } else {
            delimitersRegexBuilder.append("|");
        }
        delimitersRegexBuilder
                .append("(")
                .append(delimiter)
                .append(")");
    }
    delimitersRegexBuilder.append(")");
    String delimitersRegex = delimitersRegexBuilder.toString();

    // Scan.
    int pendingQuoteIndex = -1;
    Deque<Integer> bracketStack = new LinkedList<>();
    StringBuilder pendingSegmentBuilder = new StringBuilder();
    List<String> segmentList = new ArrayList<>();
    Matcher matcher = Pattern.compile(delimitersRegex).matcher(string);
    int matcherIndex = 0;
    while (matcher.find()) {
        pendingSegmentBuilder.append(string.substring(matcherIndex, matcher.start()));
        int delimiterIndex = -1;
        for (int i = 1; i <= matcher.groupCount(); ++i) {
            if (matcher.group(i) != null) {
                delimiterIndex = i - 1;
                break;
            }
        }
        if (delimiterIndex < 1) {
            // Regex.
            if (pendingQuoteIndex == -1 && bracketStack.isEmpty()) {
                segmentList.add(pendingSegmentBuilder.toString());
                pendingSegmentBuilder.setLength(0);
            } else {
                pendingSegmentBuilder.append(matcher.group());
            }
        } else {
            delimiterIndex -= 1;
            pendingSegmentBuilder.append(matcher.group());
            if (delimiterIndex < quotesRegex.length) {
                // Quote.
                if (pendingQuoteIndex == -1) {
                    pendingQuoteIndex = delimiterIndex;
                } else if (pendingQuoteIndex == delimiterIndex) {
                    pendingQuoteIndex = -1;
                }
                // Ignore unpaired quotes.
            } else if (pendingQuoteIndex == -1) {
                delimiterIndex -= quotesRegex.length;
                if (delimiterIndex < leftBracketsRegex.length) {
                    // Left bracket
                    bracketStack.push(delimiterIndex);
                } else {
                    delimiterIndex -= leftBracketsRegex.length;
                    // Right bracket
                    int topBracket = bracketStack.peek();
                    // Ignore unbalanced brackets.
                    if (delimiterIndex == topBracket) {
                        bracketStack.pop();
                    }
                }
            }
        }
        matcherIndex = matcher.end();
    }
    pendingSegmentBuilder.append(string.substring(matcherIndex, string.length()));
    segmentList.add(pendingSegmentBuilder.toString());

    while (segmentList.size() > 0 && segmentList.get(segmentList.size() - 1).isEmpty()) {
        segmentList.remove(segmentList.size() - 1);
    }

    return segmentList;
}