Streaming substrings of a string

Question

Given a (long) string src, generate substrings (up to) len characters long on demand by iterating over src and shifting the reading frame by shift characters every time.

StreamSupport.stream works for me, but is there a better (more idiomatic) way to do this, for example, by using a method like Stream.iterate and providing a Predicate and UnaryOperator?

/**
 * Streams strings of length up to len. Each streamed string is created from the string src by removing
 * first "shift" characters and adding last "shift" characters. The shifting starts from 2nd string onward. It's
 * like traversing the given string by a fixed length frame that shifts forward "shift" characters at a time.
 *
 * @param src   the source string, e.g. "abcde"
 * @param len   max length of the string to be streamed, no string streamed from this method will exceed this length, e.g. 2
 * @param shift integer shift-width to traverse src, e.g. 1
 * @return a Stream of strings, e.g. the above will stream "ab", "bc", "cd", and "de"
 */

private static Stream<String> streamStrings(String src, int len, int shift) {
    Iterator<String> traverser = new Iterator<>() {
        private int i = 0, j = Math.min(len, src.length()); // substring(i, j) is what we need

        @Override
        public boolean hasNext() {
            return i < j && j <= src.length();
        }

        @Override
        public String next() {
            String n = src.substring(i, j);
            i += shift;
            if (j < src.length())
                j = Math.min(i + len, src.length());
            else
                j  = i + len;
            return n;
        }
    };
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(traverser, Spliterator.SIZED), false);
}

Sample Call and Output

streamStrings("abcdef", 3, 2).forEach(System.out::println);
//abc
//cde
//ef

Answer 1

You should generally avoid multiple variable initializations on one line:

private int i = 0;
private int j = Math.min(len, src.length());

is more readable.

---

EDIT: The following suggestion is left in for reference, but is based on an incorrect assumption.

From your sample output I would assume the following desired behaviour as well:

streamStrings("abcdef", 2, 1).forEach(System.out::println);

// ab
// bc
// cd
// de
// ef
// f

which your implementation does not produce. I don't think you need the condition inside next() at all, the following should suffice instead:

j = Math.min(i + len, src.length());

Answer 2

• Braces should always be used even if the body of the if or else contains only a single statement.
• Missing input validation: shift=0 causes an infinite loop.
• One variable per declaration: as @riskypenguin also suggested, avoid declarations in one line like int i = 0, j = Math.min(len, src.length());

---

Using IntStream could be an alternative:

private static Stream<String> streamStrings(String src, int len, int shift) {
    long n = (long) Math.ceil( (double) (src.length() - len) / shift ) + 1;
    return IntStream.range(0, src.length())
            .filter(i -> i % shift == 0)
            .mapToObj(i -> src.substring(i, Math.min(i + len, src.length())))
            .limit(n);
}

Where:

• n: is the number of strings
• IntStream.range(0, src.length()).filter(i -> i % shift == 0): is a cluncky way to iterate from 0 to src.length() incrementing by shift. In Python would be range(0, len(src), shift).
• limit(n): limits the stream to n substrings.