why the need to use reduce in Java 8 ?

[tangara goh]

Hi,

I am starting to revise Java 8 and then I come across this code from https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html#StreamOps

    int sum = numbers.stream().reduce(0, (x,y) -> x+y);
 

or:


    int sum = numbers.stream().reduce(0, Integer::sum);
 

but it can accomplish with the following :

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
        int sum = numbers.stream().mapToInt(Integer::intValue).sum();
        System.out.println("Sum: " + sum);

I am terribly confusing....

[Campbell Ritchie]

But you can't use mapToInt() in the following scenario.

String noSpaces =
   /* Take array and make Stream to transmit it */
   Arrays.stream(
   /* Create array */
            "Campbell Ritchie is brilliant".split(" "))
   /* Reduce to Optional */
   .reduce((x, y) -> x + y)
   /* Get result fromOptional */
   .orElse("No result");

By the way, read the documentation for reduce() and find out why

xyz.reduce((x, y) -> x - y)

won't work correctly.

[tangara goh]

I read the Oracle site but there is this part :
Or we could use a parallelizable collect form:


    ArrayList<String> strings = stream.collect(() -> new ArrayList<>(),
                                               (c, e) -> c.add(e.toString()),
                                               (c1, c2) -> c1.addAll(c2));


or, pulling the mapping operation out of the accumulator function, we could express it more succinctly as:


    List<String> strings = stream.map(Object::toString)
                                 .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

what is stream here ?

[Campbell Ritchie]

You doubtless already know that there are usually multiple ways to do the same thing. The link you provided seems to say the same in Java22.
In the second code example (please use the code button) you are creating a Collector from its three parts. that makes it easier to run in parallel. The example you showed creates a List (actually, it is very specific about the exact sort of List wanted), and that is a starting point, calling the List's constructor.
The middle part tells you that whenever you encounter an element, it is to be added with the add() method.
When the separate parallel operations finish, the two Lists are put together and one collects all the results from the other with the addAll() method.
The variable stream is a notional variable meaning any sort of Stream, irrespective of how you created it. It is of course, a Stream<T>, and the compiler “knows” how to choose all the other generic type parameters for the rest of the Stream's progress.

[tangara goh]

Campbell Ritchie wrote:
The variable stream is a notional variable meaning any sort of Stream, irrespective of how you created it. It is of course, a Stream<T>, and the compiler “knows” how to choose all the other generic type parameters for the rest of the Stream's progress.

public class Person {
	String name;
    int age;
    
    Person(){};

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name;
    }



static List<Person> persons =
    Arrays.asList(
        new Person("Max", 18),
        new Person("Peter", 23),
        new Person("Pamela", 23),
        new Person("David", 12));


public static void main(String[] args) {
	List<Person> filtered =
		   persons.stream()
		        .filter(p -> p.name.startsWith("P"))
		        .collect(Collectors.toList());

		System.out.println(filtered);    // [Peter, Pamela]
		
		List<String> strings = persons.map(Object::toString)
                .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
		
		
		List<Person>copy =  new ArrayList<>();
		copy = persons.map(Object::toString)
                .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
}

I am not getting it,  So I tried out the example using the class Person.  it dosn't work out...as in it refuse to transform the Object to String and then collect the elements from the Person in the static list and make it into a new one...I am not comprehending the functions at all.

[tangara goh]

Please ignore the above.  I got it finally.  
List<Person> copy = persons.stream()
                .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

System.out.println("what we have now is " + List.of(copy));

Note: the oracle's site using map instead of stream() really stumbled me...or is there something I did not comprehend about that part that uses

stream.map(Object::toString)

[Campbell Ritchie]

That would in your case take a Stream<Person> and map that person to a String (the name), and then create a new Stream<String>.
Find yourself a copy of Modern Java in Action by Urma Fusco and Mycroft (Manning, 2018) or one of its predecessors and read that. It is the best explanation of how Streams work that I can remember seeing.

[Mike Simmons]

tangara goh wrote:Note: the oracle's site using map instead of stream() really stumbled me...or is there something I did not comprehend about that part that uses

stream.map(Object::toString)

They aren't using map instead of stream.  They are using a map on a stream.  You don't see the call to the stream() method in their example - instead, they use a variable named "stream" to indicate that they're dealing with something that's already a stream. In your example, you still need the stream() call to convert a List to a Stream.  Compare these two possibilities:

    List<String> strings = persons.stream()
      .map(Object::toString)
      .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

    List<Person>  copy = persons.stream()
      .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

One gives you a List of Strings, while the other gives a List of Persons.  Which is correct will depend on what you need to do with this list - which do you need?

[Mike Simmons]

Campbell Ritchie wrote:But you can't use mapToInt() in the following scenario.

String noSpaces =
   /* Take array and make Stream to transmit it */
   Arrays.stream(
   /* Create array */
            "Campbell Ritchie is brilliant".split(" "))
   /* Reduce to Optional */
   .reduce((x, y) -> x + y)
   /* Get result fromOptional */
   .orElse("No result");

Interestingly though, this code masks a rather inefficient implementation, which is roughly equivalent to:

    var array = "Campbell Ritchie is brilliant".split(" ");
    String result;
    if (array.length == 0) {
      result = "No result";
    } else {
      result = array[0];
      for (int i = 1; i < array.length; i++) {
        result = result + array[i];
      }
    }

This is mostly OK... until we get to the

        result = result + array[i];

which is concatenating a String inside a loop.  This is probably fine for a small number of iterations - in this case, we have just four elements.  But it's O(n*n) performance overall, because every single time we go through the loop, we're building a new String by recopying everything in the previous string, plus one more word.  As the string length increases, the performance just gets worse and worse.  Instead, we'd be much better off with

      Arrays.stream("Campbell Ritchie is brilliant".split(" "))
        .collect(Collector.of(
          StringBuilder::new,
          (c, s) -> c.append(s),
          StringBuilder::append,
          Object::toString
        ));

Or

      String noSpaces = Arrays.stream("Campbell Ritchie is brilliant".split(" "))
        .collect(Collectors.joining());

Of course, this effect could also be achieved more easily with

      String noSpaces = "Campbell Ritchie is brilliant".replace(" ",  "");

But that wasn't your point. ;)

Campbell Ritchie wrote:By the way, read the documentation for reduce() and find out why

xyz.reduce((x, y) -> x - y)

won't work correctly.

Aside from the fact that String has no "-" operator defined?  I guess you meant using the Integer example from before, not the String version you just gave.

[Mike Simmons]

I forget what the trick is to remove the < br /> nonsense - obviously, that wasn't in my original.

[Simon Roberts]

In case it's helpful to anyone looking at this later, the simple answer to the original title question "why the need to use reduce?" might reasonably be presented like this:

reduce (in it's various forms, along with collect which is a close relative) allows the creation of a single object as a "final answer" built from all the data in the stream. This is a sufficiently common requirement that a great many "special cases" are provided pre-built, including several, starting with sum(), that were discussed along the course of the thread.

IOW, if you can find a special case solution, use it. If your use case hasn't been coded up for you in a library, build it using reduce, or perhaps collect.

[Campbell Ritchie]

Mike Simmons wrote:. . . Aside from the fact that String has no "-" operator defined?  I guess you meant using the Integer example from before . . .

Yes, I did.

Sorry, but I can't work out how to get rid of the <br/> tags.