Splitting the String to get all characters

[amit punekar]

Hello,
I need to split the String e.g. "AMIT" to get a String array that would contain all the characters (A,M,I,T).
I tried writing the regular expression to be used with String.split() method.
Here is the code that I tried

 
String str = "AMIT";
String arr = str.split("");

It works but with a small hitch, the first String in the array is EMPTY String.

Alternatively I can use the toCharArray() to get all the characters, but I want to work with the Strings instead of characters.

Thanks in advance,
Amit

[James Sabre]

        String[] arr = str.split("(?<!^)");

[amit punekar]

Hi James,
Thanks a lot.
Can you please help me understand it or point to the documentation that I can refer to ?
I have gone through various regex mentioned in the Java documentation but could not understand.

Thanks once again,
Amit

[James Sabre]

amit punekar wrote:Hi James,
Thanks a lot.
Can you please help me understand it or point to the documentation that I can refer to ?
I have gone through various regex mentioned in the Java documentation but could not understand.

Thanks once again,
Amit

Look at the Javadoc for Pattern and the section on 'negative look behind'. If you are in the early stages of working with regex then a good reference is here. If you are serious about learning about regular expression then buy the book "Mastering Regular Expressions" by Jeffrey Friedl published by O'Reilly. I can't give you the ISBN number since my copy is out way out of date (1997) but Google will find you the latest version.

[Rob Spoor]

You can use a negative lookbehind; check out the Javadoc of java.util.regex.Pattern:

string.split("(?<!^)")

This is the same as yours except I explicitly said to ignore the position just after the start (^).
edit: I posted a lookahead, not lookbehind. Fixed

However, I suggest you still use toCharArray(), then convert it to String[]. That is simply more efficient. Just try the following code:

import java.util.*;

public class Test
{
    public static void main(String[] args) throws Exception
    {
        final int count = 10000000;
        long start;
        long end;

        start = System.currentTimeMillis();
        for (int i = 0; i < count; i++)
        {
            split1("AMIT");
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);

        start = System.currentTimeMillis();
        for (int i = 0; i < count; i++)
        {
            split2("AMIT");
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);

        System.out.println(Arrays.toString(split1("AMIT")));
        System.out.println(Arrays.toString(split2("AMIT")));
    }

    private static String[] split1(String string)
    {
        char[] chars = string.toCharArray();
        String[] strings = new String[chars.length];
        for (int i = 0; i < chars.length; i++)
        {
            strings[i] = String.valueOf(chars[i]);
        }
        return strings;
    }

    private static String[] split2(String string)
    {
        return string.split("(?!^)");
    }
}

On my system, split1 is easily 10 times faster than split2. That's because with split2, using String.split, you create a java.util.regex.Pattern and java.util.regex.Matcher object each single time. It uses a List<String> to store the intermediate results (using Stirng.substring to create new String objects), then converts that List<String> into a String[].>

[James Sabre]

Rob Prime wrote:On my system, split1 is easily 10 times faster than split2. That's because with split2, using String.split, you create a java.util.regex.Pattern and java.util.regex.Matcher object each single time. It uses a List<String> to store the intermediate results (using Stirng.substring to create new String objects), then converts that List<String> into a String[].

So what happens to your benchmark result if you pre-compile the regex? And what happens if you perform make sure that the JIT has done it's job before doing the timing?

Adding code to your benchmark to cover both of these reduces the advantage on my machine to about a factor of 4. Still not good but "premature optimisation etc etc etc".

[Rob Spoor]

James Sabre wrote:So what happens to your benchmark result if you pre-compile the regex?

Using Pattern.split takes off about 33% of the time but it's still 8 times slower.

And what happens if you perform make sure that the JIT has done it's job before doing the timing?

How would I do that? I've just re-ran the tests with the same long loops after the first loops, so that's 10 million iterations after already having run 10 million iterations, and the results are similar.

"premature optimisation etc etc etc".

I agree but if I can replace using a regex with two simple loops (one for toCharArray internally, one for the copying) I'll definitely do that.

[James Sabre]

Rob Prime wrote:

James Sabre wrote:So what happens to your benchmark result if you pre-compile the regex?

Using Pattern.split takes off about 33% of the time but it's still 8 times slower.

And what happens if you perform make sure that the JIT has done it's job before doing the timing?

How would I do that? I've just re-ran the tests with the same long loops after the first loops, so that's 10 million iterations after already having run 10 million iterations, and the results are similar.

"premature optimisation etc etc etc".

I agree but if I can replace using a regex with two simple loops (one for toCharArray internally, one for the copying) I'll definitely do that.

To make sure the JIT has done it's job you just run the loops for a bit without actually timing the result. I typically use about 10% so each of your loops then starts with something like

      for (int i = -count / 10; i < count; i++)
        {
            if (i == 0)
                start = System.currentTimeMillis();

As far as replacing a regex with two simple loops is concerned. There we have a different approach. With a such a simple regex as this, unless time was critical, I would always prefer the one line solution.

[Ireneusz Kordal]

James Sabre wrote:
Still not good but "premature optimisation etc etc etc".

Imagine how long it will take to understand a magic formula (?!^) by someone who will maintain your code in the future
and some day will must quickly fix a serious bug but will not be an expert in regular expressions.

[Rob Spoor]

Especially considering you've copied my error that uses a lookahead instead of lookbehind

[James Sabre]

Ireneusz Kordal wrote:

James Sabre wrote:
Still not good but "premature optimisation etc etc etc".

Imagine how long it will take to understand a magic formula (?!^) by someone who will maintain your code in the future
and some day will must quickly fix a serious bug but will not be an expert in regular expressions.

That is a simple regular expression so this does not wash as an argument. Using your argument one would never ever ever use anything except the most trival algorithms. One would use crude DFT rather than FFT. One would use brute force rather than Dijkstra when looking for shortest paths. One would use simple linear search rather than KMP.

I expect programmers to understand basic tools and I regard regex as a basic tool.

[Paul Clapham]

James Sabre wrote:That is a simple regular expression so this does not wash as an argument. Using your argument one would never ever ever use anything except the most trival algorithms. One would use crude DFT rather than FFT. One would use brute force rather than Dijkstra when looking for shortest paths. One would use simple linear search rather than KMP.

I expect programmers to understand basic tools and I regard regex as a basic tool.

If two programmers who know regex quite well have to discuss un-simple topics like negative look-behind and go through several versions before coming up with a correct regex, then I wouldn't classify the regex as "simple".

And given the choice between a non-simple regex and calling the toCharArray() method of String, I would choose the latter regardless of what developers I expected to be maintaining the code in the future. This is one case when the most trivial algorithm is also the most appropriate, since it does what has to be done faster and more transparently than the more complex algorithm.

[Rob Spoor]

James Sabre wrote:I regard regex as a basic tool.

I think that's where we disagree on most. Regexes are very useful, true, but definitely not "basic". I've bought and read "Mastering Regular Expressions" and its writers too agree that regular expressions are far from a simple topic. There's a reason there are many books on regexes.

[James Sabre]

Rob Prime wrote:

James Sabre wrote:I regard regex as a basic tool.

I think that's where we disagree on most. Regexes are very useful, true, but definitely not "basic". I've bought and read "Mastering Regular Expressions" and its writers too agree that regular expressions are far from a simple topic. There's a reason there are many books on regexes.

Is counting published books on a topic a good metric for the complexity of a topic? How many books are there on Java basics? I have just 3 and two of them are rubbish but I know that there are dozens out there. If there are more published books on elementary Java than on regex does that make elementary Java more complex than regex?

This is turning into a religious argument so I will bow out now.

[Rob Spoor]

I think that is a very good idea. Let's just agree that both solutions work so it's up to the developer to choose the one he wants.

[Paul Clapham]

James Sabre wrote:Is counting published books on a topic a good metric for the complexity of a topic?

Far from it. It's a metric for the level of interest in a topic.

This is turning into a religious argument so I will bow out now.

I don't find it particularly religious but I do agree with Rob Prime's last post. We're done with answering Amit's question.

[Mike Simmons]

Ignoring the other issues raised, here's an even faster solution, similar to the toCharArray() but without the unnecessary copying of data:

  private static String[] split3(String string) {
    String[] strings = new String[string.length()];
    for (int i = 0; i < strings.length; i++) {
      strings[i] = string.substring(i, i + 1);
    }
    return strings;
  }

[amit punekar]

Hello,
Thank you James and Rob for your valuable inputs.
I would certainly say whichever path anyone choose to do this task would certainly get enlightened by this discussion thread.
Thank you very much once again and appreciate your time for letting me know other faces of the problem as well.

Thanks,
Amit

[David Newton]

Could just skip the first array entry :/

[Mike Simmons]

Mmm, I'm not following you there David. Why would the first entry be skipped?

[David Newton]

Mike Simmons wrote:Mmm, I'm not following you there David. Why would the first entry be skipped?

From the original post:

It works but with a small hitch, the first String in the array is EMPTY String.

It's not all about you ;)

[amit punekar]

Hi David,
I did it earlier to skip the first token, but then was trying to get elegant way handling this.

Thanks for the reply,
Amit