스트림의 연산

• 스트림이 제공하는 기능 : 중간 연산과 최종 연산
• 중간 연산 : 연산결과가 스트림인 연산. 반복적으로 적용 가능
• 최종 연산 : 연산결과가 스트림이 아닌 연산. 단 한번만 적용 가능(스트림의 요소를 소모)

중간 연산

• filter() : 걸러내기

• peek() : forEach()랑 비슷, 작업 중간에 잘 처리됐나 확인하기

• ✨✨✨map()&flatMap()

스트림 자르기

skip()

Stream<T> skip(long n)

• 앞에서부터 n개 건너뛰기

limit()

Stream<T> limit(long maxSize)

• maxSize 이후의 요소는 잘라냄

예)

IntStream intStream = IntStream.rangeClosed(1, 10);
//1 2 3 4 5 6 7 8 9 10
intStream.skip(3).limit(5).forEach(System.out::print);

45678

스트림의 요소 걸러내기

filter()

`Stream filter(Predicate<? super T> predicate)

• 조건에 맞지 않는 요소 제거
• ✨✨조건식이 true인 요소만 남기기

distinct()

Stream<T> distict()

• 중복제거

예)

IntStream intStream = IntStream.rangeClosed(1, 10);
//1 2 3 4 5 6 7 8 9 10
intStream.filter(i->i%2==0).forEach(System.out::print);
intStream.filter(i->i%2!=0 && i%3!=0).forEach(System.out::print);
//***&& 일 경우 filter()를 나눠서 해도 된다!
intStream.filter(i->i%2!=0).filter(i->i%3!=0).forEach(System.out::print);

246810
157
157

예)

IntStream intStream = IntStream.of(1,2,2,6,3,4,5,5,3,6);
intStream.distinct().forEach(System.out::print);

126345

스트림 정렬하기

sorted()

Stream<T> sorted()

• 스트림 요소의 기본 정렬(Comparable)로 정렬

Stream<T> sorted(Comparator<? super T> comparator)

• 지정된 Comparator로 정렬

Comparator.comparing()으로 정렬기준 제공

Comparator comparing(Function<T,U> keyExtractor)
Comparator comparing(Function<T,U> keyExtractor, Comparator<U> keyComparator)

• Function 함수형인페 사용
• comparing()이 Comparator를 반환하여 sorted()가 사용

예)

• Student::getBan == (Student s) -> s.getBan()

thenComparing() - 정렬기준이 여러개 일 때

Comparator thenComparing(Comparator<T> other)
Comparator thenComparing(Function<T,U> keyExtractor)
Comparator thenComparing(Function<T,U> keyExtractor, Comparator<U> keyComp)

예)

studentStream.sorted(Comparator.comparing(Student::getBan)	//반별로 정렬
				.thenComparing(Student::getTotalScore)	//총점별로 정렬
				.thenComparing(Student::getName))	//이름별로 정렬
			.forEach(System.out::println);

ex14_05

import java.util.Comparator;
import java.util.stream.Stream;

public class Ex14_05 {

	public static void main(String[] args) {
		Stream<Student> stuStream = Stream.of(
				new Student("이자바", 3, 300),
				new Student("김자바", 1, 200),
				new Student("안자바", 2, 100),
				new Student("박자바", 2, 150),
				new Student("소자바", 1, 200),
				new Student("나자바", 3, 290),
				new Student("감자바", 3, 180)
			);
		
//		stuStream.sorted().forEach(System.out::println);	//기본정렬:총점 내림차순
		stuStream.sorted(Comparator.comparing(Student::getBan)	//반별 정렬
		.thenComparing(Comparator.naturalOrder()))	//기본정렬(총점 내림차순)
//		.thenComparing(Comparator.naturalOrder()).reversed())	//기본 반대정렬(총점 올림차순)
//		.thenComparing(Comparator.reverseOrder()))	//기본 반대정렬(총점 올림차순)
		.forEach(System.out::println);
		

	}//main

}

class Student implements Comparable<Student>{
	String name;
	int ban;
	int totalScore;
	
	public String getName() {return name;}
	public int getBan() {return ban;}
	public int getTotalScore() {return totalScore;}

	Student(String name, int ban, int totalScore) {
		this.name = name;
		this.ban = ban;
		this.totalScore = totalScore;
	}
	
	//****기본정렬을 총점 내림차순으로 한다.
	//오버라이드 필수로 해야한다!!
	@Override
	public int compareTo(Student s) {
		return s.totalScore - this.totalScore;
	}
	//***
	public String toString() {
		return String.format("[%s, %d, %d]", name, ban, totalScore);
	}
	
}

stuStream.sorted().forEach(System.out::println);	//기본정렬:총점 내림차순

[이자바, 3, 300]
[나자바, 3, 290]
[김자바, 1, 200]
[소자바, 1, 200]
[감자바, 3, 180]
[박자바, 2, 150]
[안자바, 2, 100]

stuStream.sorted(Comparator.comparing(Student::getBan))	//반별 정렬
		.forEach(System.out::println);

[김자바, 1, 200]
[소자바, 1, 200]
[안자바, 2, 100]
[박자바, 2, 150]
[이자바, 3, 300]
[나자바, 3, 290]
[감자바, 3, 180]

stuStream.sorted(Comparator.comparing(Student::getBan)	//반별 정렬
		.thenComparing(Comparator.naturalOrder()))	//기본정렬(총점 내림차순)
		.forEach(System.out::println);

[김자바, 1, 200]
[소자바, 1, 200]
[박자바, 2, 150]
[안자바, 2, 100]
[이자바, 3, 300]
[나자바, 3, 290]
[감자바, 3, 180]

stuStream.sorted(Comparator.comparing(Student::getBan)	//반별 정렬
		.thenComparing(Comparator.reverseOrder()))	//기본 반대정렬(총점 올림차순)
		.forEach(System.out::println);

[김자바, 1, 200]
[소자바, 1, 200]
[안자바, 2, 100]
[박자바, 2, 150]
[감자바, 3, 180]
[나자바, 3, 290]
[이자바, 3, 300]

✨✨✨조심해야 할 것!! reversed()

stuStream.sorted(Comparator.comparing(Student::getBan)	//반별 정렬
		.thenComparing(Comparator.naturalOrder()).reversed())	//기본 반대정렬(총점 올림차순)
		.forEach(System.out::println);

[감자바, 3, 180]
[나자바, 3, 290]
[이자바, 3, 300]
[안자바, 2, 100]
[박자바, 2, 150]
[김자바, 1, 200]
[소자바, 1, 200]

• reversed() : ✨✨앞의 모든 것에 적용

stuStream.sorted(Comparator.comparing(Student::getBan).reversed()	//반별 정렬
		.thenComparing(Comparator.naturalOrder()))	//기본 반대정렬(총점 올림차순)
		.forEach(System.out::println);

[이자바, 3, 300]
[나자바, 3, 290]
[감자바, 3, 180]
[박자바, 2, 150]
[안자바, 2, 100]
[김자바, 1, 200]
[소자바, 1, 200]

• 이번엔 맨 앞만 적용되었기에 뒤는 신경 안써도 된다.

		.thenComparing(Comparator.naturalOrder()).reversed())	//기본 반대정렬(총점 올림차순)
		.forEach(System.out::println);

[김자바, 1, 200]
[소자바, 1, 200]
[안자바, 2, 100]
[박자바, 2, 150]
[감자바, 3, 180]
[나자바, 3, 290]
[이자바, 3, 300]

• 앞에 한번, 그리고 전체적으로 다시 한번 적용!!

• ✨✨reversed() : 맨앞 또는 전체에 한번에 역순정렬 할 때!!

• 💖💖💖reverseOrder() : 하나만 역순정렬 할 때!!

Ref

• 생활코딩 JAVA1
• 객체화 설명
• w3schools JAVA
• 나동빈
• 자바의정석
• 자바의정석 깃허브
• 클래스와 객체