chapter 6 문제풀이 (6.5.2 응용하기 참고)

1. reverse 구현

public static void main(String[] args) {
List numbers = Arrays.asList(1, 2, 3, 4, 5);

    List<Integer> result = numbers.stream()
            .collect(new ReverseCollector<>());

    System.out.println(result);  // [5, 4, 3, 2, 1]

}

```java
public class ReverseCollector<T> implements Collector<T, List<T>, List<T>> {
    @Override
    public Supplier<List<T>> supplier() {
        return ArrayList::new; //수집 연산의 시발점
    }

    public BiConsumer<List<T>, T> accumulator() {
        return List::add; //  탐색한 항목을 누적하고 바로 누적자를 고친다.
    }

    @Override
    public Function<List<T>, List<T>> finisher() {
        return (list)->{
            Collections.reverse(list);
        return list;}; 
    }

    @Override
    public BinaryOperator<List<T>> combiner() {
        return (list1, list2) -> { // 두 번째 콘텐츠와 합쳐서 첫 번째 누적자를 고친다.
            list1.addAll(list2); //변경된 첫 번째 누적자를 반환한다.
            return list1;
        };
    }
    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(
            EnumSet.of(UNORDERED, CONCURRENT)); // 컬렉터의 플래그를 IDENTITY_FINISH,CONCURRENT로 설정한다.
    }
}

2. String concat 구현

public static void main(String[] args) {
        List<String> words = Arrays.asList("Hello", " ", "world", "!");

        String result = words.stream()
                .collect(new StringConcatCollector());

        System.out.println(result);  // Hello world!
}

public class StringConcatCollector implements Collector<String, List<String>,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 null;
    }

    @Override
    public Function<List<String>, String> finisher() {
        return (list)->{

        return String.join("",list);};
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(
            EnumSet.of(UNORDERED, CONCURRENT)); // 컬렉터의 플래그를 IDENTITY_FINISH,CONCURRENT로 설정한다.
    }
}

3. 홀짝 분리

   public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
   
        Map<Boolean, List<Integer>> result = numbers.stream()
                .collect(new EvenOddPartitionCollector<>());
   
        List<Integer> evens = result.get(true);
        List<Integer> odds = result.get(false);
   
        System.out.println("Evens: " + evens);  // Evens: [2, 4, 6, 8, 10]
        System.out.println("Odds: " + odds);  // Odds: [1, 3, 5, 7, 9]
   }
   

```java
public class EvenOddPartitionCollector<Integer> implements Collector<Integer, List<Integer>, Map<Boolean, List<Integer>>> {

    @Override
    public Supplier<List<Integer>> supplier() {
        return ArrayList::new; //수집 연산의 시발점
    }

    @Override
    public BiConsumer<List<Integer>, Integer> accumulator() {
        return List::add; //  탐색한 항목을 누적하고 바로 누적자를 고친다.
    }

    @Override
    public BinaryOperator<List<Integer>> combiner() {
        return null;
    }

    @Override
    public Function<List<Integer>, Map<Boolean, List<Integer>>> finisher() {
        return (list)->{
            Map<Boolean, List<Integer>> resultMap = new HashMap<>();
            List<Integer> evenList = new ArrayList<>();
            List<Integer> oddList = new ArrayList<>();
            for(int i=0; i<list.size();i++){
                if(checkEvenOdd((java.lang.Integer)list.get(i))){
                    evenList.add(list.get(i));
                }else{
                    oddList.add(list.get(i));
                }
            };
            resultMap.put(true,evenList);
            resultMap.put(false,oddList);

            return resultMap;
            };
    }
    public static boolean checkEvenOdd(int num) {
        if (num % 2 != 1) {
            return true;
        } else {
            return false;
        }
    }
    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(
            EnumSet.of(UNORDERED, CONCURRENT)); // 컬렉터의 플래그를 IDENTITY_FINISH,CONCURRENT로 설정한다.
    }
}