🦊 chap9. 리팩터링, 테스팅, 디버깅

chap8. 컬렉션 API 개선

8.1 컬렉션 팩토리

자바 9에서는 작은 컬렉션 객체를 쉽게 만들 수 있는 몇 가지 방법을 제공한다.

List<String> friends = new ArrayList<>();
friends.add("Raphael");
friends.add("Olivia");
friends.add("Thibaut");

적은 요소를 포함하는 리스트를 팩토리 메서드로 간단하게 줄일 수 있다.

List<String> friends
		= Arrays.asList("Rapheal", "Olivia", "Thibaut");

이는 고정 크기의 리스트로 요소를 추가하거나 삭제할 수 없다.

요소의 갱신은 가능하다.

UnsupportedOperationException 예외 발생

내부적으로 고정된 크기의 변환할 수 있는 배열로 구현되었기 때문에 예왹 ㅏ발생한다.

Arrays.asSet() 이라는 팩토리 메서드는 없으므로 다른 방법이 필요하다.

Set<String> friends
			= new HashSet<>(Arrays.asList("Raphael", "Olivia", "Thibaut"));

Set<String> friends
			= Stream.of("Raphael", "Olivia", "Thibaut")
							.collect(Collectors.toSet());

하지만 두 방법 모두 매끄럽지 못하며 내부적으로 불필요한 객체 할당이 필요하다.

또한 결과는 변환할 수 있는 집합이라는 사실에 주목하자.

8.1.1 리스트 팩토리

List<String> friends = List.of("Raphael", "Olivia", "Thibaut");

List.of 팩토리 메서드를 이용하여 간단하게 리스트를 만들 수 있다.

이 리스트는 불변리스트로 add 또는 set 메서드로 리스트를 바꾸려 하면 java.lang.UnsupportedOperationException 이 발생한다.

또한 null 요소를 금지하여 의도치 않은 버그를 방지하고 조금 더 간결한 내부 구현을 달성했다.

List 인터페이스에는 List.of 의 다양한 오버로드 버전이 있다.

왜 가변 인자로 다중 요소를 받을 수 있도록 하지 않았을까?

내부적으로 가변 인수 버전은 추가 배열을 할당해서 리스트로 감싼다.

즉 배열을 할당하고 초기화하며 나중에 GC에 대한 비용을 지불해야 한다.

고정된 숫자의 요소를 API로 정의하면 이런 비용을 제거할 수 있다.

데이터 처리 형식을 설정하거나 데이터를 변환할 필요가 없다면 사용하기 간편한 팩토리 메서드를 이용하자!

8.1.2 집합 팩토리

Set<String> friends = Set.of("Raphael", "Olivia", "Thibaut");

중복된 요소를 제공해 집합을 만들려고 하면

예를 들어 Olivia 라는 요소가 중복되어 있다는 설명과 함께 IllegalArgumentException 이 발생한다.

8.1.3 맵 팩토리

Map<String, Integer> ageOfFriends
		= Map.of("Raphael", 30, "Olivia", 25, "Thibaut", 26);

Map.of 팩토리 메서드에 키와 값을 번갈아 제공하는 방법으로 맵을 만들 수 있다.

열 개 이하의 키 값 쌍에서는 이 메소드가 유용하지만, 그 이상에서는 Map.Entry<K, V> 객체를 인수로 받으며 가변 인수로 구현된 Map.ofEntries 를 이용하자.

Map<String, Integer> ageOfFriends =
		Map.ofEntries(entry("Raphael", 30),
									entry("Olivia", 25),
									entry("Thibaut", 26));

8.2 리스트와 집합 처리

자바 8에서는 List, Set 인터페이스에 다음과 같은 메서드를 추가했다.

• removeIf : Predicate 를 만족하는 요소를 제거한다.
• replaceAll : List 에서 UnaryOperation 함수를 이용해 요소를 바꾼다.
• sort : List 를 정렬한다.

이들은 새로운 결과를 만드는 것이 아니라 호출한 컬렉션 자체를 바꾼다.

8.2.1 removeIf 메서드

for (Transaction transaction : transactions) {
	if (Character.isDigit(transaction.getReferenceCode().charAt(0))) {
		transactions.remove(transaction);
	}
}

이는 숫자로 시작되는 참조 코드를 가진 트랜잭션을 삭제하는 코드이다.

니는 ConcurrentModificationException 을 발생시킨다.

내부적으로 for-each 루프는 Iterator 객체를 사용하기 때문에 다음과 같이 해석된다.

for (Iterator<Transaction> iterator = transactions.iterator(); iterator.hasNext(); ){
	Transaction transaction = iterator.next();
	if (Character.isDigit(transaction.getReferenceCode().charAt(0))) {
		transactions.remove(transaction);
	}
}

결과적으로 반복자의 상태와 컬렉션의 상태와 서로 동기화되지 않는다.

Iterator 객체를 명시적으로 사용하고 그 객체의 remove() 를 호출함으로 이 문제를 해결하자.

for (Iterator<Transaction> iterator = transactions.iterator(); iterator.hasNext(); ){
	Transaction transaction = iterator.next();
	if (Character.isDigit(transaction.getReferenceCode().charAt(0))) {
		iterator.remove();
	}
}

이 복잡한 코드는 자바 8의 removeIf 메서드로 바꿀 수 있다.

코드가 단순해질 뿐 아니라 버그도 예방할 수 있다.

transactions.removeIf(transaction -> 
		Character.isDigit(transaction.getReferenceCode.charAt(0)));

8.2.2 replaceAll 메서드

referenceCodes.stream()
			.map(code -> Character.toUpperCase(code.charAt(0)) + code.substring(1))
			.collect(Collectors.toList())

스트림 API 를 이용해 리시트의 각 요소를 새로운 요소로 바꿀 수 있다.

하지만 이 코드는 새 문자열 컬렉션을 만든다. 기존 컬렉션을 바꾸려면 ListIterator 객체를 이용한다.

for (ListIterator<String> iterator = referenceCodes.listIterator(); iterator.hasNext(); ){
	String code = iterator.next();
	iterator.set(Character.toUpperCase(code.charAt(0)) + code.substring(1));
}

코드가 복잡해졌고 컬렉션 객체와 Iterator 객체를 혼용하면 반복과 동시에 컬렉션 변경이 이루어지며 쉽게 문제를 일으킨다.

refereceCodes.replaceAll(code -> Character.toUpperCase(code.charAt(0)) + code.substring(1));

8.3 맵 처리

8.3.1 forEach 메서드

Map.Entry<K, V> 의 반복자를 이용해 맵의 항목 집합을 반복할 수 있다.

for(Map.Entry<String, Integer> entry: ageOfFriends.entrySet()) {
	String friend = entry.getKey();
	Integer age = entry.getValue();
}

자바 8에서부터 Map 인터페이스는 BiConsumer 를 인수로 받는 forEach 메서드를 지원한다.

ageOfFriends.forEach((friends, age) -> System.out.println(friend + age));

8.3.2 정렬 메서드

다음 두 개의 새로운 유틸리티를 이용하여 맵의 항목을 값 또는 키를 기준으로 정렬할 수 있다.

• Entry.comparingByValue
• Entry.comparingByKey

favouriteMovies
	.entrySet()
	.stream()
	.sorted(Entry.comparingByKey())
	.forEachOrdered(System.out::println);

자바 8에서는 HashMap 의 내부 구조를 바꿔 성능을 개선했다.

기존 맵은 키로 생성한 해시코드로 접근할 수 있는 킷에 저장했다.

다만 많은 키가 같은 해시코드를 반환하면 O(n) 의 시간이 걸리는 LinkedList 로 버킷을 반환하여 성능이 저하된다.

최근에는 버킷이 너무 커질 경우 이를 O(log n) 으로 소요되는 정렬된 트리를 이용해 동적으로 치환하여 성능을 개선했다.

다만 이는 key 값이 String ,Number 같은 Comparable 형태여야만 지원된다.

8.3.3 getOrDefault 메서드

기존에는 키가 존재하지 않으면 null 이므로 NullPointerException 을 방지하려면 널 체크가 필요했다.

기본값을 반환하는 방식으로 이를 해결할 수 있다.

Map<String, String> favouriteMovies =
			Map.ofEntries(entry("Raphael", "Star Wars"), entry("Olivia", "James Bond"));

favouriteMovies.getOrDefault("Olivia", "Matrix"));

첫 번째 인수인 키가 존재하지 않으면 두 번째 인수인 기본값을 반환한다.

8.3.4 계산 패턴

키를 이용해 값비싼 동작을 실행해서 얻은 결과를 캐시하려 한다.

• computeIfAbsent : 제공된 키에 해당하는 값이 없으면, 키를 이용해 새 값을 계산하고 맵에 추가
• computeIfPresent : 제공된 키가 존재하면 새 값을 계산하고 맵에 추가
• compute : 제공된 키로 새 값을 계산하고 맵에 저장

여러 값을 저장하는 맵을 처리할 때도 이 패턴을 활용할 수 있다.

String friend = "Raphael";
List<String> movies = friendsToMovies.get(friend);
if (movies == null) {
	movies = new ArrayList<>();
	friendsToMovies.put(friend, movies);
}
movies.add("Star Wars");

이를 computeIfAbsent 를 활용하면

friendsToMovie.computeIfAbsent("Raphael", name -> newArrayList<>())
							.add("Star Wars");

이 메서드는 현재 키과 관련된 값이 맵에 존재하며 null 이 아닐 때만 새 값을 계산한다.

8.3.5 삭제 패턴

String key = "Raphael";
String value = "Jack Reacher 2";
if (favouriteMovies.containsKey(key) && Objects.equals(favouriteMovies.get(key), value)) {
	favouriteMovies.remove(key);
	return true;
}
return false;

이를 다음처럼 간결하게 구현할 수 있다.

favouriteMovies.remove(key, value);

8.3.6 교체 패턴

• replaceAll : BiFunction 을 적용한 결과로 각 항목의 값을 교체한다.
• Replace : 키가 존재하면 맵의 값을 바꾼다.

Map<String, String> favouriteMovies = new HashMap<>();
favouriteMovies.replaceAll((friend, movie) -> movie.toUpperCase());

맵의 모든 값의 형식을 바꿀 수 있다.

8.3.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);

중복된 키가 없다면 위 코드는 잘 동작한다.

값을 더 유연하게 합쳐야 한다면 merge 메서드를 이용하자.

만약 두 맵 모두에 Cristina 가 다른 영화 값으로 존재한다고 가정하자.

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"));

forEach 와 merge 를 이용해 충돌을 해결할 수 있다..

Map<String, String> everyone = new HashMap<>(family);
friends.forEach((k, v) ->
		everyone.merge(k, v, (movie1, movie2) -> movie1 + " & " + movie2));

지정된 키와 연관된 값이 없거나 null 이면 null 이 아닌 값과 연결한다.

그렇지 않으면 매핑 함수의 결과 값으로 대치하거나 항목을 제거한다.

초기화 검사를 구현할 수도 있다.

moviesToCount.merge(movieName, 1L, (key, count) -> count + 1L);

8.4 개선된 ConcurrentHashMap

동시성 친화적이며 최신 기술을 반영한 HashMap 버전이다.

내부 자료구조의 특정 부분만 잠궈 동시 추가, 갱신 작업을 허용한다.

따라서 동기화된 HashTable 버전에 비해 읽기 쓰기 연산 성능이 월등하다.

8.4.1 리듀스와 검색

스트림과 비슷한 종류의 세 가지 새로운 연산을 지원한다.

• forEach : 각 key, value 쌍에 주어진 액션을 실행
• reduce : 모든 key, value 쌍을 합침
• search : null 이 아닌 값을 반환할 때까지 key, value 쌍에 함수를 적용

다음처럼 키에 함수 받기, 값, Map.Entry, (key, value) 인수를 이용한 네 가지 연산 형태를 지원한다.

• (key, value)로 연산 : forEach, reduce, search
• key로 연산 : forEachKey, reduceKeys, searchKeys
• value 로 연산 : forEachValue, reduceValue, searchValue
• Map.Entry 객체로 연산 : forEachEntry, reduceEntries, searchEntries

이들 연산은 ConcurrentHashMap 의 상태를 잠그지 않고 연산을 수행한다.

또한 병렬성 기준값을 기정해야 한다.

맵의 크기가 주어진 기준값보다 작으면 순차적으로 연산을 실행한다.

기준값을 1로 지정하면 공통 스레드 풀을 이용해 병렬성을 극대화한다.

Long.MAX_VALUE 로 지정하면 한 개의 스레드만으로 연산을 실행한다.

8.4.2 계수

맵의 매핑 개수를 반환하는 mappingCount 메서드를 제공한다.

기존의 size 메서드 대신 int 를 반환하는 mappingCount 메서드를 사용하는 것이 좋다.

8.4.3 집합뷰

집합뷰로 반환하는 keySet 이라는 메서드를 제공한다.

맵을 바꾸면 집합도 바뀌고, 집합을 바꾸면 맵도 영향을 받는다.