Stream equivalent for appending dash(-) after every 3rd char of string

Question

I have created simple for loop based solution to append dash(-) on every third digit.

 private String appendedDashOnEachThirdDigit(String digitString) {
    char digits[] = digitString.toCharArray();
    StringBuilder builder = new StringBuilder();

    for (int i = 0; i < digits.length; i++) {
      char ch = digits[i];
      builder.append(ch);
      if ((i + 1) % 3 == 0 && i - 1 != digits.length) {
        builder.append('-');
      }
    }
    return builder.toString();
  }

Now I want to create equivalent java 8 stream based solution. This is very basic case and I want to know how this can be done with stream api?

I have created this basic stream function:-

 private String appendedDashOnEachThirdDigitByStream(String digitString) { //char[] chars = digitString.toCharArray(); //return IntStream.range(0, chars.length) // .filter(i -> (i + 1) % 3 == 0 && i - 1 != chars.length) // .collect(Collectors.collectingAndThen(Collectors.toList(), // new Function<List<Object>, Object>() { // })) return digitString.chars() .mapToObj(value -> String.valueOf((char) value)) .collect(Collectors.joining("-")); }

Answer 1

While it is possible it is not best solution.

    class T {
        final int i;
        final int c;

        public T(int i, int c) {

            this.i = i;
            this.c = c;
        }
    }
    int[] i = {0};


    String res = "123456789".chars()
            .mapToObj(c -> new T(i[0]++, c))
            .collect(Collectors.groupingBy(x -> x.i / 3))
            .entrySet()
            .stream()
            .sorted(Comparator.comparing(Map.Entry::getKey))
            .map(x ->
                    x.getValue().stream().mapToInt(y -> y.c)
                            .mapToObj(y -> String.valueOf((char)y))
                            .collect(Collectors.joining())

            ).collect(Collectors.joining("-"));


    System.out.println("res = " + res);

Main problem here is that stream is good when your elements is independent. In your scenario processing depend on position so it required wired grouping.