Split string to equal length substrings in Java

java

string-splitting

regex

guava

byNikita Barsukov·Aug 13, 2024

To separate a string in Java into fixed-size sections, you can employ a for loop alongside the substring() method. Given an str string and a chunk size n, the next snippet performs the splitting task:

String str = "exampleString"; //because examples can be stringy too 
int n = 3;
List<String> chunks = new ArrayList<>();
for (int i = 0; i < str.length(); i += n) {
    chunks.add(str.substring(i, Math.min(str.length(), i + n))); //splitting hairs, or strings?
}

The result? A list chunks with n character long substrings. Yes, the code even takes care of a potential shorter n at the end of the string.

Understanding the breakdown

Splitting strings in Java can be done various ways. Let's learn about the tools at hand for effective string dissection.

The regex and non-regex debate

Sure, a regex can feel like black magic with how fast it can split a string:

String[] substrings = str.split("(?<=\\G.{" + n + "})"); //abracadabra

But there's always a price:

Overhead: Regex brings added complexity, especially with different sized substrings.
Performance: Non-regex code can offer better efficiency and reliability with Java string splits.
Compatibility: Platforms like Android don't support \G in regex lookbehinds. Ouch!
Clarity: Non-regex solutions are like an open book. No mysteries here!

Libraries worth a glance

If you want to outsource some of the work, Guava library from Google has you covered for lots of string operations:

Iterable<String> chunks = Splitter.fixedLength(n).split(str);

Very friendly, isn't it? What's even better: you can store splitters in constants to easily reuse them.

Navigating UTF-16

Do your strings include characters outside the Basic Multilingual Plane (BMP)? Java encodes these characters using two char units. So splitting has to be done cautiously here to avoid nasty surprises.

Dealing with curveballs

Remember, in coding, it's either you control edge cases, or they control you. Let's keep them in check.

Catching edge cases

When you want to calculate the number of chunks, going for Math.ceil() might seem tempting, however, manual calculation keeps things accurate and free of floating-point issues:

int numChunks = (str.length() + n - 1) / n;  //Because who needs the math library anyway?

Efficient slicing with variable lengths

For those non-uniform substrings, a custom loop approach is your best bet to save you from the inefficient, hard-to-read regex patterns.

Caching your splitter

Need constant string splitting operations? Storing a constant reference to a splitter boosts reusability and efficiency. Talk about having your cake and eating it!