Java 8 Streams - implementing Collector Examples

Implementing Collector interface with Characteristics.CONCURRENT.

package com.logicbig.example;

import java.util.EnumSet;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class CollectorExample2 {
    public static void main (String[] args) {
        String s = Stream.of("Mike", "Nicki", "John")
                         .parallel()
                         .unordered()
                         .collect(new MyCollector());
        System.out.println(s);
    }

    private static class MyCollector implements
                        Collector<String, StringBuffer, String> {

        @Override
        public Supplier<StringBuffer> supplier () {
            return () -> {
                System.out.println("supplier call");
                return new StringBuffer();
            };
        }

        @Override
        public BiConsumer<StringBuffer, String> accumulator () {
            return (sb, s) -> {
                System.out.println("accumulator function call,"
                                    + " accumulator container: "
                                    + System.identityHashCode(sb)
                                    + " thread: "
                                    + Thread.currentThread().getName()
                                    + ", processing: " + s);
                sb.append(" ").append(s);
            };
        }

        @Override
        public BinaryOperator<StringBuffer> combiner () {
            return (stringBuilder, s) -> {
                System.out.println("combiner function call");
                return stringBuilder.append(s);
            };
        }

        @Override
        public Function<StringBuffer, String> finisher () {
            return stringBuilder -> stringBuilder.toString();
        }

        @Override
        public Set<Characteristics> characteristics () {
            //  return Collections.emptySet();
            return EnumSet.of(Characteristics.CONCURRENT);
        }
    }
}

Output

supplier call
accumulator function call, accumulator container: 1362387712 thread: com.logicbig.example.CollectorExample2.main(), processing: Nicki
accumulator function call, accumulator container: 1362387712 thread: ForkJoinPool.commonPool-worker-2, processing: John
accumulator function call, accumulator container: 1362387712 thread: ForkJoinPool.commonPool-worker-1, processing: Mike
 Nicki John Mike

Original Post

Using Characteristics.IDENTITY_FINISH which directly returns the instance created in the supplier() instead of using the finisher() function for a conversion.

package com.logicbig.example;

import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class CollectorExample4 {
    public static void main (String[] args) {
        List<String> s = Stream.of("Mike", "Nicki", "John")
                               .parallel()
                               .collect(new MyCollector());
        System.out.println(s);
    }

    private static class MyCollector implements
                        Collector<String, List<String>, List<String>> {


        @Override
        public Supplier<List<String>> supplier () {
            return ArrayList::new;
        }

        @Override
        public BiConsumer<List<String>, String> accumulator () {
            return List::add;
        }

        @Override
        public BinaryOperator<List<String>> combiner () {
            return (list, list2) -> {
                list.addAll(list2);
                return list;
            };
        }

        @Override
        public Function<List<String>, List<String>> finisher () {
            return null;
        }

        @Override
        public Set<Characteristics> characteristics () {
            //   return Collections.emptySet();
            return EnumSet.of(Characteristics.IDENTITY_FINISH);
        }
    }
}

Output

[Mike, Nicki, John]

Original Post

package com.logicbig.example;

import java.util.Collections;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class CollectorExample {
    public static void main (String[] args) {
        String s = Stream.of("Mike", "Nicki", "John").collect(new
                            MyCollector());
        System.out.println(s);
    }

    private static class MyCollector implements
                        Collector<String, StringBuilder, String> {

        @Override
        public Supplier<StringBuilder> supplier () {
            return StringBuilder::new;
        }

        @Override
        public BiConsumer<StringBuilder, String> accumulator () {
            return (sb, s) -> sb.append(" ").append(s);
        }

        @Override
        public BinaryOperator<StringBuilder> combiner () {
            return (sb1, sb2) -> sb1.append(sb2);
        }

        @Override
        public Function<StringBuilder, String> finisher () {
            return stringBuilder -> stringBuilder.toString();
        }

        @Override
        public Set<Characteristics> characteristics () {
            return Collections.emptySet();
        }
    }
}

Output

 Mike Nicki John

Original Post

Using CONCURRENT along with UNORDERED characteristics.

package com.logicbig.example;

import java.util.EnumSet;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class CollectorExample3 {
    public static void main (String[] args) {
        String s = Stream.of("Mike", "Nicki", "John")
                         .parallel()
                         .collect(new MyCollector());
        System.out.println(s);
    }

    private static class MyCollector implements
                        Collector<String, StringBuffer, String> {

        @Override
        public Supplier<StringBuffer> supplier () {
            return () -> {
                System.out.println("supplier call");
                return new StringBuffer();
            };
        }

        @Override
        public BiConsumer<StringBuffer, String> accumulator () {
            return (sb, s) -> {
                System.out.println("accumulator function call,"
                                    + " accumulator container: "
                                    + System.identityHashCode(sb)
                                    + " thread: "
                                    + Thread.currentThread().getName()
                                    + ", processing: " + s);
                sb.append(" ").append(s);
            };
        }

        @Override
        public BinaryOperator<StringBuffer> combiner () {
            return (stringBuilder, s) -> {
                System.out.println("combiner function call");
                return stringBuilder.append(s);
            };
        }

        @Override
        public Function<StringBuffer, String> finisher () {
            return stringBuilder -> stringBuilder.toString();
        }

        @Override
        public Set<Characteristics> characteristics () {
            //   return Collections.emptySet();
            return EnumSet.of(Characteristics.CONCURRENT
                                , Characteristics.UNORDERED);
        }
    }
}

Output

supplier call
accumulator function call, accumulator container: 1362387712 thread: com.logicbig.example.CollectorExample3.main(), processing: Nicki
accumulator function call, accumulator container: 1362387712 thread: ForkJoinPool.commonPool-worker-2, processing: John
accumulator function call, accumulator container: 1362387712 thread: ForkJoinPool.commonPool-worker-1, processing: Mike
 Nicki John Mike

Original Post

Java 8 Streams - implementing Collector Examples

Output

Output

Output

Output

See Also