Object collect(Collector collector) // Collector(인터페이스)를 구현한 클래스의 객체를 매개 변수로 사용 
Object collect(Supplier, BiConsumer accumulator, BiConsumer combiner) // Collector 중에서도 지정하여 사용, 잘 사용X

public interface Collector<T, A, R> { // T(요소)를 A에 누적 → 결과를 R로 변환 → 반환
    
    // T를 A에 누적하여 저장하다가 R로 변환하여 반환
    Supplier<A> supplier(); // 누적할 곳 : StringBuilder::new
    BiConsumer<A, T> accumulator(); // 누적 방법 : (sb, s) -> sb.append(s)
    BinaryOperator<A> combiner(); // 결합 방법(병렬) : (sb1, sb2) -> sb1.append(sb2) 
    Function<A, R> finisher(); // 최종 변환 : sb -> sb.toString()
    Set<Characteristics> chracteristics(); // 컬렉터의 특성이 담긴 set을 반환
    ...
}

Object collect(Collector collector) 

List<String> names 
    = stuStream
        .map(Student::getName) // Stream<Strudent> → Stream<String>
        .collect(Collectors.toList()); // Stream<String> → List<String>

ArrayList<String> list
    = names
        .stream()
        .collect(Collectors.toCollection(ArrayList::new)); // Stream<String> → ArrayList<String>

Map<String, Person> map
    = personStream
        .collect(Collectors.toMap(p -> p.getRegId(), p -> p)); // Stream<Person> → Map<String, Person>

Student[] stuNames = studentStream.toArray(Student[]::new); // OK

Student[] stuNames = studentStream.toArray(); // ERROR, 자동 형변환X
Student[] stuNames = (Student[])studentStream.toArray(); // OK, 수동 형변환O

Object[] stuNames = studentStream.toArray(); // OK

// 전체 count
long count = stuStream.count();

// 그룹별 count
// 그룹 지정하지 않으면 전체 count
long count = stuStream.collect(counting()); // Collectors.counting()

// 전체 sum
long totalScore = stuStream.mapToInt(Student::getTotalScore).sum();

// 그룹별 sum
// 그룹 지정하지 않으면 전체 sum
long totalScore = stuStream.collect(summingInt(Student::getTotalScore));

// 최대값
OptionalInt topScore = studentStream.mapToInt(Student::getTotalScore).max();

// 전체 max
Optional<Student> topStudent
    = stuStream
        .max(Comparator.comparingInt(Student::getTotalScore));

// 그룹별 max, 예를 들어 남자 1등 구할 때 사용
// 그룹 지정하지 않으면 전체 sum
Optional<Student> topStudent
    = stuStream
        .collet(maxBy(Comparator.comparingInt(Student::getTotalScore)));

Collector reducing(BinaryOperator<T> op)
Collector reducing(T identity, BinaryOperator<T> op) // 누적 작업(accumulator)
Collector reducing(U identity, Function<T, U> mapper, BinaryOperator<U> op) // T → U 변환이 필요할 때, map + reduce

IntStream intStream = new Random().ints(1, 46).distinct().limit(6);

// 전체 reducing
OptionalInt max = intStream.reduce(Integer::max);

// 그룹별 reducing
OptionalInt<Integer> max = intStream.boxed().collect(reducing(Integer::max);

// 전체 reducing
long sum = intStream.reduce(0, (a, b) -> a + b);

// 그룹별 reducing
long sum = intStream.boxed().collect(reducing(0, (a, b) -> a + b));

// 전체 reducing
int grandTotal = stuStream.map(Student::getTotalScore).reduce(0, Integer::sum);

// 그룹별 reducing
int grandTotal = stuStream.collect(reducing(0, Student::getTotalScore, Integer::sum));

String studentNames = stuStream.map(Student::getName).collect(joing());
String studentNames = stuStream.map(Student::getName).collect(joing(",")); // a, b, c
String studentNames = stuStream.map(Student::getName).collect(joing(",", "[", "]")); // [a, b, c]

String studentNames = stuStream.collect(joining(",")); // Student의 toString()으로 결합