03.스트림과 람다를 이용한 효과적 프로그래밍
컬렉션 API 개선
컬렉션 팩토리
반환 객체는 불변
List Factory
//Before
List<String> friends = Arrays.asList("Park", "Kim", "Jeong");
//After
List<String> friends = List.of("Park", "Kim", "Jeong")Set Factory
Set<String> friends = Set.of("Park", "Kim", "Jeong");Map Factory
// 열 개 이하의 키/값 쌍을 가진 작은 맵을 만들 경우
Map<String, Integer> ageOfFriends = Map.of("Park", 20, "Kim", 21, "Jeong", 25);
// 그 이상의 맵 생성 (Map.enty: Map.Entry 객체를 만드는 새로운 팩토리 메서드)
import static java.util.Map.entry;
Map<String, String> ageOfFriends = Map.ofEntries(
entry("Park", 20),
entry("Kim", 21),
entry("Jeong", 25));리스트와 집합 처리
기존 컬렉션 객체와 Iterator 객체를 혼용한 삭제, 수정은 쉽게 문제를 일으켰었다.
그래서, java8에서는 List, Set Interface 에 새로운 메서드가 추가되었다. (기존 컬렉션 자체를 수정)
removeIf
Predicate를 만족하는 요소 제거 (List, Set)
transactions.removeIf(transaction ->
Character.isDigit(transaction.getReferenceCode().charAt(0)));replaceAll
UnaryOperator 함수를 이용하여 요소 교체 (List)
referenceCodes.replaceAll(code -> Character.toUpperCase(code.charAt(0)) + code.substring(1));sort
리스트 정렬 (List)
list.sort(Comparator.naturalOrder()); // 오름차순
list.sort(Comparator.reverseOrder());
list.sort(String.CASE_INSENSITIVE_ORDER); // 대소문자 구분없이 오름차순
list.sort(Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER));맵 처리
1. forEach
기존 맵에서 키/값을 반복하며 확인했다면, forEach 메서드를 사용해보자.
ageOfFriens.forEach((friend, age) -> System.out.println(friens + " is" + age + " years old"));2. Order
Entry.comparingByValue / Entry.comparingByKey
favouriteMovies.entrySet().stream()
.sorted(Entry.comparingByKey()) // 오름차순
// .sorted(Entry.comparingByKey(Comparator.reverseOrder())) // 내림차순
.forEachOrdered(System.out::println);3. getOrDefault
찾으려는 키가 존재하지 않으면 기본값을 반환 getOrDefault(key, default)
Map<String, String> favouriteMovies = Map.ofEntries(
entry("Raphael", "Star Wars"),
entry("Olivia", "James Bond"));
System.out.println(favouriteMovies.getOrDefault("Olivia", "Matrix")); // James Bond
System.out.println(favouriteMovies.getOrDefault("Thibaut", "Matrix")); // Matrix4. Compute Pattern
computeIfAbsent
제공된 키에 해당하는 값이 없으면(값이 없거나 널), 키를 이용해 새 값을 계산하고 맵에 추가
현재 키와 관련된 값이 맵에 존재하며 널이 아닐 때만 새 값을 계산
Map<String, byte[]> dataToHash = new HashMap<>();
MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
lines.forEach(line ->
dataToHash.computeIfAbsent(line, // 맵에서 찾을 키
this::calculateDigest)); // 키가 존재하지 않을 경우 동작
private byte[] calculateDigest(String key) {
return messageDigest.digest(key.getBytes(StandardCharsets.UTF_8));
}
// Map이 여러 값을 저장하는 형태일 경우
friendsToMovies.computeIfAbsent("Raphael", name -> new ArrayList<>())
.add("Star Wars");computeIfPresent
제공된 키가 존재하면 새 값을 계산하고 맵에 추가
compute
제공된 키로 새 값을 계산하고 맵에 저장
5. Remove Pattern
//제공된 키에 해당하는 맵 항목 제거
favouriteMovies.remove(key)
//키가 특정한 값과 연관되어 있을 경우에만 항목을 제거하는 오버로드 버전 메서드
favouriteMovies.remove(key, value);
//특정 조건에 해당하는 항목 삭제
favouriteMovies.entrySet().removeIf(entry -> entry.getValue < 10);6. Replace Pattern
replaceAll
BiFunction 을 적용한 결과로 각 항목의 값을 교체
Map<String, String> favouriteMovies = new HashMap<>();
favouriteMovies.put("Raphael", "Star Wars");
favouriteMovies.put("Olivia", "james bond");
favouriteMovies.replaceAll((friend, movie) -> movie.toUpperCase());Replace
키가 존재하면 맵의 값 교체
7. Merge
두 개의 맵에서 값을 합치거나 교체할 경우 사용
중복된 키가 없을 경우
Map<String, String> family = Map.ofEntries(
entry("Teo", "Star Wars"), entry("Cristina", "James Bond"));
Map<String, String> friends = Map.ofEntries(
entry("Raphael", "Star Wars"));
Map<String, String> everyone = new HashMap<>(family);
everyone.putAll(friends);중복된 키가 있을 경우
Map<String, String> family = Map.ofEntries(
entry("Teo", "Star Wars"), entry("Cristina", "James Bond"));
Map<String, String> friends = Map.ofEntries(
entry("Raphael", "Star Wars"), entry("Cristina", "Matrix"));
Map<String, String> everyone = new HashMap<>(family);
friends.forEach((k, v) -> // forEach + merge 로 key 충돌 해결
everyone.merge(k, v, (movie1, movie2) -> movie1 + " & " + movie2));초기 검사 구현이 필요할 경우
지정된 키와 연관된 값이 없거나 널이면, 두 번째 인수를 키와 연결
그렇지 않을 경우, 세 번째 인자의 BiFunction을 적용
moviesToCount.merge(movieName, 1L, (key, count) -> count + 1L);ConcurrentHashMap
ConcurrentHashMap 클래스는 동시 친화적이며 내부 자료구조의 특정 부분만 잠궈 동시 추가, 갱신 작업을 허용
forEach
각 (키/값) 쌍에 주어진 액션 실행
reduce
모든 (키/값) 쌍을 제공된 리듀스 함수를 이용해 결과로 합침
search
널이 아닌 값을 반환할 떄까지 각 (키/값) 쌍에 함수 적용
(키/값) 인수를 이용한 네 가지 연산 형태 지원
ConcurrentHashMap 상태를 잠그지 않고 연산을 수행하므로, 연산에 제공한 함수는 계산이 진행되는 동안 바뀔 수 있는 객체, 값, 순서 등에 의존하면 안 됨!
키/값으로 연산 :
forEach,reduce,search키로 연산 :
forEachKey,reduceKeys,searchKeys값으로 연산 :
forEachValue,reduceValues,searchValuesMap.entry 객체로 연산 :
forEachEntry,reduceEntries,searchEntriess
Count
mappingCount
맵의 매핑 개수를 반환 (매핑 개수가 int의 범위를 넘어서는 이후의 상황 대처)
리팩터링, 테스팅, 디버깅
리팩터링
코드 가독성 개선
코드 가독성이 좋다?란 '어떤 코드를 다른 사람도 쉽게 이해할 수 있음'을 의미한다.
1. 익명 클래스를 람다 표현식으로 리팩터링하기
익명 클래스에서 사용한 this와 super는 람다 표현식에서 다른 의미를 갖는다.
익명 클래스에서 this는 익명 클래스 자신
람다에서 this는 람다를 감싸는 클래스
익명 클래스는 감싸고 있는 클래스의 변수를 가릴 수 있다.
람다 표현식으로는 불가
/*
* 익명 클래스 사용
*/
Runnable r1 = new Runnable() {
public void run() {
System.out.println("Hello");
}
};
/*
* 람다 표현식 사용
*/
Runnable r2 = () -> System.out.println("Hello");
interface Task {
public void execute();
}
public static void doSomething(Runnable r) { r.run(); }
public static void doSomething(Task a) { r.execute(); }
// 람다 표현식의 대상 형식이 모호할 경우 명시적 형변환을 이용
doSomething((Task)() -> System.out.println("Hello"));
doSomething((Runnable)() -> System.out.println("Hello"));2. 람다 표현식을 메서드 참조로 리팩터링하기
/*
* 람다 표현식 사용
*/
Map<CaloricLevel, List<Dish> dishesByCaloricLevel =
menu.stream().collect(
groupingBy(dish -> {
if (dish.getCalories() <= 400) { return CaloricLevel.DIET; }
else if (dish.getCalories() <= 700) { return CaloricLevel.NORMAL; }
else { return CaloricLevel.FAT; }
}));
/*
* 메서드 참조 사용
*/
public class Dish {
//...
public CaloricLevel getCaloricLevel() {
if (dish.getCalories() <= 400) { return CaloricLevel.DIET; }
else if (dish.getCalories() <= 700) { return CaloricLevel.NORMAL; }
else { return CaloricLevel.FAT; }
}
}
Map<CaloricLevel, List<Dish>< dishesByCaloricLevel =
menu.stream().collect(groupingBy(Dish::getCaloricLevel));// 람다 표현식 사용
inventory.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
// 정적 헬퍼 메서드(comparing, maxBy) 참조 사용
inventory.sort(comparing(Apple::getWeight));
// 람다 표현식 사용
int totalCalories = menu.stream().map(Dish::getCalories).reduce(0, (c1, c2) -> c1 + c2);
// 내장 헬퍼 메서드(sum, maximum) 참조 사용
int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));3. 명령형 데이터 처리를 스트림으로 리팩터링하기
스트림 API로 데이터 처리 파이프라인의 의도를 더 명확하게 보여주자.
/*
* 명령형 코드
*/
List<String> dishNames = new ArrayList<>();
for(Dish dish: menu) {
if(dish.getCalories() > 300) {
dishNames.add(dish.getName());
}
}
/*
* 스트림 API
*/
menu.parallelStream()
.filter(d -> d.getCalories() > 300)
.map(Dish::getName)
.collect(toList());4. 코드 유연성 개선
람다 표현식을 이용해서 동작 파라미터화를 쉽게 구현해보자.
함수형 인터페이스 적용
람다 표현식을 이용하기 위해 함수형 인터페이스를 추가
조건부 연기 실행
// Before : 복잡한 제어 흐름 코드 (상태 노출 및 매번 상태 체크) if (logger.isLoggable(Log.FINER)) { logger.finer("Problem: " + generateDiagnostic()); } // After : 가독성과 캡슐화 강화 public void log(Level level, Supplier<String> msgSupplier) { if(logger.isLoggable(level)) { log(level, msgSupplier.get()); } } logger.log(Level.FINER, () -> "Problem: " + generateDiagnostic());실행 어라운드
준비, 종료 과정을 처리하는 로직을 재사용하여 코드 중복 줄이기
String oneLine = processFile((BufferedReader b) -> b.readLine()); // 람다 전달 String twoLines = processFile((BufferedReader b) -> b.readLine() + b.readLine()); // 다른 람다 전달 public static String processFile(BufferedReaderProcessor p) throws IOException { try (BufferedReader br = new BufferedReader(new FileReader("Aaron/MJIA/test.txt"))) { return p.process(br); // 인수로 전달된 BufferedReaderProcessor 실행 } } // IOException을 던질 수 있는 람다의 함수형 인터페이스 public interface BufferedReaderProcessor { String process(BufferedReader b) throws IOException; }
람다 테스팅
Example
public class Point {
private final int x;
private final int y;
public final static Comparator<Point> compareByXAndThenY =
comparing(Point::getX).thenComparing(Point::getY);
private Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() { return x; }
public int getY() { return y; }
public Point moveRightBy(int x) {
return new Point(this.x + x, this.y);
}
}@Test
public void testMoveRightBy() throws Exception {
Point p1 = new Point(5, 5);
Point p2 = p1.moveRightBy(10);
assertEquals(15, p2.getX());
assertEquals(5, p2.getY());
}1. 보이는 람다 표현식의 동작 테스팅
람다는 익명이므로 테스트 코드 이름을 호출할 수 없다.
필요 시
람다를 필드에 저장해서 재사용하거나, 람다 로직 테스트가 가능하다.람다 표현식은 함수형 인터페이스의 인스턴스를 생성하므로
인스턴스의 동작으로 람다 표현식을 테스트할 수 있다
public class Point {
//...
public final static Comparator<Point> compareByXAndThenY =
comparing(Point::getX).thenComparing(Point::getY);
//...
}@Test
public void testComparingTwoPoints() throws Exception {
Point p1 = new Point(10, 15);
Point p2 = new Point(10, 25);
int result = Point.compareByXAndThenY.compare(p1, p2);
assertTrue(result < 0);
}2. 람다를 사용하는 메서드의 동작에 집중하자
람다의 목표는 정해진 동작을 다른 메서드에서 사용할 수 있도록,
하나의 조각으로 캡슐화하는 것세부 구현을 포함하는 람다 표현식을 공개하지 말아야 한다.
public static List<Point> moveAllPointsRightBy(List<Point> points, int x) {
return points.stream()
.map(p -> new Point(p.getX() + x, p.getY()))
.collect(toList());
}@Test
public void testMoveAllPointsRightBy() throws Exception {
List<Point> points = Arrays.asList(new Point(5, 5), new Point(10, 5));
List<Point> expectedPoints = Arrays.asList(new Point(15, 5), new Point(20, 5));
List<Point> newPoints = Point.moveAllPointsRightBy(points, 10);
assertEquals(expectedPoints, newPoints);
}3. 복잡한 람다를 개별 메서드로 분할하기
많은 로직을 포함하는 복잡한 람다 표현식의 경우, 람다 표현식을 메서드 참조로 바꾸자.
// 람다 표현식을 메서드 참조로 바꾼 예시
public class Dish {
//...
public CaloricLevel getCaloricLevel() {
if (dish.getCalories() <= 400) { return CaloricLevel.DIET; }
else if (dish.getCalories() <= 700) { return CaloricLevel.NORMAL; }
else { return CaloricLevel.FAT; }
}
}
Map<CaloricLevel, List<Dish> dishesByCaloricLevel =
menu.stream().collect(groupingBy(Dish::getCaloricLevel));4. 고차원 함수 테스팅
메서드가 함수를 인수로 받을 경우, 다른 람다로 메서드 동작을 테스트
@Test public void testFilter() throws Exception { List<Integer> numbers = Arrays.asList(1, 2, 3, 4); List<Integer> even = filter(numbers, i -> i % 2 == 0); List<Integer> smallerThanThree = filter(numbers, i -> i < 3); assertEquals(Arrays.asList(2, 4), even); assertEquals(Arrays.asList(1, 2), smallerThanThree); }다른 함수를 반환하는 메서드의 경우, 함수형 인터페이스의 인스턴스로 간주하고 함수의 동작을 테스트
디버깅
1. 스택 트레이스 확인하기
스택 트레이스를 통해 프로그램이 어디서, 어떻게 멈추게 되었는지 살펴보자.
다만, 람다 표현식은 이름이 없어서 복잡한 스택 트레이스가 생성된다.
메서드 참조를 사용해도 스택 트레이스에서는 메서드명이 나타나지 않는다.
따라서, 람다 표현식과 관련한 스택 트레이스는 이해하기 어려울 수 있다.
2. 정보 로깅
peek스트림 연산을 활용하여 스트림 파이프라인에 적용된 각 연산이 어떤 결과를 도출하는지 확인할 수 있다.
List<Integer> result =
Stream.of(2, 3, 4, 5) //or numbers.stream()
.peek(x -> System.out.println("from stream: " + x)) // 소스에서 처음 소비한 요소
.map(x -> x + 17)
.peek(x -> System.out.println("after map: " + x)) // map 동작 실행 결과
.filter(x -> x % 2 == 0)
.peek(x -> System.out.println("after filter: " + x)) // filter 동작 후 선택된 숫자
.limit(3)
.peek(x -> System.out.println("after limit: " + x)) // limit 동작 후 선택된 숫자
.collect(toList());Last updated