Java ‐ Stream - dnwls16071/Backend_Summary GitHub Wiki

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CollectorMain {
	public static void main(String[] args) {

		// 기본 기능
		List<String> list = Stream.of("Java", "Spring", "JPA")
				.collect(Collectors.toList());
		System.out.println("list = " + list);

		// 수정 불가능 리스트
		List<Integer> unmodifiableList = Stream.of(1, 2, 3)
				.collect(Collectors.toUnmodifiableList());
		//unmodifiableList.add(4); // 런타임 예외
		System.out.println("unmodifiableList = " + unmodifiableList);

		Set<Integer> set = Stream.of(1, 2, 2, 3, 3, 3)
				.collect(Collectors.toSet());
		System.out.println("set = " + set);

		// 타입 지정
		Set<Integer> treeSet = Stream.of(3, 4, 5, 2, 1)
				.collect(Collectors.toCollection(TreeSet::new));
		System.out.println("treeSet = " + treeSet);

		Map<String, Integer> map1 = Stream.of("Apple", "Banana", "Tomato")
				.collect(Collectors.toMap(
					name -> name, // keyMapper
					name -> name.length() // valueMapper
				));
		System.out.println("map1 = " + map1);

		Map<String, Integer> map3 = Stream.of("Apple", "Apple", "Banana")
				.collect(Collectors.toMap(
					name -> name,
					name -> name.length(),
					(oldVal, newVal) -> oldVal + newVal // 중복될 경우 기존 값 + 새 값
				));
		System.out.println("map3 = " + map3);

		// Map의 타입 지정
		LinkedHashMap<String, Integer> map4 = Stream.of("Apple", "Apple", "Banana")
				.collect(Collectors.toMap(
					name -> name,
					String::length,
					(oldVal, newVal) -> oldVal + newVal, // key 중복 발생 시
					LinkedHashMap::new // 결과 Map 타입 지정
				));
		System.out.println("map4 = " + map4.getClass());
	}
}

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

public class CollectorMain {
	public static void main(String[] args) {

		// 첫 글자 알파벳을 기준으로 그룹화
		List<String> names = List.of("Apple", "Avocado", "Banana",
				"Blueberry", "Cherry");
		Map<String, List<String>> grouped = names.stream()
				.collect(Collectors.groupingBy(name -> name.substring(0, 1)));
		System.out.println("grouped = " + grouped);

		// 짝수(even)인지 여부로 분할(파티셔닝)
		List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
		Map<Boolean, List<Integer>> partitioned = numbers.stream()
				.collect(Collectors.partitioningBy(n -> n % 2 == 0));
		System.out.println("partitioned = " + partitioned);

		// 다운스트림 컬렉터에서 유용하게 사용
		Integer max1 = Stream.of(1, 2, 3)
				.collect(Collectors.maxBy(
						((i1, i2) -> i1.compareTo(i2)))
				).get();
		System.out.println("max1 = " + max1);

		Integer max2 = Stream.of(1, 2, 3)
				.max((i1, i2) -> i1.compareTo(i2)).get();
		System.out.println("max2 = " + max2);

		Integer max3 = Stream.of(1, 2, 3)
				.max((Integer::compareTo)).get();
		System.out.println("max3 = " + max3);

		// 기본형 특화 스트림 사용
		int max4 = IntStream.of(1, 2, 3)
				.max().getAsInt();
		System.out.println("max4 = " + max4);

		// 다운스트림 컬렉터에서 유용하게 사용
		long count1 = Stream.of(1, 2, 3)
				.collect(Collectors.counting());
		System.out.println("count1 = " + count1);

		long count2 = Stream.of(1, 2, 3)
				.count();
		System.out.println("count2 = " + count2);

		// 다운스트림 컬렉터에서 유용하게 사용
		double average1 = Stream.of(1, 2, 3)
				.collect(Collectors.averagingInt(i -> i));
		System.out.println("average1 = " + average1);

		// 기본형 특화 스트림으로 변환
		double average2 = Stream.of(1, 2, 3)
				.mapToInt(i -> i)
				.average().getAsDouble();
		System.out.println("average2 = " + average2);

		// 기본형 특화 스트림 사용
		double average3 = IntStream.of(1, 2, 3)
				.average().getAsDouble();
		System.out.println("average3 = " + average3);

		// 통계
		IntSummaryStatistics stats = Stream.of("Apple", "Banana", "Tomato")
				.collect(Collectors.summarizingInt(String::length));
		System.out.println(stats.getCount()); // 3
		System.out.println(stats.getSum()); // 17 (5+6+6)
		System.out.println(stats.getMin()); // 5
		System.out.println(stats.getMax()); // 6
		System.out.println(stats.getAverage()); // 5.66...

		List<String> alphabets = List.of("a", "b", "c", "d");

		// 모든 이름을 하나의 문자열로 이어 붙이기
		String joined1 = names.stream()
				.collect(Collectors.reducing(
						(s1, s2) -> s1 + "," + s2
				)).get();
		System.out.println("joined1 = " + joined1);

		String joined2 = names.stream()
				.reduce((s1, s2) -> s1 + "," + s2).get();
		System.out.println("joined2 = " + joined2);

		// 문자열 전용 기능
		String joined3 = names.stream()
				.collect(Collectors.joining(","));
		System.out.println("joined3: " + joined3);

		String joined4 = String.join(",", "a", "b", "c", "d");
		System.out.println("joined4: " + joined4);
	}
}

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class DownStreamCollectorMain {
	public static void main(String[] args) {

		List<Student> students = List.of(
				new Student("Kim", 1, 85),
				new Student("Park", 1, 70),
				new Student("Lee", 2, 70),
				new Student("Han", 2, 90),
				new Student("Hoon", 3, 90),
				new Student("Ha", 3, 89)
		);

		// 1단계: 학년별로 학생들을 그룹화 해라.
		Map<Integer, List<Student>> collect1_1 = students.stream()
				.collect(Collectors.groupingBy(
						Student::getGrade, // 그룹화 기준: 학년
						Collectors.toList() // 다운스트림1: 학생을 리스트로 수집
				));
		System.out.println("collect1_1 = " + collect1_1);

		// 다운스트림에서 toList() 생략 가능
		Map<Integer, List<Student>> collect1_2 = students.stream()
				.collect(Collectors.groupingBy(Student::getGrade));
		System.out.println("collect1_2 = " + collect1_2);

		// 2단계: 학년별로 학생들의 이름을 출력해라.
		Map<Integer, List<String>> collect2 = students.stream()
				.collect(Collectors.groupingBy(
						Student::getGrade, // 그룹화 기준: 학년
						Collectors.mapping(Student::getName, // 다운스트림 1: 학생 -> 이름 변환
		Collectors.toList() // 다운스트림 2: 변환된 값(이름)을 List로 수집
		)));
		System.out.println("collect2 = " + collect2);

		// 3단계: 학년별로 학생들의 수를 출력해라.
		Map<Integer, Long> collect3 = students.stream()
				.collect(Collectors.groupingBy(
						Student::getGrade,
						Collectors.counting()
				));
		System.out.println("collect3 = " + collect3);

		// 4단계: 학년별로 학생들의 평균 성적 출력해라.
		Map<Integer, Double> collect4 = students.stream()
				.collect(Collectors.groupingBy(
						Student::getGrade,
						Collectors.averagingInt(Student::getScore)
				));
		System.out.println("collect4 = " + collect4);
	}
}