자바 스 트림 의 Collector 소스 노트

package java.util.stream;

import java.util.Collections;
import java.util.EnumSet;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * A mutable reduction operation that
 * accumulates input elements into a mutable result container, optionally transforming
 * the accumulated result into a final representation after all input elements
 * have been processed.  Reduction operations can be performed either sequentially
 * or in parallel.
            ，                  ，          stream      ，           。            ，       。
 *
 * 
Examples of mutable reduction operations include:
 * accumulating elements into a {@code Collection}; concatenating
 * strings using a {@code StringBuilder}; computing summary information about
 * elements such as sum, min, max, or average; computing "pivot table     " summaries
 * such as "maximum valued transaction by seller", etc.  The class {@link Collectors}
 * provides implementations of many common mutable reductions.
         ：       ，     ，     ，       ，  ‘           ’，                    。
 *
 * 
A {@code Collector} is specified by four functions that work together to
 * accumulate entries into a mutable result container, and optionally perform
 * a final transform on the result.  They are: 

   Collector                        ，                。   ：
 *     
creation of a new result container ({@link #supplier()})
    ，        。
 *     
incorporating a new data element into a result container ({@link #accumulator()})
    ，               。
 *     
combining two result containers into one ({@link #combiner()})
    ，            。
 *     
performing an optional final transform on the container ({@link #finisher()})
    ，                     。
 * 
 *
 * 
Collectors also have a set of characteristics, such as
 * {@link Characteristics#CONCURRENT}, that provide hints that can be used by a
 * reduction implementation to provide better performance.
            ，                           。
 *
 * 
A sequential implementation of a reduction using a collector would
 * create a single result container using the supplier function, and invoke the
 * accumulator function once for each input element.  A parallel implementation
 * would partition the input, create a result container for each partition,
 * accumulate the contents of each partition into a subresult for that partition,
 * and then use the combiner function to merge the subresults into a combined
 * result.
                          ，              。
                  ，                ，               ，                  ，                 。
 *
 * 
To ensure that sequential and parallel executions produce equivalent
 * results, the collector functions must satisfy an identity and an
 * associativity constraints.
                       ，                 。
 
 
 * 
The identity constraint says that for any partially accumulated result,
 * combining it with an empty result container must produce an equivalent
 * result.  That is, for a partially accumulated result {@code a} that is the
 * result of any series of accumulator and combiner invocations, {@code a} must
 * be equivalent to {@code combiner.apply(a, supplier.get())}.
        ，           ，        ，           。
          ，            ，    combiner.apply(a, supplier.get())    。
 *
 * 
The associativity constraint says that splitting the computation must
 * produce an equivalent result.  That is, for any input elements {@code t1}
 * and {@code t2}, the results {@code r1} and {@code r2} in the computation
 * below must be equivalent:
      ，              ，         。
      ，r1,       ，     
  r2，        ，           ，    。
     r1    r2.
 * 
{@code
 *     A a1 = supplier.get();
 *     accumulator.accept(a1, t1);
 *     accumulator.accept(a1, t2);
 *     R r1 = finisher.apply(a1);  // result without splitting
 *
 *     A a2 = supplier.get();
 *     accumulator.accept(a2, t1);
 *     A a3 = supplier.get();
 *     accumulator.accept(a3, t2);
 *     R r2 = finisher.apply(combiner.apply(a2, a3));  // result with splitting
 * } 
*
* For collectors that do not have the {@code UNORDERED} characteristic,
* two accumulated results {@code a1} and {@code a2} are equivalent if
* {@code finisher.apply(a1).equals(finisher.apply(a2))}.  For unordered
* collectors, equivalence is relaxed to allow for non-equality related to
* differences in order.  (For example, an unordered collector that accumulated
* elements to a {@code List} would consider two lists equivalent if they
* contained the same elements, ignoring order.)
특성 이 없 는 누적 작업 의 경우 a1 과 a2 가 finisher. apply (a1). equals (finisher. apply (a2) 를 만족 시 키 면
그러면 a1 은 a2 와 같다.
무질서 한 집합 에 있어 서 상등 성의 요 구 는 약간 완화 된다. 예 를 들 어 무질서 한 집합 이 다른 집합 과 비교 할 때 그들 이 포함 하 는 요소 가 똑 같 으 면 그들 과 같다 고 본다.
*
* Libraries that implement reduction based on {@code Collector}, such as
* {@link Stream#collect(Collector)}, must adhere to the following constraints:
Collector 인 터 페 이 스 를 기반 으로 한 라 이브 러 리 는 제약 을 지 켜 야 합 니 다.
* 
*      
 The first argument passed to the accumulator function, both
*     arguments passed to the combiner function, and the argument passed to the
*     finisher function must be the result of a previous invocation of the
*     result supplier, accumulator, or combiner functions. 
누산기 의 첫 번 째 매개 변 수 는 반드시 이전에 생산 자 를 호출 한 결과 여야 한다.
병합 기의 두 매개 변 수 는 이전에 누산기 를 호출 한 결과 여야 합 니 다.
종결 기의 인 자 는 이전에 병합 기 를 호출 한 결과 여야 합 니 다.
*      
 The implementation should not do anything with the result of any of
*     the result supplier, accumulator, or combiner functions other than to
*     pass them again to the accumulator, combiner, or finisher functions,
*     or return them to the caller of the reduction operation. 
실현 류 는 생산자, 누산기, 합병 기, 종결 기의 매개 변 수 를 전달 하고 결 과 를 호출 자 에 게 되 돌려 주 는 것 을 제외 하고 그들의 조작 결 과 를 수정 할 수 없다.
*      
 If a result is passed to the combiner or finisher
*     function, and the same object is not returned from that function, it is
*     never used again. 
만약 하나의 결과 가 조합 기 나 종결 기 에 전달 되 었 다 면, 그것 은 다시 돌아 오지 않 을 것 이 며, 다 시 는 사용 되 지 않 을 것 이다.
*      
 Once a result is passed to the combiner or finisher function, it
*     is never passed to the accumulator function again. 
만약 하나의 결과 가 조합 기 나 종결 기 에 전달 되 었 다 면, 그것 은 더 이상 누산기 에 전달 되 지 않 을 것 이다.
*      
 For non-concurrent collectors, any result returned from the result
*     supplier, accumulator, or combiner functions must be serially
*     thread-confined.  This enables collection to occur in parallel without
*     the {@code Collector} needing to implement any additional synchronization.
*     The reduction implementation must manage that the input is properly
*     partitioned, that partitions are processed in isolation, and combining
*     happens only after accumulation is complete. 
동기 화 되 지 않 은 수집 기 에 대해 서 는 생산자, 누적 기, 조합 기 에서 돌아 오 는 결 과 는 직렬 스 레 드 에 의 해 제한 되 어야 합 니 다. 이 는 수집 작업 을 병행 할 수 있 고 추가 적 인 동기 화 작업 에 의존 할 필요 가 없습니다.
병합 작업 의 실현 류 는 입력 이 적당 한 파 티 션 을 확보 하고 이 파 티 션 들 은 격 리 되 어야 하 며 조합 작업 은 누적 작업 이 완 료 된 후에 해 야 한다.
*      
 For concurrent collectors, an implementation is free to (but not
*     required to) implement reduction concurrently.  A concurrent reduction
*     is one where the accumulator function is called concurrently from
*     multiple threads, using the same concurrently-modifiable result container,
*     rather than keeping the result isolated during accumulation.
*     A concurrent reduction should only be applied if the collector has the
*     {@link Characteristics#UNORDERED} characteristics or if the
* 원본 데 이 터 는 정렬 되 지 않 습 니 다. 
동기 화 수집 기 에 대해 서 는 클래스 를 동기 화 할 필요 가 없습니다. 동기 화 병합 작업 은 다 중 스 레 드 에 의 해 동기 화 되 고 동기 화 가 변 용 기 를 결과 용기 로 사용 하 는 것 입 니 다. 누적 기간 동안 결과 의 격 리 를 유지 하 는 것 이 아 닙 니 다. 동기 화 수집 기 는 무질서 한 집합 에 만 사용 되 어야 합 니 다.
* 
*
* In addition to the predefined implementations in {@link Collectors}, the
* static factory methods {@link #of(Supplier, BiConsumer, BinaryOperator, Characteristics...)}
* can be used to construct collectors.  For example, you could create a collector
* that accumulates widgets into a {@code TreeSet} with:
미리 정 의 된 수집 기 를 제외 하고 트 리 셋 을 수집 하 는 Collector 를 사용자 정의 할 수 있 습 니 다.
*
*  
{@code
 *     Collector> intoSet =
 *         Collector.of(TreeSet::new, TreeSet::add,
 *                      (left, right) -> { left.addAll(right); return left; });
 * }
*
* (This behavior is also implemented by the predefined collector
* {@link Collectors#toCollection(Supplier)}).
*
* @apiNote
* Performing a reduction operation with a {@code Collector} should produce a
* result equivalent to:
수집 기 를 사용 하여 병합 작업 을 수행 합 니 다. 그 결 과 는 다음 과 같 아야 합 니 다.
*  
{@code
 *     R container = collector.supplier().get();
 *     for (T t : data)
 *         collector.accumulator().accept(container, t);
 *     return collector.finisher().apply(container);
 * }
*
* 그러나 라 이브 러 리 는 입력 을 분할 하고 감 소 를 수행 할 수 있 습 니 다.
* on the partitions, and then use the combiner function to combine the partial
* results to achieve a parallel reduction.  (Depending on the specific reduction
* operation, this may perform better or worse, depending on the relative cost
* of the accumulator and combiner functions.)
어쨌든 클래스 가 자 유 롭 게 분 구 될 수 있 고 분 구 에서 병합 을 실행 한 다음 에 조합 기 를 사용 하여 분 구 결 과 를 조합 하여 병렬 병합 을 실현 합 니 다.
(성능 은 특정한 누적 과 조합 작업 의 성능 에 달 려 있다)
*
* Collectors are designed to be composed; many of the methods
* in {@link Collectors} are functions that take a collector and produce
* a new collector.  For example, given the following collector that computes
* the sum of the salaries of a stream of employees:
수집 기 는 조합 가능 한 것 으로 정의 되 어 있 으 며, 많은 수집 기 방법 은 하나의 수집 기 를 얻 고, 하나의 수집 기 를 생산 하 는 것 이다. 예 를 들 어, 아래 의 수집 기 는 끼 워 넣 어서 사용 할 수 있 고, 수집 기 에 서 는 수집 기 를 다시 사용 할 수 있다.
*
*  
{@code
 *     Collector summingSalaries
 *         = Collectors.summingInt(Employee::getSalary))
 * }
*
* 우 리 는 에 의 해 급여 의 합 계 를 모 으 기 위해 수집 기 를 만 들 고 싶다 면
* department, we could reuse the "sum of salaries"logic using
* {@link Collectors#groupingBy(Function, Collector)}:
*
*  
{@code
 *     Collector> summingSalariesByDept
 *         = Collectors.groupingBy(Employee::getDepartment, summingSalaries);
 * }
*
* @see Stream#collect(Collector)
* @see Collectors
*
* @param  the type of input elements to the reduction operation
* @param  the mutable accumulation type of the reduction operation (often
*            hidden as an implementation detail)
* @param  the result type of the reduction operation
* @since 1.8
*/
public interface Collector {
/**
* A function that creates and returns a new mutable result container.
가 변 용 기 를 만 들 고 되 돌려 주 는 방법
*
* @return a function which returns a new, mutable result container
*/
Supplier  supplier();
/**
* A function that folds a value into a mutable result container.
* 가 변 용기 에 값 을 접 을 수 있 는 방법 을 되 돌려 줍 니 다.
* @return a function which folds a value into a mutable result container
*/
BiConsumer  accumulator();
/**
* A function that accepts two partial results and merges them.  The
* combiner function may fold state from one argument into the other and
* return that, or may return a new result container.
* 두 부분 결 과 를 받 아들 여 합병 한다.조합 기 함 수 는 상 태 를 하나의 매개 변수 에서 다른 매개 변수 로 접 고 이 매개 변 수 를 되 돌려 주거 나 새로운 결과 용 기 를 되 돌려 줄 수 있 습 니 다.
* @return a function which combines two partial results into a combined
* result
*/
BinaryOperator  combiner();
/**
* 중간 축적 유형 에서 최종 변환 을 수행 합 니 다.
중간 계산 결과 에서 최종 전환 작업 을 수행 하 다.
* {@code A} to the final result type {@code R}.
*
*  If the characteristic {@code IDENTITY_FINISH} is
* set, this function may be presumed to be an identity transform with an
* unchecked cast from {@code A} to {@code R}.
* IDENTITY 가 설정 되 어 있다 면FINISH 인자, 이 함 수 는 유형 검사 없 는 동일 성 변환 으로 추 정 될 수 있 습 니 다.
* @return a function which transforms the intermediate result to the final
* result
*/
Function  finisher();
/**
* Returns a {@code Set} of {@code Collector.Characteristics} indicating
* the characteristics of this Collector.  This set should be immutable.
* 지정 한 집합 파 라 메 터 를 포함 하 는 set 를 되 돌려 줍 니 다. set 는 가 변 적 이지 않 습 니 다.
이 집합 은 수집 기의 세 가지 특성 을 포함 하고 있 으 며, 수집 기 를 사용자 정의 할 때 수집 기의 데이터 가 어떤 특성 이 있어 야 어떤 특성 을 추가 하 는 지, 함부로 추가 할 수 없습니다.
* @return an immutable set of collector characteristics
*/
Set characteristics();
/**
* Returns a new {@code Collector} described by the given {@code supplier},
* {@code accumulator}, and {@code combiner} functions.  The resulting
* {@code Collector} has the {@code Collector.Characteristics.IDENTITY_FINISH}
* characteristic.
* 주어진 3 개의 함수 에 따라 Collector. Characteristics. IDENTITY 가 있 는 함 수 를 되 돌려 줍 니 다.FINISH 매개 변수의 수집 기 는 finisher 를 포함 하지 않 습 니 다.
* @param supplier The supplier function for the new collector
* @param accumulator The accumulator function for the new collector
* @param combiner The combiner function for the new collector
* @param characteristics The collector characteristics for the new
*                        collector
* @param  The type of input elements for the new collector
* @param  The type of intermediate accumulation result, and final result,
*           for the new collector
* @throws NullPointerException if any argument is null
* @return the new {@code Collector}
*/
public static Collector of(Supplier supplier,
BiConsumer accumulator,
BinaryOperator combiner,
Characteristics... characteristics) {
Objects.requireNonNull(supplier);
Objects.requireNonNull(accumulator);
Objects.requireNonNull(combiner);
Objects.requireNonNull(characteristics);
Set cs = (characteristics.length == 0)
? Collectors.CH_ID
: Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH,
characteristics));
return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, cs);
}
/**
* Returns a new {@code Collector} described by the given {@code supplier},
* {@code accumulator}, {@code combiner}, and {@code finisher} functions.
* 주어진 4 개의 함수 에 따라 수집 기 를 되 돌려 줍 니 다.
* @param supplier The supplier function for the new collector
* @param accumulator The accumulator function for the new collector
* @param combiner The combiner function for the new collector
* @param finisher The finisher function for the new collector
* @param characteristics The collector characteristics for the new
*                        collector
* @param  The type of input elements for the new collector
* @param  The intermediate accumulation type of the new collector
* @param  The final result type of the new collector
* @throws NullPointerException if any argument is null
* @return the new {@code Collector}
*/
public static Collector of(Supplier  supplier,
BiConsumer  accumulator,
BinaryOperator  combiner,
Function  finisher,
Characteristics... characteristics) {
Objects.requireNonNull(supplier);
Objects.requireNonNull(accumulator);
Objects.requireNonNull(combiner);
Objects.requireNonNull(finisher);
Objects.requireNonNull(characteristics);
Set cs = Collectors.CH_NOID;
if (characteristics.length > 0) {
cs = EnumSet.noneOf(Characteristics.class);
Collections.addAll(cs, characteristics);
cs = Collections.unmodifiableSet(cs);
}
return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, finisher, cs);
}
/**
* Characteristics indicating properties of a {@code Collector}, which can
* 최적화 감축 구현 을 최적화 하 는 데 사 용 됩 니 다.
수집 기의 특정 매개 변 수 를 지정 하여 구현 클래스 를 최적화 합 니 다.
*/
enum Characteristics {
/**
* Indicates that this collector is concurrent, meaning that
* the result container can support the accumulator function being
* called concurrently with the same result container from multiple
* threads.
수집 기 가 동시 다발 적 이 라 고 지적 한 것 은 결과 용기 지원 누적 기 (같은 결과 용기 사용) 가 다 중 스 레 드 로 호출 되 었 음 을 의미 합 니 다.
*
*  If a {@code CONCURRENT} collector is not also {@code UNORDERED},
* then it should only be evaluated concurrently if applied to an
* unordered data source.
수집 기 가 무질서 하 다 면 무질서 한 데이터 원본 으로 운 송 될 때 만 그 가 병발 했다 고 생각해 야 한다.
이 기능 을 추가 하면 중간 결과 용 기 는 하나 뿐 이 고 여러 스 레 드 로 호출 될 수 있 기 때문에 결과 용 기 는 스 레 드 가 안전 해 야 합 니 다. 그렇지 않 으 면 일정한 확률 로 오 류 를 보고 할 수 있 습 니 다.
사용자 정의 수집 기 가 이 기능 을 사용 하면 누적 기 에서 불필요 한 조작 을 하지 마 십시오 (예 를 들 어 인쇄 집합). 그렇지 않 으 면 오류 가 발생 할 수 있 습 니 다. 한 집합 이 여러 스 레 드 에서 수정 되 는 동시에 옮 겨 다 니 면 동기 화 수정 이상 이 발생 할 수 있 기 때 문 입 니 다.
이 기능 을 추가 하고 parallelStream 을 사용 하면 comber 함수 의 lamboda 는 호출 되 지 않 습 니 다. 중간 결과 용기 가 하나 밖 에 없 기 때문에 합 칠 필요 가 없습니다.
하나의 집합 이 parallelStream 을 사용 하지만 수집 기 에 이 속성 이 없다 면 누적 기 는 여러 개의 중간 결과 용기 (supplier 함수 가 계속 제공) 를 만 들 것 입 니 다. parallelStream 을 사용 하면 수집 기 에 또 이러한 특성 이 있 으 면 누적 기 는 중간 결과 용기 만 사용 할 것 입 니 다.
*/
CONCURRENT,
/**
* 컬 렉 션 작업 이 저장 을 유지 하기 위해 커밋 하지 않 음 을 나 타 냅 니 다.
* 입력 요소 의 순서 가 발생 합 니 다. (이것 은 true 일 수 있 습 니 다.
* result container has no intrinsic 내 재 된 order, 예 를 들 어 a {@ link Set}.)
집합 작업 이 입력 요 소 를 유지 하 는 순 서 를 보장 하지 않 는 다 고 지적 합 니 다. (집합 용기 에 내 재 된 순서 가 없다 면, 예 를 들 어 Set)
*/
UNORDERED,
/**
* Indicates that the finisher function is the identity function and
* can be elided.  If set, it must be the case that an unchecked cast
* from A to R will succeed.
종결 함 수 는 동일 성 함수 이 며 생략 될 수 있 음 을 지적 합 니 다.이 매개 변 수 를 설정 하면 형식 검사 없 는 결과 맵 작업 이 성공 할 것 입 니 다 (중간 결 과 를 최종 결과 로 강제 변환 하려 면 성공 해 야 합 니 다).
*/
IDENTITY_FINISH
}
}  
import java.util.*;
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;

/**
        ， set   map
**/
public class MyCollector2 implements Collector, HashMap> {
    @Override
    public Supplier> supplier() {
        return HashSet::new;
    }

    @Override
    public BiConsumer, T> accumulator() {
        return (set, item)->{
            System.out.println(Thread.currentThread().getName());
            set.add(item);};
    }

    @Override
    public BinaryOperator> combiner() {
        return (set1, set2)->{set1.addAll(set2);return set1;};
    }

    @Override
    public Function, HashMap> finisher() {
        return (set)->{
            HashMap map = new HashMap<>();
            set.forEach(item->{map.put(item,item);});
            return map;
        };
    }

    @Override
    public Set characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(Characteristics.UNORDERED));
    }

    public static void main(String[] args) {
        List list = Arrays.asList("hello", "world", "welcome", "hello", "a", "b", "d", "c", "e", "f", "g", "h", "J");
        HashSet set = new HashSet<>();
        set.addAll(list);
        System.out.println("set: "+ set);
        HashMap map = set.parallelStream().collect(new MyCollector2<>());
        System.out.println(map);
    }
}