Argthtjtr

I was trying to write a mkString function in Java8, a la Scala's useful mkString and ran into 2 issues that I could use some help on:

1. I am unable to make the first argument of mkString a generic Collection reference like Collection<Object> c and have invokers call with ANY type of collection.




2. Unable to reference the returned result of reduce() in-line to access the result's length to remove the extra leading separator.

Here's the code :

public static void main(String args) {

    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println(mkString(numbers, ","));



}



public static String mkString(Collection<Integer> c, String sep) {

    return c.stream()

            .map(e -> String.valueOf(e))

            .reduce("", (a, b) -> a + sep + b)

            .substring(1, <<>>.length);

}

Note that if you're doing this not for self-education but to actually use it in some production code, you might want to consider the built-in Collectors.joining collector:

String result = numbers.stream().collect(Collectors.joining(","));

It has several overloads, similar to Scala's mkString.

Additionally, there is the String.join method, but it works only for collections of strings.

You can do it like :

public static <T>  String mkString(Collection<T> c, String sep) { // generic impl

    return c.stream()

            .map(String::valueOf)

            .reduce("", (a, b) -> a + sep + b)

            .substring(1); // substring implementation to strip leading character

}

If I remember my java correctly, you can declare the argument type as Collection<?> to be able to pass a collection of any objects.

As to biting the separator off, I think, just .substring(1) will do what you want.

Any type of collection in java means Collection<?>, which semantically is the same as Collection<T> (in your case), it is said that if the type parameter is used only once) it can safely be replaced with a wildcard. But, since you want to be able to concat any collection, you should also ask for the callers to supply a Function that would transform from that type to a String representation, thus your method would become:

public static <T> String mkString(Collection<T> c,

                                  Function<T, ? extends CharSequence> mapper,

                                  String sep) {

    return c.stream()

            .map(mapper)

            .collect(Collectors.joining(sep));



}

You can utilize String.join with a generic type:

public static <T> String mkString(Collection<T> c, String sep) {

    return String.join(sep, c.stream()

                             .map(e -> String.valueOf(e))

                             .collect(Collectors.toList()));

}

Here it is in action with both Strings and other objects.