스트림 자르기 - skip(), limit()

skip()과 limit()은 스트림의 일부를 잘라낼 때 사용한다. 두 메서드는 기본 스트림에서도 동일하게 사용할 수 있다.

//n개만큼 건너뛰기
Stream<T> skip(long n)

//maxSize 갯수만큼의 스트림 요소 반환
Stream<T> limit(long maxSize)

//활용
IntStream intStream = IntStream.rangeClosed(1, 10);
intStream.skip(3).limit(5).forEach(System.out::println);   //45678 출력

스트림의 요소 걸러내기 - filter(), distinct()

//중복된 요소 제거
Stream<T> distinct()

//distinct() 활용 예
IntStream intStream = IntStream.of(1,2,2,3,4,5,6,6);
intStream.distinct().forEach(System.out::println);      //123456 출력

//Predicate 또는 연산 결과가 boolean인 람다식을 활용한 걸러내기
Stream<T> filter(Predicate<? super T> predicate)

//filter() 활용 예1
IntStream intStream = IntStream.rangeClosed(1, 10);
intStream.filter(i -> i%2 == 0).forEach(System.out::println);    //2,4,6,8,10 출력

//filter() 활용 예2
intStream.filter(i -> i%2 == 0).filter(i -> i%4 == 0).forEach(System.out::println); //48 출력
intStream.filter(i -> i%2 == 0 && i -> i%4 == 0).forEach(System.out::println); //48 출력

정렬 - sorted()

//기본 정렬(사전 순 정렬)
Stream<T> sorted()

//Comparator 또는 int 값 반환 람다식을 통한 정렬
Stream<T> sorted(Comparator<? super T> comparator)

Stream<String> strStream = Stream.of("dd", "aaa", "CC", "cc", "b");

//기본 정렬(CCaaabccdd)
strStream.sorted();
strStream.sorted(Comparator.naturalOrder());
strStream.sorted((s1, s2)->s1.compareTo(s2));
strStream.sorted(String::compareTo);

//역순 정렬(ddccbaaaCC)
strStream.sorted(Comparator.reverseOrder());
strStream.sorted(Comparator.<String>naturalOrder().reversed());

//대소구분 없이 정렬(aaabCCccdd)
strStream.sorted(String.CASE_INSENSITIVE_ORDER)

//대소구분 없이 역정렬(ddCCccbaaa)
strStream.sorted(String.CASE_INSENSITIVE_ORDER.reversed())

//길이 순 정렬(bddCCccaaa)
strStream.sorted(Comparator.comparing(String::length));
strStream.sorted(Comparator.comparingInt(String::length));        //오토박싱x

//길이 순 역정렬(aaaddCCccb)
strStream.sorted(Comparator.comparing(String::length).reversed());

Comparator의 메서드

//default 메서드
reversed()
thenComparing(Comparator<T> other)
thenComparing(Comparator<T, U> keyExtractor)
thenComparing(Comparator<T, U> keyExtractor, Comparator<U> keyComp)
thenComparingInt(ToIntFunction<T> keyExtractor)
thenComparingLong(ToIntFunction<T> keyExtractor)
thenComparingDouble(ToIntFunction<T> keyExtractor)

//static 메서드
naturalOrder()
reverseOrder()
comparing(Function<T, U>, keyExtractor)
comparing(Function<T, U>, keyExtractor, Comparator<U> keyComparator)
comparingInt(ToIntFunction<T> keyExtractor)
comparingLong(ToIntFunction<T> keyExtractor)
comparingDouble(ToIntFunction<T> keyExtractor)
nullsFirst(Comparator<T> comparator)
nullLast(Comparator<T> comparator)