package me.whiteship.chapter07.item43;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.BiFunction;
// map.merge를 이용해 구현한 빈도표 - 람다 방식과 메서드 참조 방식을 비교해보자. (259쪽)
public class Freq {
public static void main(String[] args) {
args = new String[] {"hello", "keesun"};
Map<String, Integer> frequencyTable = new TreeMap<>();
for (String s : args)
frequencyTable.merge(s, 1, (count, incr) -> count + incr); // 람다
System.out.println(frequencyTable);
frequencyTable.clear();
for (String s : args)
frequencyTable.merge(s, 1, Integer::sum); // 메서드 참조
System.out.println(frequencyTable);
}
private static Integer sum(Integer count, Integer incr) {
return count + incr;
}
}package me.whiteship.chapter07.item43;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.BiFunction;
// map.merge를 이용해 구현한 빈도표 - 람다 방식과 메서드 참조 방식을 비교해보자. (259쪽)
public class Freq {
public static void main(String[] args) {
args = new String[] {"hello", "keesun"};
Map<String, Integer> frequencyTable = new TreeMap<>();
for (String s : args)
frequencyTable.merge(s, 1, Freq::sum); // 람다
System.out.println(frequencyTable);
frequencyTable.clear();
for (String s : args)
frequencyTable.merge(s, 1, Integer::sum); // 메서드 참조
System.out.println(frequencyTable);
}
private static Integer sum(Integer count, Integer incr) {
return count + incr;
}
}
package me.whiteship.chapter07.item43;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.BiFunction;
// map.merge를 이용해 구현한 빈도표 - 람다 방식과 메서드 참조 방식을 비교해보자. (259쪽)
public class Freq {
public static void main(String[] args) {
args = new String[] {"hello", "keesun"};
Map<String, Integer> frequencyTable = new TreeMap<>();
for (String s : args)
frequencyTable.merge(s, 1, Freq::sum); // 람다
System.out.println(frequencyTable);
frequencyTable.clear();
for (String s : args)
frequencyTable.merge(s, 1, Integer::sum); // 메서드 참조
System.out.println(frequencyTable);
}
private static Integer sum(Integer count, Integer incr) {
return count + incr;
}
}43. 람다보다는 메서드 참조를 사용하라.
package me.whiteship.chapter07.item43.method_references;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class StaticMethodReference {
public static void main(String[] args) {
List<String> words = new ArrayList<>(Arrays.asList("aaa", "bbbbb", "c"));
System.out.println("Before sorting: " + words);
// 정적 메서드 참조
Collections.sort(words, StaticMethodReference::compareByLength);
System.out.println("After sorting: " + words);
}
public static int compareByLength(String s1, String s2) {
return Integer.compare(s1.length(), s2.length());
}
}
package me.whiteship.chapter07.item43.method_references;
import java.time.Instant;
import java.util.*;
import java.util.stream.Collectors;
public class BoundedMethodReference {
public static void main(String[] args) {
List<Instant> instants = new ArrayList<>();
instants.add(Instant.now().minusSeconds(10));
instants.add(Instant.now().plusSeconds(10));
instants.add(Instant.now().minusSeconds(20));
instants.add(Instant.now().plusSeconds(20));
Instant now = Instant.now();
// 한정적 메서드 참조
List<Instant> futureInstants = instants.stream()
.filter(now::isAfter)
// .filter(t -> now.isAfter(t))
.toList();
System.out.println("Future instants: " + futureInstants);
}
}
인스턴스 메서드를 참조하는 것이다.
package me.whiteship.chapter07.item43.method_references;
import java.util.*;
import java.util.stream.Collectors;
public class UnboundedMethodReference {
public static void main(String[] args) {
List<String> words = new ArrayList<>(Arrays.asList("Banana", "Apple", "Cherry"));
System.out.println("Before conversion: " + words);
// 비한정적 메서드 참조 1
List<String> lowerCaseWords = words.stream()
.map(String::toLowerCase)
// .map(s -> s.toLowerCase())
.toList();
System.out.println("After conversion: " + lowerCaseWords);
words = new ArrayList<>(Arrays.asList("banana", "apple", "cherry"));
System.out.println("Before sorting: " + words);
// 비한정적 메서드 참조 2
Collections.sort(words, String::compareTo);
// Collections.sort(words, (s1, s2) -> s1.compareTo(s2));
System.out.println("After sorting: " + words);
}
}인스턴스 메서드를 참조하는데 클래스를 통해서 참조를 한다.
람다에서의 첫 번째 인자가 수신자 역할을 한다.
첫번째 인자가 이 메서드를 실행을 한다.
어떤 인스턴스 하나로 고정되어있지가 않다. -> 비한정적이다.
s가 매번 달라진다. -> 비한정적이다.
어떤 인스턴스가 오더라도 모든 인스턴스를 toLowerCase로 하겠다.
now.instant는 now로 고정이 되어있다. -> 한정적이다.
package me.whiteship.chapter07.item43.method_references;
import java.util.*;
import java.util.stream.Collectors;
public class UnboundedMethodReference {
public static void main(String[] args) {
List<String> words = new ArrayList<>(Arrays.asList("Banana", "Apple", "Cherry"));
System.out.println("Before conversion: " + words);
// 비한정적 메서드 참조 1
List<String> lowerCaseWords = words.stream()
.map(String::toLowerCase)
// .map(s -> s.toLowerCase())
.toList();
System.out.println("After conversion: " + lowerCaseWords);
words = new ArrayList<>(Arrays.asList("banana", "apple", "cherry"));
System.out.println("Before sorting: " + words);
// 비한정적 메서드 참조 2
Collections.sort(words, String::compareTo);
Collections.sort(words, (s1, s2) -> s1.compareTo(s2));
System.out.println("After sorting: " + words);
}
}
package me.whiteship.chapter07.item43.method_references;
import java.util.Arrays;
import java.util.List;
public class ConstructorMethodReference {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
System.out.println("Names: " + names);
// 생성자 참조
List<Person> people = names.stream()
.map(Person::new)
// .map(name -> new Person(name))
.toList();
System.out.println("People: " + people);
}
}
원래는 Person::new가 아무것도 없는건지 아닌지 모른다.
근데 map이 value가 하나씩 돌아가면서 만들어지는 것이다.
저 자리에는 사실 .map(name -> new Person(name)) 이 코드가 있는거다.
