내가 함수형 프로그래밍을 처음 접한 건 자바 공부를 막 시작했을 때 인텔리제이의 추천으로 내 코드를 람다식으로 바꿨을 때이다. 보기에 굉장히 멋있어 보여서 언젠가 람다를 공부해서 자유자재로 활용해야지라는 생각을 했던 것 같다.

이렇게 생각한 지 벌써 3달이 흘렀는데 아직도 람다와 어색하다.. 😅

이번 미션을 통해 람다와 스트림에 대해서 공부할 수 있는 기회가 생겨 람다와 스트림 사용법 대해서 간단히 정리해 보려고 한다.

• 함수형 인터페이스(abstract 메서드가 1개)를 간단한 식으로 표현하는 것이다.

java.util.function

자바에서 많이 사용되는 함수형 인터페이스들을 정의해놓은 pakage

자주 사용되는 함수형 인터페이스 예시

Supplier<T>

• T get() : input 없고 output : T

Consumer<T>

• void accept(T t) : input : T, output 없음

Function<T, R>

• R apply(T t) : input : T, output : R

Predicate<T>

• boolean test(T t) : input : T, output : boolean

BiConsumer<T, U>

• void accept(T t, U u) : input : T, U, output 없음

BiFunction<T, U, R>

• R apply(T t, U u) : input : T, U, output : R

BiPredicate<T, U>

• boolean test(T t, U u) : input : T, U, output boolean

Stream은 컬렉션, 배열에 저장되어 있는 값을 참조하여 데이터를 처리하는 흐름을 말한다. 람다를 활용해서 함수형 프로그래밍을 이용해서 항상 동일한 input에 유일한 output을 기대할 수 있다.

stream은 크게 stream 생성, 가공, 최종연산(결과 만들기)의 순서로 이루어져 있다.

지연성을 이용해 최종연산이 있어야지 가공과정을 실행하도록 되어 있다.

• 배열 / 컬랙션 / 빈 스트림
• Stream.iterate()
• 기본 타입형 (IntStream, LongStream)
• 스트림 연결하기

배열을 스트림으로 생성

Stream<Integer> stream = Arrays.stream(intArray);

Stream<Integer> partOfArrayStream = Arrays.stream(intArray, 1, 3);

1 ~ (3 - 1)번 인덱스까지만 스트림으로 만듬

컬렉션을 스트림으로 생성

Stream<Integer> stream = intList.stream()

Stream.iterate()로 스트림 생성

Stream<Integer> iteratedStream = Stream.iterate(30, n -> n + 2).limit(5);

초기값이 30, 2씩 증가하는 5개의 요소를 갖는 스트림 생성 ([30, 32, 34, 36, 38])

꼭 limit(5); 처럼 사이즈를 제한해야 함. (그냥 iterate()로 만들면 스트림의 사이즈가 무한하기 때문)

기본 타입형 스트림 생성

IntStream intStream = IntStream.range(1, 5); // 1, 2, 3, 4 생성

IntStream intStream = IntStream.rangeClosed(1, 5); // 1, 2, 3, 4, 5 생성

• !! Random Class를 이용한 랜덤한 기본형 스트림 생성
  • DoubleStream randomDoubles = new Random().doubles(3); // 난수 3개 생성

new Random().ints(0, 10)  
  .limit(10)  
  .forEach(System.out::println);

// 0 ~ 9 까지의 랜덤한 int 값들을 10개 생성한 후 출력함

스트림 연결하기

Stream<String> concat = Stream.concat(strStream1, strStream2)

IntStream concat = IntStream.concat(IntStream1, IntStream2)

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

Stream<String> stream = names.stream()  
							 .filter(name -> name.contains("a"));

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

Stream<String> stream = names.stream()  
							 .map(String::toUpperCase);

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

students.stream()  
		 .flatMapToInt(student ->   
						 IntStream.of(student.getKor(),
									  student.getEng(),   				
									  student.getMath()))
		 .average().ifPresent(avg ->   
						   	  System.out.println(Math.round(avg * 10)/10.0));

Stream<T> sorted();

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

IntStream.of(14, 11, 20, 39, 23)  
		 .sorted()  
		 .boxed()  
		 .collect(Collectors.toList());

Stream<T> peek(Consumer<? super T> action);

중간에 값 확인을 하기 위해서 자주 사용한다.

(스트림 연산 도중 궁금한 부분).peek(System.out::println)

Calculating

long count = IntStream.of(1, 3, 5, 7, 9).count();  
long sum = LongStream.of(1, 3, 5, 7, 9).sum();

OptionalInt min = IntStream.of(1, 3, 5, 7, 9).min();  
OptionalInt max = IntStream.of(1, 3, 5, 7, 9).max();

DoubleStream.of(1.1, 2.2, 3.3, 4.4, 5.5)  
			.average()  
			.ifPresent(System.out::println); // Optional 대신 ifPresent() 이용

Reduction

// 1개 (accumulator)  
Optional<T> reduce(BinaryOperator<T> accumulator);  
  
// 2개 (identity)  
T reduce(T identity, BinaryOperator<T> accumulator);

OptionalInt reduced = IntStream.range(1, 4) // [1, 2, 3]  
							   .reduce((a, b) -> {  
										return Integer.sum(a, b);  
									  });
 
int reducedTwoParams = IntStream.range(1, 4) // [1, 2, 3]  
								.reduce(10, Integer::sum); // method reference

Collecting

.collect(Collectors.toList());

.collect(Collectors.joining()); // String을 모두 합쳐서 하나의 String으로 만드는 것
.collect(Collectors.joining(", ", "<", ">")); // joining(String사이 구분자, 결과 맨 앞, 결과 맨 뒤)

String listToString =   
 productList.stream()  
 .map(Product::getName)  
 .collect(Collectors.joining(", ", "<", ">"));  
// <potatoes, orange, lemon, bread, sugar>

Matching

boolean anyMatch(Predicate<? super T> predicate);  //하나라도 만족하는지
boolean allMatch(Predicate<? super T> predicate);  // 모두 조건을 만족하는지
boolean noneMatch(Predicate<? super T> predicate); // 모두 조건을 만족하지 않는지

forEach

void forEach(Consumer<? super T> action);

.forEach(System.out::println);

참고 블로그