Longest running string

You should keep 4 variables:

• The start index of the longest run
• The end index (or length) of the longest run
• The start index of the current run
• The iterating index

For performance, you'd likely also store the char of the current run in a variable.

When done iterating, return substring of longest run.

Far too many Strings. Why don't you store just a single character and count its repetitions, then copy the char and the number to some maxchar and maxnum if number > maxnum?

EDIT (code added):

public static int maxRun(String testString) {
    int len = testString.length();
    char maxchar = "!";
    int  maxlen = 0;
    char prevchar = "!";
    int  sublen = 0;

    for (int i = 0; i < len; ++i) {
        char curr = testString.charAt(i);
        if (curr == prevchar) {
            ++sublen;
        }
        else
        {
            if (sublen > maxlen) {
                maxchar = prevchar;
                maxlen = sublen;
            }
            prevchar = curr;
            sublen = 1;
        }
    }

    if (sublen > maxlen) {
        maxchar = prevchar;
        maxlen = sublen;
    }

    for (int i = maxlen; --i >= 0;)
        System.out.println(maxchar);
    System.out.println("");
    return maxlen;
}

It will be enough and cheaper to track the following variables:

• The length of the longest run seen so far
• The length of the current run
• The previous character
• The current character

Like this:

public static int longestRun(String testString) {
    int len = testString.length();
    if (len < 2) {
        return len;
    }

    int longest = 0;
    int currentRun = 1;

    char prev = testString.charAt(0);
    for (int i = 1; i < len; ++i) {
        char current = testString.charAt(i);
        if (current == prev) {
            ++currentRun;
        } else {
            if (currentRun > longest) {
                longest = currentRun;
            }
            currentRun = 1;
        }
        prev = current;
    }
    if (currentRun > longest) {
        longest = currentRun;
    }
    return longest;
}

This solution avoids unnecessary string concatenation, that is expensive.

Other notes:

• Instead of i += 1 at the end of the body of the for loop, it's better to put ++i in the for statement itself
• Since the purpose of your function is finding the "longest run", naming it longestRun would be more natural than maxRun

You should honour the "separation of concerns" principle, e.g. not printing something to the console and then returning another value. I think it is better to return the String of the longest sequence (as finding out the length is easy).

I tried my best to use the new Stream API, but here it feels quite awkward (suggestions are welcome):

public static String maxRun(String testString) {
    return testString.chars()
            .mapToObj(i -> (char) i)
            .reduce(new LinkedList<String>(),
                    (l, c) -> {
                        l.add((l.isEmpty() || l.getLast().charAt(0) != c)
                                ? "" + c : l.removeLast() + c);
                        return l;
                    }, (p, q) -> { p.addAll(q); return p; })
            .stream()
            .max(Comparator.comparing(String::length))
            .orElse("");
}

Since we're dealing with a String, I suspect that we can use a regular expression to String#split it into chucks for further processing. Specifically, we want a regular expression which will partition every time a character is not like the preceding one. We can do this with lookarounds:

private static final Pattern SPLIT_REGEX = Pattern.compile("(?<=(.))(?!\\1)");

This pattern matches anywhere that:

• (?<=(.)) given any preceding character we store in group 1 (positive lookbehind),

• (?!\\1) the following character does not match group 1 (negative lookahead).

So splitting the string aaabbcdd with this regex will produce the array ["aaa", "bb", "c", "dd"].

From there, we can stream and find the max element by string length:

import java.util.Arrays;
import java.util.Comparator;
import java.util.regex.Pattern;

public class StringRunCount {

  private static final Pattern SPLIT_REGEX = Pattern.compile("(?<=(.))(?!\\1)");

  public static String maxRun(final String string) {
    if (null == string) {
      throw new IllegalArgumentException("Argument cannot be null");
    }

    return Arrays.stream(SPLIT_REGEX.split(string))
        .max(Comparator.comparing(String::length))
        .get();
  }

  public static void main(final String[] args) {
    assert "a".equals(maxRun("a"));
    assert "aa".equals(maxRun("aab"));
    assert "bbbbb".equals(maxRun("abbbbbcc"));
    assert "aa".equals(maxRun("aabbccdd"));
  }

}

I learned about Comparator.comparing(String::length) from @Landei's answer, which I'm gracious for because I was expecting to be able to just pass in String::length by itself, originally. I also just call get on the Optional<String> returned by max because we've ruled out the only case the result could be null with our parameter check.

(Note that the last assert isn't necessarily valid, since any other two character substring would suffice.)