Split the string based on number of occurrences in Java

Question

I want to split the values based on the number of occurrences.

If the number of occurrences is 4
e.g. key = A-B-C-D, the answer should be A,B,C,D
If the number of occurrences is more than 4
e.g. key = A-B-C-D-E-F, the answer should be A-B-C,D,E,F

Please find my attempt below:

String key = "A-B-C-D-E-F";
String[] res = key.split("(?<!^[^_]*)_");
System.out.println(Arrays.toString(res));

My output is A-B,C,D,E,F but my expectation is A-B-C,D,E,F

Similarly the number of occurrences varies based on usage. While splitting, I need to get maximum four values.

Please check and let me know about this.

java lookbehind does allow quantifiers, but only if the length of the string is finite afaik (like curly quantifier with upper bound); still i am surprised it works with star. — guido, Apr 08 '16 at 10:52
Right I know it works with `{0,999}` but with `*`, totally suprising — anubhava, Apr 08 '16 at 10:53
Even [the reference](http://www.regular-expressions.info/lookaround.html#limitbehind) confirms @anubhava's suspicion... — HamZa, Apr 08 '16 at 10:54
After pinging [nhahtdh](http://chat.stackoverflow.com/transcript/message/29834592#29834592) he could point me in the right direction. [This answer seems to explain our confusion...](http://stackoverflow.com/a/1537370) — HamZa, Apr 08 '16 at 11:01
@WiktorStribiżew: This is a known issue in Java: https://stackoverflow.com/questions/1536915/regex-look-behind-without-obvious-maximum-length-in-java Java officially does not support variable length look-behind, but due to the way it implements `*` and the way it checks the length of the pattern in the look-behind, some cases are let through. — nhahtdh, Apr 08 '16 at 11:01
You cannot use the `split` like that in this case, since the lookbehind will become of unknown width. — Wiktor Stribiżew, Apr 08 '16 at 11:17
i will try to find any other way to do it using regEx or i will use java code to achieve it :) — Abdul, Apr 08 '16 at 11:20
@Abdul: I hope you will review the previous questions and give credit to people who answered you. — Wiktor Stribiżew, Apr 08 '16 at 14:01
@Wiktor Stribiżew :- I will credit to them for their effort to support me ... — Abdul, Apr 08 '16 at 14:03
@Wiktor Stribiżew :- I checked and accepted their answers :) — Abdul, Apr 08 '16 at 14:32

Wiktor Stribiżew · Accepted Answer · 2016-04-08T13:37:31.937

Use

//String key = "A-B-C-D";       // => [A, B, C, D]
String key = "A-B-C-D-E-F"; // => [A_B, C, D, E, F]
int keep = 3;
String[] res = key.split("-");
if (res.length > 4) {
    String first = String.join("-", Arrays.asList(res).subList(0, keep)); 
    List<String> lst = new ArrayList<>();
    lst.add(first);
    lst.addAll(Arrays.asList(res).subList(keep, res.length));
    res = new String[lst.size()];
    res = lst.toArray(res);
}
System.out.println(Arrays.toString(res));

See the IDEONE demo

Basically, I suggest splitting first, and check how many elements we have. Then, just take as many first elements as we need to keep, and then combine this one with the rest.

@Braj: Thanks. Fixed. – Wiktor Stribiżew Apr 08 '16 at 13:38 — Wiktor Stribiżew, Apr 08 '16 at 13:38

score 0 · Answer 2 · answered Apr 08 '16 at 14:24

You can also try this regex way:

public static void main(String[] args) {
    String input[] = { "A-B-C-D", "A-B-C-D-E-F-E-G", "AAAA-BBB-CCC-DD-EE", "BB-CC-DD-EE" };

    for (String str : input) {
        String output = str.replaceAll("(.*)-([\\w]+?)-([\\w]+?)-([\\w]+?)$", "$1 , $2 , $3 , $4");

        System.out.println("[" + str + "]\t\t\t=> [" + output + "]");
    }
}

OUTPUT:

[A-B-C-D]               => [A , B , C , D]
[A-B-C-D-E-F-E-G]       => [A-B-C-D-E , F , E , G]
[AAAA-BBB-CCC-DD-EE]    => [AAAA-BBB , CCC , DD , EE]
[BB-CC-DD-EE]           => [BB , CC , DD , EE]

score 0 · Answer 3 · answered Apr 11 '16 at 04:49

Since you want to have maximum four values after splitting, and you start splitting from the back, you can split by the following regex:

key.split("-(?!([^-]+-){3})");

The regex simply splits by a dash, as long as it can't find 3 dashes ahead. This results in the string being split at the last 3 dashes. Assuming that the input string does not end with dash, the resulting array will have exactly 4 values.

Split the string based on number of occurrences in Java

3 Answers3