Java Stream의 사용

/**
 * Returns a stream consisting of the distinct elements (according to
 * {@link Object#equals(Object)}) of this stream.
 *
 * <p>For ordered streams, the selection of distinct elements is stable
 * (for duplicated elements, the element appearing first in the encounter
 * order is preserved.)  For unordered streams, no stability guarantees
 * are made.
 *
 * <p>This is a <a href="package-summary.html#StreamOps">stateful
 * intermediate operation</a>.
 *
 * @apiNote
 * Preserving stability for {@code distinct()} in parallel pipelines is
 * relatively expensive (requires that the operation act as a full barrier,
 * with substantial buffering overhead), and stability is often not needed.
 * Using an unordered stream source (such as {@link #generate(Supplier)})
 * or removing the ordering constraint with {@link #unordered()} may result
 * in significantly more efficient execution for {@code distinct()} in parallel
 * pipelines, if the semantics of your situation permit.  If consistency
 * with encounter order is required, and you are experiencing poor performance
 * or memory utilization with {@code distinct()} in parallel pipelines,
 * switching to sequential execution with {@link #sequential()} may improve
 * performance.
 *
 * @return the new stream
 */
Stream<T> distinct();

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> key) {
  Map<Object, Boolean> seen = new ConcurrentHashMap<>();
  return t -> seen.putIfAbsent(key.apply(t), Boolean.TRUE) == null;
}

Map<String, Long> freq;
try (Stream<String> words = new Scanner(file).tokens()) {
    freq = words.collect(
            Collectors.groupingBy(String::toLowerCase, Collectors.counting())
    );
} catch (FileNotFoundException e) {

List<String> topTen = freq.keySet()
    .stream()
    .sorted(Comparator.comparing(freq::get).reversed())
    .limit(10)
    .collect(Collectors.toList());

int sum = widgets.stream()
  .filter(w -> w.getColor() == RED)
  .mapToInt(w -> w.getWeight())
  .sum();

// List<People>에서 사람들의 이름만 뽑아 리스트로 수집한다
List<String> list = people.stream()
    .map(Person::getName)
    .collect(Collectors.toList());

// List<People>에서 이름만 뽑아 TreeSet 으로 수집한다
Set<String> set = people.stream()
    .map(Person::getName)
    .collect(Collectors.toCollection(TreeSet::new));

// 리스트의 원소들을 콤마로 구분된 하나의 String으로 수집한다.
String joined = things.stream()
    .map(Object::toString)
    .collect(Collectors.joining(", "));

// 모든 직원 급여의 총합을 구한다
int total = employees.stream()
    .collect(Collectors.summingInt(Employee::getSalary));

// 부서별 직원 목록을 만든다
Map<Department, List<Employee>> byDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));

// 부서별 급여 합계를 구한다
Map<Department, Integer> totalByDept = employees.stream()
    .collect(
        Collectors.groupingBy(
            Employee::getDepartment,
            Collectors.summingInt(Employee::getSalary)
        )
    );

// PASS한 학생과 FAIL한 학생 리스트를 따로 수집한다
Map<Boolean, List<Student>> passingFailing = students.stream()
    .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

List<String> words = List.of("Cat", "Dog");

List<String> uniq = words.stream()
    .map(word -> word.split(""))
    .flatMap(Arrays::stream)
    .distinct()
    .collect(Collectors.toList());

// 결과는 ["C", "a", "t", "D", "o", "g"]

List<Integer> flat = Stream.of(10, 20, 30)
    .flatMap(x -> Stream.of(x, x + 1, x + 2))
    .collect(Collectors.toList());

// 결과는 [10, 11, 12, 20, 21, 22, 30, 31, 32]

IntStream intStream = Stream.of(new Person("Tom", 10), new Person("John", 8))
    .mapToInt(Person::getAge);
Stream<Integer> boxedStream = intStream.boxed();

Stream.iterate(0, n -> n + 1)
    .limit(10)
    .forEach(n -> System.out.printf("%d ", n));

// 0 1 2 3 4 5 6 7 8 9

Stream.iterate(new int[]{0, 1}, n -> new int[]{ n[1], n[0] + n[1]})
    .limit(20)
    .forEach(n -> System.out.printf("%d ", n[1]));

// 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

List<Integer> numbers = Stream.of(11, 16, 30, -8, 7, 4, 100)
    .filter(n -> n > 10)
    .collect(Collectors.toList());

// 11, 16, 30, 100

List<Integer> numbers = Stream.of(11, 16, 30, -8, 7, 4, 100)
    .takeWhile(n -> n > 10)
    .collect(Collectors.toList());

// 11, 16, 30

List<Integer> numbers = Stream.of(11, 16, 30, -8, 7, 4, 100, -10)
    .dropWhile(n -> n > 10)
    .collect(Collectors.toList());

// -8, 7, 4, 100, -10
// (11, 16, 30 은 n > 10 에 해당되어 모두 버려졌다)

Optional<Integer> sum = Stream.of(11, 16, 30, -8, 7, 4, 100, -10)
    .reduce(Integer::sum);
// 150

Optional<Integer> min = Stream.of(11, 16, 30, -8, 7, 4, 100, -10)
    .reduce(Integer::min);
// -10

OptionalInt mas = IntStream.of(11, 16, 30, -8, 7, 4, 100, -10)
    .max();
// 100

IntStream.range(1, 3).forEach(System.out::println);
// 1
// 2

IntStream.rangeClosed(1, 3).forEach(System.out::println);
// 1
// 2
// 3

IntStream.rangeClosed(1, 4).sum();  // 10

@Getter
class Person {
  int age; String name; Hobby hobby;

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

enum Hobby { Swimming, Reading, Writing }

Stream<Person> people = Stream.of(
  new Person("John", 45, Hobby.Swimming),
  new Person("Jane", 56, Hobby.Reading),
  new Person("Tom", 32, Hobby.Reading));

people.map(Person::getName)
  .collect(Collectors.joining());
// JohnJaneTom

people.map(Person::getName)
  .collect(Collectors.joining(", "));
// John, Jane, Tom

Optional<Person> oldestPerson = people.collect(
  Collectors.maxBy(Comparator.comparingInt(Person::getAge)));

Optional<Person> oldestPerson = people.max(
  Comparator.comparingInt(Person::getAge));

Optional<Person> oldestPerson = people.collect(
  Collectors.minBy(Comparator.comparingInt(Person::getAge)));

Optional<Person> oldestPerson = people.min(
  Comparator.comparingInt(Person::getAge));

int total = people.collect(Collectors.summingInt(Person::getAge));

int total = people.mapToInt(Person::getAge).sum();

double average = people.collect(
  Collectors.averagingDouble(Person::getAge));

IntSummaryStatistics statistics = people.collect(
        Collectors.summarizingInt(Person::getAge));

statistics.getAverage();  // 44.333333333333336
statistics.getCount();    // 3
statistics.getMax();      // 56
statistics.getMin();      // 32
statistics.getSum();      // 133

public static <T, K> Collector<T, ?, Map<K, List<T>>>
groupingBy(Function<? super T, ? extends K> classifier)

Map<Hobby, List<Person>> splitByHobby = people.collect(
  Collectors.groupingBy(Person::getHobby));

// Swimming: [John]
// Reading: [Jane, Tom]

Map<Boolean, List<Person>> splitByAge50 = people.collect(
  Collectors.groupingBy(p -> p.getAge() > 50));

// true: [Jane]
// false: [John, Tom]

public static <T> Collector<T, ?, Map<Boolean, List<T>>>
partitioningBy(Predicate<? super T> predicate)

Map<Boolean, List<Person>> splitByHobby = people.collect(
  Collectors.partitioningBy(
    p -> p.getHobby() == Hobby.Swimming));

    /**
...
     * @apiNote This method exists mainly to support debugging, where you want
     * to see the elements as they flow past a certain point in a pipeline:
     * <pre>{@code
     *     Stream.of("one", "two", "three", "four")
     *         .filter(e -> e.length() > 3)
     *         .peek(e -> System.out.println("Filtered value: " + e))
     *         .map(String::toUpperCase)
     *         .peek(e -> System.out.println("Mapped value: " + e))
     *         .collect(Collectors.toList());
     * }</pre>

Stream.of("one", "two", "three", "four")
    .filter(e -> e.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Stream.of("one", "two", "three", "four")
    .filter(e -> e.length() > 3)
    .peek(e -> System.out.println("Filtered value: " + e))
    .map(String::toUpperCase)
    .peek(e -> System.out.println("Mapped value: " + e))
    .collect(Collectors.toList());