Java regex split on multiple delimiters including substrings of other delimiters

Question

I'm trying to convert a string into a map of values using regex and known delimiters. The code I have works, but if I use a delimiter which is a substring of another delimiter, it is not parsed (properly).

Let's cut straight to some sample input, erroneous output, expected output, and code!

Sample input: "Artist: foo bar foooo Title: bar fooo bar Dimensions: x z y Framed dimensions: y z x" (as you can see there is "Dimensions" and "Framed dimensions")

Erroneous output: {Artist:=foo bar foooo, Title:=bar fooo bar, Dimensions:=x z y, dimensions:=y z x} (Framed dimensions got caught under dimensions!)

Expected output: Artist:=foo bar foooo, Title:=bar fooo bar, Dimensions:=x z y, Framed dimensions:=y z x}

Code example:

String DELIMITER = "[Aa]rtist:|[Tt]itle:|[Ff]ramed [Dd]imensions:|[Dd]imensions:"
...
public Map<String, String> parseToMap(String str) {
    Map<String, String> itemMap = new LinkedHashMap<>();
    String infos[] = str.split("(?=" + DELIMITER + ')'); //split at delimiters
        for(String info : infos) {
            try {
                String[] tmp = info.split("(?<=" + DELIMITER + ')'); //split to key/val pair
                itemMap.put(tmp[0].trim(), tmp[1].trim());
            } catch (IndexOutOfBoundsException e) {
                //Skip if no key/val pair
            }
        }
    return itemMap;
}

I also feel like this is a bit hackish. If there is a more elegant solution, I'd be glad to hear it. Although I can always make a trip to CodeReview if we can just get this working for now :)

EDIT: I need every word from delimiter to delimiter, not just the word following a delimiter.

In expected shouldn't it be `Title:=bar` instead of `Title=bar`? — Przemysław Moskal, Feb 20 '18 at 20:29
[*Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.* - Jamie Zawinski](http://regex.info/blog/2006-09-15/247) — , Feb 20 '18 at 20:42
@WiktorStribiżew, your solution worked for me. Wanna make it an answer and I'll accept it? — MeetTitan, Feb 20 '18 at 21:11

anubhava · Accepted Answer · 2018-02-20T21:18:58.110

Rather than split operation use this regex with 2 captured groups:

(?<key>[\w\s]+:)\s*(?<value>.+?)\s*(?=(?:[Aa]rtist|[Tt]itle|(?:[Ff]ramed )?[Dd]imensions):|$)

RegEx Demo

Code:

final String regex = "(?<key>[\\w\\s]+:)\\s*(?<value>.+?)\\s*(?=(?:[Aa]rtist|[Tt]itle|(?:[Ff]ramed )?[Dd]imensions):|$)";
final String string = "Artist: foo Title: bar Dimensions: x Framed dimensions: y";

final Pattern pattern = Pattern.compile(regex);
final Matcher m = pattern.matcher(string);

Map<String, String> itemMap = new LinkedHashMap<>();
while (m.find()) {
    itemMap.put(m.group("key"), m.group("value"));
}

System.out.println("itemMap: " + itemMap);

This only gets the following word. I need every word until the next delimiter. — MeetTitan, Feb 20 '18 at 21:02

score 2 · Answer 2 · answered Feb 20 '18 at 21:33

Your regex is a non-consuming positive lookahead that tests each position inside a string, and thus, it can match overlapping strings.

You may use a matching approach to capture the delimiters into Group 1 and then any char that does not start any of the delimiters:

public static Map<String, String> parseToMap(String str) {
    String DESCRIPTION_DELIMITER = "[Aa]rtist:|[Tt]itle:|[Ff]ramed [Dd]imensions:|[Dd]imensions:";
    Map<String, String> itemMap = new LinkedHashMap<>();
    Pattern p = Pattern.compile("(" + DESCRIPTION_DELIMITER + ")((?:(?!" + DESCRIPTION_DELIMITER + ").)*)"); //split to key/val pair
    Matcher m = p.matcher(str);
    while(m.find()) {
        itemMap.put(m.group(1).trim(), m.group(2).trim());
    }
    return itemMap;
}

See the Java demo.

The regex will look like

([Aa]rtist:|[Tt]itle:|[Ff]ramed [Dd]imensions:|[Dd]imensions:)((?:(?![Aa]rtist:|[Tt]itle:|[Ff]ramed [Dd]imensions:|[Dd]imensions:).)*)

See the online demo.

Here,

([Aa]rtist:|[Tt]itle:|[Ff]ramed [Dd]imensions:|[Dd]imensions:) - Group 1 matching any of the delimiters
((?:(?![Aa]rtist:|[Tt]itle:|[Ff]ramed [Dd]imensions:|[Dd]imensions:).)*) - a tempered greedy token matching any char other than a line break char (.), 0+ occurrences (*), that does not start any of the delimiter character sequences.

score 0 · Answer 3 · answered Feb 20 '18 at 22:58

If the input is expected to be always in the following format
Artist: foo Title: bar Dimensions: x Framed dimensions: y

Java regex split on multiple delimiters including substrings of other delimiters

3 Answers3