Java8 Stream

Epilogue🙎‍♀️
나는 대학교때도 Java8이후의 추가된 사항을 배우진 못했고,
실무는 항.상. legacy환경의 코드를 많이 접하여서 사실 Lambda니 Stream에 대한 활용코드를 본 적도 별로없고, 사실 그냥 List for loop돌려도 문제가 없었으니까, 나중에 공부해야지 하고 미루던 공부를 늦었지만 이제라도 시작해본다,,,

스트림의 특징

👉람다식으로 처리 코드를 제공한다.

List<Student> list = Arrays.asList(
    new Student("차민혜",100), new Student("엘사", 99)
);

// java8 이전 iterator를 통한 for loop
for(Student student : list){
    System.out.println(student.getName() +  "score : " + student.getScore());
}

// java8 이후 Stream을 이용한 for loop
Stream<Student> stream = list.stream();
stream.forEach(s -> {
    System.out.println(s.getName() + " 점수 : "+s.getScore());
});

👉내부 반복자를 사용하므로 병렬처리가 쉽다

List<String> list = Arrays.asList(
    "홍길동", "윤두준", "람다식", "박병렬", "김자바"
);

// 순차처리
Stream<String> stream = list.stream();
stream.forEach(ParallelExample :: print);		
System.out.println();
// print  >> 홍길동, 윤두준, 람다식, 박병렬, 김자바

// 병렬처리
Stream<String> parallelStream = list.parallelStream();
parallelStream.forEach(ParallelExample :: print);
// print  >> 람다식, 김자바, 박병렬, 윤두준, 홍길동

👉스트림은 중간처리와 최종 처리를 할 수 있다.

• 중간처리 :: 매핑, 필터링, 정렬을 수행

• 최종처리 :: 반복, 카운팅, 평균, 총합 등의 집계처리를 수행

List<Student> studentList = Arrays.asList(
    new Student("홍길동", 60),
    new Student("이순신", 95),
    new Student("세종대왕", 100)
);

double avg = studentList.stream()
    // 중간처리 > 학생객체를 점수로 매핑
    .mapToInt(Student :: getScore)
    // 최종처리 > 평균점수
    .average()
    .getAsDouble();

👉 다양한 객체로부터 스트림 읽기

// 1. 컬렉션으로부터 스트림 얻기
List<Student> studentList = Arrays.asList(
    new Student("홍길동", 60),
    new Student("이순신", 95),
    new Student("세종대왕", 100)
);

Stream<Student> stream = studentList.stream();
stream.forEach(s -> System.out.println(s.getName()));

// 2. 배열로부터 스트림 얻기
// 2.1 String 배열
String[] strArray = {"홍길동" ,"이순신", "강감찬"};
Stream<String> stStream = Arrays.stream(strArray);
stStream.forEach(s -> System.out.println(s));

// 2-2. int 배열
int[] intArray = {1,23,54,5678,10};
IntStream intStream = Arrays.stream(intArray);
intStream.forEach(s -> System.out.println(s));

// 3. 숫자 범위로부터 스트림 얻기
IntStream intRangeStream = IntStream.rangeClosed(1, 100);   // cf) range(1,100) 1~99까지
intRangeStream.forEach(a -> sum +=a);
System.out.println("sum : "+sum);

// 4. 파일로부터 스트림 얻기
Path path = Paths.get("src/main/java/study/stream/type/lineExample.txt");
Stream<String> fileStream ;

// 4-1. Files.lines() 메소드 이용
fileStream = Files.lines(path, Charset.defaultCharset());
fileStream.forEach(System.out :: println);
System.out.println();

// 4-2.BufferedReader.lines() 메소드 이용
File file = path.toFile();
FileReader fileReader = new FileReader(file);
BufferedReader br = new BufferedReader(fileReader);
fileStream = br.lines();
fileStream.forEach(System.out :: println);

// 5. 디렉토리로부터 스트림 얻기
Path dirPath= Paths.get("D:\\IDE\\workspace");
Stream<Path> dirStream = Files.list(dirPath);
dirStream.forEach(p -> System.out.println(p.getFileName())) ;

스트림 파이프라인

대량의 데이터를 가공해서 축소하는 것을 일반적으로 리덕션(Reduction)이라고 하는데,

데이터의 합계, 평균값, 최대값, 최소값 등이 대표적인 리덕션의 결과물이다.

그러나 컬렉션의 요소를 리덕션의 결과물로 바로 집계 할 수 없는 경우

-> 집계하기 좋도록 필터링, 매핑, 정렬, 그룹핑 등의 중간처리가 필요하다.

👉남자 회원들의 평균나이를 구하는 예제

// 로컬변수 생략후 람다식 표현
double avgAge = list.stream()               // 오리지널 스트림
    .filter(s -> s.getSex() == Member.MALE) // 중간처리1 : 남자회원만 필터링
    .mapToInt(Member::getAge)               // 중간처리2 : 남자회원 나이 필터링
    .average()                              // 최종처리 : 합계구하기
    .getAsDouble();

👉중간 처리 메소드와 최종 처리 메소드

• 중간처리 : 리턴타입이 스트림

• 최종처리 : 리턴타입리 기본타입이거나 OptinalXXX

  종류	처리	리턴타입	method
  중간처리	필터링	Stream IntStream LongStream DoubleStream	distinct() filter()
  	매핑	Stream IntStream LongStream DoubleStream	flatMap() flatMapToInt()... map() mapToInt()... asDoubleStream()... boxed()
  	정렬	Stream IntStream LongStream DoubleStream	sorted()
  	루핑	Stream IntStream LongStream DoubleStream	peek()
  최종처리	매칭	Boolean	allMatch() anyMatch() noneMatch()
  	집계	long OptinalXXX	count() findFirst() / max() / min() / average() / reduce()/ sum()
  	루핑	void	forEach()
  	수집	R	collect()

필터링(distinct() , filter())

필터링은 중간 처리 기능으로 요소를 걸래는 역할

• distinct() : 중복제거
• filter() : 매개값으로 주어진 Predicate가 true를 리턴하는 요소만 필터링

// 중복제거
Stream<String> stream = list.stream().distinct();
stream.forEach(System.out :: print);

System.out.println();

// 성이 '신'씨면서 중복제거
Stream<String> sinStream = list.stream()
                                .distinct()
                                .filter(s-> s.startsWith("신"));
sinStream.forEach(System.out :: print);

매핑(flatMapXXX(), mapXXX(), asXXXStream(), boxed())

매핑은 중간 처리 기능으로 스트림의 요소를 다른요소로 대체하는 작업이다.

👉flatMapXXX() 메소드

• 요소를 대체하는 복수개의 요소들로 구성된 새로운 스트림을 리턴

List<String> inputList = Arrays.asList("java8 lambda", "stream mapping");

// 복수개의 요소로 대체
inputList.stream()
  	  	.flatMap(data -> Arrays.stream(data.split(" ")))
    	.forEach(System.out :: println);
// result > 
java8
lambda
stream
mapping


// String 배열을 , 단위로 짜른 후 int[]배열로 변환
List<String> inputList2 = Arrays.asList("1,2,3","4,5,67","8,9,20");
inputList2.stream()
        .flatMapToInt(data-> {
            String[] strArr = data.split(",");
            int[] intArr = new int[strArr.length];
            for(int i=0;i<intArr.length;i++){
                intArr[i] = Integer.parseInt(strArr[i].trim());
            }
            return Arrays.stream(intArr);
        })
        .forEach(System.out::println);
// result >
1
2
3
4
5
67
8
9
20

👉mapXXX() 메소드

• 요소를 대체하는 요소로 구성된 새로운 스트림을 리턴

List<Student> studentList = Arrays.asList(
                new Student("홍길동", 10),
                new Student("김나나", 20),
                new Student("차안나", 30)
        );

studentList.stream()
    .mapToInt(s-> s.getScore())
    .forEach(System.out :: println);

👉asDoubleStream(), asLongStream(), boxed() 메소드

• asDoubleStream() : IntStream의 int요소

​ LongStream의 ong 요소를 double요소로 타입변환해서 DoubleStream을 생성

• asLongStream() : IntStream의 int요소를 long요소 타입으로 타입변환하여 LongStream을 생성
• boxed() : int,long,double 요소를 Integer, Long, Double요소로 박싱해서 Stream을 생성

int[] intArray = {1,2,3,4,5};

// int -> double 로 변환
IntStream stream = Arrays.stream(intArray);
stream.asDoubleStream().forEach(System.out :: println);

// boxed (int -> Integer)
stream = Arrays.stream(intArray);
stream
    .boxed()
    .forEach(System.out :: println);

​

정렬(sorted())

스트림은 요소가 최종 처리되기 전에 중간 단계에서 요소를 정렬해서 최종 처리 순서를 변경

※객체 요소일 경우에는 클래스가 Comparable을 구현하지 않으면 sorted()메소드를 호출하면 ClassCastException이 발생한다. 따라서 Comparable이 구현된 요소에서 사용가능하다.

👉Comparable 구현 클래스

public class Student implements Comparable<Student> {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }

    @Override
    public int compareTo(Student o) {
        return Integer.compare(score, o.getScore());
    }
}

👉sorted()메소드를 이용한 정렬

// 숫자 요소인 경우
IntStream intStream = Arrays.stream(new int[]{5,3,2,1,4});
intStream.sorted()
    .forEach(System.out :: println);

// 객체 요소일 경우
List<Student> list = Arrays.asList(
    new Student("김나나", 90),
    new Student("엘사", 99),
    new Student("안나", 20)
);
list.stream()
    .sorted()
    .forEach(s-> System.out.println(s.getScore()));

// 역순
list.stream()
    .sorted(Comparator.reverseOrder())
    .forEach(s-> System.out.println(s.getScore()));

루핑(peek(), forEach())

요소 전체를 반복하는것.

• peek() : 중간처리 단계의 메소드이므로 ,반드시 최종처리 단계의 메소드 호출
• forEach() : 최종처리 단계의 메소드, 해당 메소드 호출이후 sum()같은 최종처리 메소드 호출하면 안된다

int[] intArr = {1,2,3,4,5};

// peek()를 마지막에 호출한 경우
Arrays.stream(intArr)
    .filter(a -> a% 2 == 0)
    .peek(a-> System.out.println(a));    // 동작하지 않음

// 최종 처리 메소드를 마지막에 호출한 경우
int total = Arrays.stream(intArr)
    .filter(a -> a% 2 == 0)
    .peek(a-> System.out.println(a))    // 동작함
    .sum();
System.out.println("total : "+total);

// forEach()를 마지막에 호출한 경우
Arrays.stream(intArr)
    .filter(a -> a% 2 == 0)
    .forEach(System.out :: println);

매칭(allMatch(), anyMatch(), noneMatch())

스트림클래스는 최종 처리 단계에서 요소들이 특정 조건에 만족하는지 조사할 수 있도록 제공

• allMatch() : 모든 요소들이 매개값으로 주어진 Predicate의 조건을 만족하는지
• anyMatch() : 최소한 한 개의 요소가 매개값으로 주어진 Predicate의 조건을 만족하는지
• noneMatch() : 모든 요소들이 매개값으로 주어진 Predicate의 조건을 만족하지 않는지

int[] intArr = {2,4,5};

boolean result = Arrays.stream(intArr)
    .allMatch(a -> a%2 ==0);
// print > false

boolean result1 = Arrays.stream(intArr)
    .anyMatch(a -> a%3 ==0);
// print > false

boolean result2 = Arrays.stream(intArr)
    .noneMatch(a -> a%3 ==0);
// print > false

기본집계(sum(), count(), average(), max(), min())

최종처리 기능으로 요소들을 처리해서 카운팅, 합계, 평균값, 최대값, 최소값등과 같이 하나의 값으로 산출

집계는 대량의 데이터를 가공해서 축소하는 리덕션(reduction)이라고 볼 수 있다.

// 개수
long count = Arrays.stream(new int[]{1,2,3,4,5})
    .filter(n-> n%2 ==0)
    .count();
// print > 2

// 합계
long sum = Arrays.stream(new int[]{1,2,3,4,5})
    .filter(n-> n%2 ==0)
    .sum();
// print > 6

// 평균값
double avg = Arrays.stream(new int[]{1,2,3,4,5})
    .filter(n-> n%2 ==0)
    .average()
    .getAsDouble();
// print > 3.0

// 최대값
int max = Arrays.stream(new int[]{1,2,3,4,5})
    .filter(n-> n%2 ==0)
    .max()
    .getAsInt();
// print > 4

// 최소값
int min = Arrays.stream(new int[]{1,2,3,4,5})
    .filter(n-> n%2 ==0)
    .min()
    .getAsInt();
// print > 2

👉Optinal 클래스

단순히 집계 값만 저장하는 것이 아니라, 집계 값이 존재하지 않을 경우 디폴트 값을 설정할 수 있고,

집계 값을 처리하는 Consumer도 등록할 수 있다.

List<Integer> list = new ArrayList<>();

// 컬렉션에 요소가 추가되지 않은 상태 -> NoSuchElementException 예외발생
double avg = list.stream()
    .mapToInt(Integer :: intValue)
    .average()
    .getAsDouble();
System.out.println(avg);

// 방법1) Optinal.isPresent() 메소드로 평균값 여부를 확인.
OptionalDouble optional = list.stream()
    .mapToInt(Integer::intValue)
    .average();
if(optional.isPresent()){
    System.out.println("(method1)avg : " + optional.getAsDouble());
}else {
    System.out.println("(method1)avg : 0.0");
}

// 방법2) orElse() 메소드를 이용하여 default값을 설정.
double avg = list.stream()
    .mapToInt(Integer::intValue)
    .average()
    .orElse(0.0);
System.out.println("(method2)avg : " + avg);

// 방법3) 평균값이 있을 경우에만
list.stream()
    .mapToInt(Integer::intValue)
    .average()
    .ifPresent(a-> System.out.println("(method3) avg : "+a));

커스텀 집계(reduce())

다양한 집계 결과물을 만들 수 있도록 reduce()메소드 제공

List<Student> studentList = Arrays.asList(
    new Student("김나나", 82),
    new Student("나다나", 90),
    new Student("신효범", 57)
);

// 학생들의 총점 구하기
// 방법1) sum()이용
int sum1 = studentList.stream()
    .mapToInt(Student::getScore)
    .sum();
// 방법2) reduce(Operator) 이용, 스트림 요소 없는 경우 NoSuchElementException 발생
int sum2 = studentList.stream()
    .map(Student::getScore)
    .reduce((a,b) -> a+b)
    .get();
// 방법3) reduce(identity, Operator) 이용, 스트림 요소 없는 경우, 0.0
int sum3 = studentList.stream()
    .map(Student::getScore)
    .reduce(0, (a,b) -> a+b);

수집(collect())

스트림은 요소들을 필터링 또는 매핑한 후 요소들을 수집하는 최종 처리 메소드인 collect()를 제공

이 메소드를 이용하면 필요한 요소만 컬렉션으로 담을 수 있고, 요소들을 그룹필한 후 집계할 수 있다.

👉필터링한 요소 수집

List<Student> list = Arrays.asList(
    new Student("김나나", 10, Student.Sex.FEMALE),
    new Student("강찬희", 35, Student.Sex.MALE),
    new Student("황진이", 98, Student.Sex.FEMALE),
    new Student("박지성", 50, Student.Sex.MALE)
);

// 전체 학생 중 남학생만 필터링해서 별도의 List 생성하기
Stream<Student> stream = list.stream();
Stream<Student> maleStream = stream.filter(s->s.getSex()== Student.Sex.MALE);
// List에 Student를 수집하는 Collector를 얻기
Collector<Student, ? , List<Student>> collector = Collectors.toList();
// Stream에 collect()메소드로 Student를 수집해서 새로운 List를 얻는다.
List<Student> maleList = maleStream.collect(collector);

// 변수 생략 버전
List<Student> maleScoreList = list.stream()
                            .filter(s-> s.getSex() == Student.Sex.MALE)
                            .collect(Collectors.toList());
maleScoreList.stream().forEach(s-> System.out.println(s.getScore()));

👉사용자 정의 컨테이너에 수집하기

collect(Supplier, BiConsumer<R, ? super T>, BiConsumer<R,R>)

• Supplier : 요소들이 수집될 컨테이너(R)을 생성

• BiConsumer<R, ? super T> : 컨테이너 객체(R)에 요소(T)를 수집하는 역할

• BiConsumer<R,R> : 컨테이너 객체(R)를 결합하는 역할.

private List<Student> list;     // 요소를 저장할 컬렉션

public MaleStudent(){           // 생성자
    list = new ArrayList<>();
    System.out.println("["+ Thread.currentThread().getName()+"] MaleStudent");
}

public void accumulate(Student student){    //요소를 수집하는 메소드
    list.add(student);
    System.out.println("["+ Thread.currentThread().getName()+"] accumulate()");
}

public void combine(MaleStudent other){ // 두 MaleStudent를 결합하는 메소드 (병렬처리에만 호출)
    list.addAll(other.getList());
    System.out.println("["+ Thread.currentThread().getName()+"] combine()");
}

public List<Student> getList(){             // 요소가 저장될 컬렉션을 리턴턴
    return list;    
}

• 스트림에서 읽은 남학생을 MaleStudent에 수집하기

// 1.전체 학생 List에서 Stream 얻기
Stream<Student> stream = list.stream();
// 2.남학생만 필터링해서 Stream 얻기
Stream<Student> maleStream = stream.filter(s->s.getSex()== Student.Sex.MALE);

// 3.MaleStudent를 공급하는 Supplier를 얻는다.
Supplier<MaleStudent> supplier = () -> new MaleStudent();
// 4.MaleStudent와 Student를 매개값으로 받아서 MaleStudent의 accumulate()메소드로 Student를 수집하는 BiConsumer를 얻는다
BiConsumer<MaleStudent, Student> accmulator = (ms, s) -> ms.accumulate(s);
// 5. 두 개의 MaleStudent를 매개값으로 받아 combine()메소드로 결합하는 BiConsumer를 얻는다.
BiConsumer<MaleStudent, MaleStudent> combiner = (ms1, ms2) -> ms1.combine(ms2);
// 6. supplier가 제공하는 MaleStudent에 accumulator가 Student를 수집해서 최종 처리된 MaleStudent를 얻는다.
MaleStudent maleStudent = maleStream.collect(supplier, accmulator, combiner);

// 메소드 참조 버전
MaleStudent maleStudent2 = list.stream()
    .filter(s->s.getSex()== Student.Sex.MALE)
    .collect(MaleStudent::new, MaleStudent::accumulate, MaleStudent::combine);

maleStudent2.getList().stream()
    .forEach(s-> System.out.println(s.getName()));

// result >
[main]
[main] accumulate()
[main] accumulate()
강찬희
박지성

👉요소를 그룹핑해서 수집

Collector<T, ?, Map<K, List>

• T를 K로 매핑하고, K 키에 저장된 List에 T를 저장한 Map 생성
• groupBy(Function<T,K> classifier)

List<Student> list = Arrays.asList(
    new Student("김나나", 10, Student.Sex.FEMALE, Student.City.Seoul),
    new Student("강찬희", 35, Student.Sex.MALE, Student.City.Seoul),
    new Student("황진이", 98, Student.Sex.FEMALE, Student.City.Busan),
    new Student("박지성", 50, Student.Sex.MALE, Student.City.Seoul)
);

/**
  *  학생들을 성별로 그룹핑하고, 같은 그룹에 속하는 학생 List를 생성한 뒤,
  *  성별을 키로, 학생List를 값으로 갖는 Map을 생성한다.
  */
// 1. 전체학생 List에서 Stream 얻기
Stream<Student> stream = list.stream();
// 2. Student를 Student.Sex로 매핑하는 Function을 얻는다
Function<Student, Student.Sex> classifier = Student::getSex;
// 3. Student.Sex가 키가 되고, 그룹핑 된 List<Student>가 값인 Map을 생성하는 Collector를 얻는다
Collector<Student, ? , Map<Student.Sex, List<Student>>> collector = Collectors.groupingBy(classifier);
// 4. Stream의 collect() 메소드로 Student를 Student.Sex별로 그룹팽해서 Map을 얻는다.
Map<Student.Sex, List<Student>> mapBySex = stream.collect(collector);

// 변수 제거 버전
Map<Student.Sex, List<Student>> mapBySex1 = list.stream()
    .collect(Collectors.groupingBy(Student :: getSex));

mapBySex1.get(Student.Sex.MALE).stream()
    .forEach(s-> System.out.println(s.getName()));
// result > 강찬희 박지성

/**
  * 학생들을 거주 도시별로 그룹핑하고, 같은 그룹에 속하는 학생들의 이름을 List로 생성한 후
  * 거주 도시를 키로, 이름 List를 값으로 갖는 Map을 생성
  */
// 1. 전체학생 List에서 Stream 얻기
Stream<Student> cityStream = list.stream();
// 2. Student를 Student.City로 매핑하는 Function을 얻는다
Function<Student, Student.City> cityClassifier = Student :: getCity;
// 3. Student를 Student.Name로 매핑하는 Function을 얻는다
Function<Student, String> mapper = Student :: getName;
// 4. Student의 이름을 List에 수집하는 Collerctor를 얻는다.
Collector<String, ? , List<String>> collector1 = Collectors.toList();
Collector<Student, ?,  List<String>> collector2 = Collectors.mapping(mapper, collector1);
// 5. Student.City가 키고 그룹핑된 이름 List가 값인 Map을 생성하는 Collector를 얻는다.
Collector<Student, ? , Map<Student.City, List<String>>> collector3 = Collectors.groupingBy(cityClassifier, collector2);
// 6. Stream의 collect메소드로 Student를 Student.City별로 그룹핑해서 Map을 얻는다.
Map<Student.City, List<String>> mapByCity = cityStream.collect(collector3);

// 변수 생략 버전
Map<Student.City, List<String>> mapByCity2 = list.stream()
    .collect(
    Collectors.groupingBy(
        Student::getCity, Collectors.mapping(Student::getName, Collectors.toList())
    )
);
mapByCity2.get(Student.City.Busan).stream()
    .forEach(s-> System.out.println(s));
// result > 황진이

👉 그룹핑 후 매핑 및 집계

/**
  * 학생들을 성별로 그룹핑한 다음 같은 그룹에 속하는 학생들의 평균 점수를 구하고,
  * 성별을 키로, 평균 점수를 값으로 갖는 Map을 생성한다.
  */
Stream<Student> stream = list.stream();
Function<Student, Student.Sex> classifier = Student::getSex;
// Student를 점수로 매핑하는 ToDoubleFunction을 얻는다
ToDoubleFunction<Student> mapper = Student::getScore;
// 학생 점수의 평균을 산출하는 Collector를 얻는다
Collector<Student, ? , Double> collector1 = Collectors.averagingDouble(mapper);
// Student.Sex가 키고, 평균 점수가 Double인 값인 Map을 생성하는 Collector를 얻는다.
Collector<Student, ? , Map<Student.Sex, Double>> collector2 = Collectors.groupingBy(classifier, collector1);
// Stream의 collect() 메소드로 Student를 Student.Sex별로 그룹핑하여 Map을 얻는다.
Map<Student.Sex, Double> mapByScore = stream.collect(collector2);

// 변수 제거 버전
Map<Student.Sex, Double> map = list.stream()
    .collect(
    Collectors.groupingBy(
        Student::getSex,
        Collectors.averagingDouble(Student::getScore)
    )
);

System.out.println(map.get(Student.Sex.MALE));

병렬처리

동시성(Concurrency()와 병렬성(Parallelism)

동시성 :멀티작업을 위해 멀티스레드가 번갈아가며 실행하는 성질

병렬성 : 멀티 작업을 위해 멀티 코어를 이용해서 동시에 실행하는 성질

👉병렬스트림 생성

// 메소드 참조 버전
MaleStudent maleStudent2 = list.parallelStream()
    .filter(s->s.getSex()== Student.Sex.MALE)
    .collect(MaleStudent::new, MaleStudent::accumulate, MaleStudent::combine);

maleStudent2.getList().stream()
    .forEach(s-> System.out.println(s.getName()));

// result >
[main] MaleStudent
[main] MaleStudent
[ForkJoinPool.commonPool-worker-3] MaleStudent
[ForkJoinPool.commonPool-worker-5] MaleStudent
[ForkJoinPool.commonPool-worker-3] accumulate()
[main] accumulate()
[ForkJoinPool.commonPool-worker-3] combine()
[main] combine()
[main] combine()
강찬희
박지성

병렬 처리 성능

👉요소의 수와 요소당 처리 시간

컬렉션에 요소의 수가 적고 요소당 처리 시간이 짧으면 순차처리가 병렬처리보다 빠르다

👉스트림 소스의 종류

ArrayList, 배열은 인덱스로 요소를 관리하기 떄문에 병렬처리시 시간이 절약된다.

반면에 HashSet, TreeSet, LinkedList는 상대적으로 병렬처리가 늦다

👉코어(Core)의 수

싱글코어일수록 순차처리가 빠르다. 곧, 코어의 수가 많을수록 병렬처리 처리속도가 빨라진다.

---

※ [이것이 자바다 신용권Java 프로그래밍 정복2] 해당 책을 참고하며 정리한 내용입니다.