Java 스트림 활용

필터링

1. 중간 연산
2. 입력된 원소 중에서 일부 원소를 걸러낸다
3. 메소드 종류
   1. filter(람다식) : 람다식 조건에 맞는 원소만 다음 스트림으로
   2. distinct() : 중복된 원소를 제거
   3. limit(숫자) : 주어진 개수만큼의 원소만 다음 스트림으로
   4. skip(숫자) : 주어진 개수만큼 스트림 원소를 건너 뛴다

 

예시

import java.util.stream.IntStream;
import java.util.stream.Stream;

public class FilterDemo {
	public static void main(String[] args) {
    	// 스트림 분리형
		System.out.println("문자열 스트림 : ");
		Stream<String> s1 = Stream.of("a1","b1","b2","c1","c2","c3");
		Stream<String> s2 = s1.filter(x->x.startsWith("c"));
		Stream<String> s3 = s2.skip(1);
		s3.forEach(Util::print);
		
        //스트림 파이프라인
		System.out.println("\n정수 스트림 : ");
		IntStream i1 = IntStream.of(1,2,1,3,3,2,4);
		i1.filter(x -> x%2 ==0).
			distinct().
			forEach(Util::print);
	}
}

 

 

 

---

매핑

1. 입력 스트림을 다른 종류의 스트림으로 변경
2. 메소드
   1. map(람다식) : 주어진 람다식을 이용하여 입력 스트림의 객체를 다른 타입으로 매핑한다
   2. flatMap() : 그룹 원소를 낱개 원소로 펼치는 평면화 작업 수행 (문장을 단어로 분리)
   3. mapToObj() : 숫자 스트림을 객체 스트림으로 매핑
   4. mapToInt() : 다른 타입의 스트림을 IntStream으로 매핑
   5. asLongStream() : IntStream을 LongStream으로 매핑
   6. asDoubleStream() : IntStream을 DoubleStream으로 매핑

 

예시

import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Map1Demo {
	public static void main(String[] args) {
		Stream<String> s1 = Stream.of("a1","b1","b2","c1","c2");
		Stream<String> s2 = s1.map(String::toUpperCase);
		s2.forEach(Util::print);
		System.out.println();
		
		Stream<Integer> i1 = Stream.of(1,2,1,3,3,2,4);
		i1.map(x -> x * 2).
			forEach(Util::print);
		System.out.println();
		
		Stream<String> s3 = Stream.of("a1","a2","a3");
		
		Stream<String> s4 = s3.map(a -> a.substring(1));
		IntStream i3 = s4.mapToInt(Integer::parseInt);
		Stream<String> s5 = i3.mapToObj(i -> "b" + i);
		
		s5.forEach(Util::print);
	}
}

 

예시2

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Map3Demo {
	public static void main(String[] args) {
		List<String> list1 = List.of("안녕, 자바!", "잘 가, C++!");
		Stream<String> s1 = list1.stream();
		Stream<String> s2 = s1.flatMap(s -> Arrays.stream(s.split(" ")));
		s2.forEach(Util::printWithParenthesis);
		System.out.println();
		
		List<String> list2 = List.of("좋은 아침");
		List<String> list3 = List.of("안녕! 람다", "환영! 스트림");
		
		Stream<List<String>> s3 = Stream.of(list1, list2, list3);
		
		Stream<String> s4 = s3.flatMap(list ->{
			if(list.size()>1)
				return list.stream();
			else
				return Stream.empty();
		});
		s4.forEach(Util::printWithParenthesis);;
	}
}

 

 

 

---

정렬

1. 입력된 스트림 원소 전체를 정렬
2. 중간 연산
3. 버퍼가 필요하다 
4. 숫자 스트림과 문자열 스트림에 정렬 연산을 수행하려면 sorted() 연산 사용
5. 메소드
   1. sorted()
   2. sorted(Comparator.comparing())

예시

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

public class SortedDemo {
	public static void main(String[] args) {
		Stream<String> s1 = Stream.of("d2","a2","b1","b3","c");
		Stream<String> s2 = s1.sorted();
		s2.forEach(Util::print);
		
		System.out.println("국가 이름 순서");
		Stream<Nation> n1 = Nation.nations.stream();
		Stream<Nation> n2 = n1.sorted(Comparator.comparing(Nation::getName));
		Stream<String> s3 = n2.map(x -> x.getName());
		s3.forEach(Util::printWithParenthesis);
		
		System.out.println("국가 GDP 순서");
		Stream<Nation> n3 = Nation.nations.stream();
		Stream<Nation> n4 = n3.sorted(Comparator.comparing(Nation::getGdpRank));
		Stream<String> s4 = n4.map(Nation::getName);
		s4.forEach(Util::printWithParenthesis);
	}
}

 

 

 

---

매칭과 검색

1. 특정 속성과 일치되는 스트림 원소의 존재 여부를 조사하거나 검색하는데 사용
2. 최종 연산
3. 메소드
   1. anyMatch(람다식) : 람다식 조건에 맞는 것이 있는지(or) 조사해서 true, false 반환
   2. allMatch(람다식) : 람다식 조건에 모두 맞는지(and) 조사해서 true, false 반환
   3. noneMatch(람다식) : 람다식 조건에 안 맞는 게 있는지 조사해서 true, false 반환
   4. findAny() : 앞에서 넘겨준 조건 중에 첫 번째로 조건에 맞는 요소 찾기
   5. findFirst() : 

 

예시

import java.util.Optional;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class MatchDemo {
	public static void main(String[]args) {
		boolean b1 = Stream.of("a1","b2","c3").anyMatch(s->s.startsWith("c"));
		System.out.println(b1);
		
		boolean b2 = IntStream.of(10,20,30).allMatch(p -> p % 3 ==0);
		System.out.println(b2);
		
		boolean b3 = IntStream.of(1,2,3).noneMatch(p -> p == 3);
		System.out.println(b3);
		
		if(Nation.nations.stream().allMatch(d -> d.getPopulation() > 100.0))
			System.out.println("모든 국가의 인구각 1억이 넘는다.");
		else
			System.out.println("모든 국가의 인구가 1억이 넘지 않는다.");
		
		Optional<Nation> nation = Nation.nations.stream().findFirst();
		nation.ifPresentOrElse(Util::print, () -> System.out.print("없음."));
		System.out.println();
		
		nation = Nation.nations.stream().filter(Nation::isIsland).findAny();
		nation.ifPresent(Util::print);
	}
}

 

 

 

---

루핑과 단순 집계

루핑 (looping)

1. 전체 원소를 반복하는 연산
2. 메소드
   1. forEach() : 최종 연산.
   2. peek() : 중간 연산.

 

단순 집계 (reduction)

1. 스트림을 사용하여 스트림의 원소 개수, 합계, 평균값, 최댓값, 최솟값 등과 같은 값을 도출
2. count(), sum(), average(), max(), min()
3. max()와 min()은 매개 값이 필요하다면 Comparator타입을 이용
4. count()와 sum()을 제외하고는 옵션 타입을 반환

 

예시

import java.util.*;
import java.util.stream.*;

public class LoopAggregateDemo {
	public static void main(String[] args) {
		Stream<Nation> sn = Nation.nations.stream().peek(Util::printWithParenthesis);
		//peek은 중간 연산자라서 바로 연산 안 되고 기다린다.
		System.out.println("어디 나타날까?");
		//peek이 최종연산자인 max를 만나면서 출력을 하고, comparing을 실행해서 결과를 Optional에 담는다
		
		Optional<Nation> on = sn.max(Comparator.comparing(Nation::getPopulation));
		System.out.println();
		System.out.println(on.get());
		//인구 수가 가장 많은 나라 출력하는데 Optional 객체를 출력
		
		System.out.println(IntStream.of(5,1,2,3).min().getAsInt());
		
		sn = Nation.nations.stream();
		System.out.println(sn.count());
	}
}