// 람다식 사용 조건
@FunctionalInterface
interface MyFunction {
void run();
}
public class Try1 {
public static void main(String[] args) {
// 람다식 사용 준비 비교
// 익명객체로 표현
MyFunction f1 = new MyFunction() {
@Override
public void run() {
System.out.println("1.1 변수에 넣은 익명객체");
}
};
// 람다식으로 표현
MyFunction f2 = ()->System.out.println("1.2 람다식을 활용한 익명객체, 익명클래스명과 메서드명 생략가능");
// 람다식 사용
f1.run();
f2.run();
}
}
2. 메서드 구현부
// 람다식 사용 조건
@FunctionalInterface
interface MyFunction {
void run();
}
public class Try1 {
// 메서드 구현부 준비
// 반환타입은 사용할 함수형 인터페이스로 해주면 해당 익명객체의 주소를 받을 수 있다.
// 꼭 반환타입을 함수형 인터페이스로 할 필요는 없다.
// 아래와 같이 바로 출력되게 할 수있다.
static MyFunction getMyFunction(){
MyFunction f = new MyFunction() {
@Override
public void run() {
System.out.println("2. 익명객체로 표현");
}
};
return f;
}
static MyFunction getMyFunction1(){
MyFunction f1 = ()-> System.out.println("2.1 메서드 구현부에서 람다식으로 작성, 익명객체로도 표현 가능");
return f1;
}
static void getMyFunction2(){
MyFunction f2 = ()-> System.out.println("2.2 메서드 구현부에서 람다식으로 작성");
f2.run();
}
public static void main(String[] args) {
// 람다식 사용
getMyFunction().run();
getMyFunction1().run();
getMyFunction2();
}
}
3. 매개변수 타입에 넣기
// 람다식 사용 조건
@FunctionalInterface
interface MyFunction {
void run();
}
public class Try1 {
// 매개변수로 준비
// 매개변수에 인터페이스 타입이 들어갈 수 있다.
// 이걸 사용할 때 lambda 식을 작성해야 한다.
static void execute(MyFunction f) {
f.run();
}
public static void main(String[] args) {
// 람다식 작성 및 사용
// 매개변수에는 MyFunction type의 객체가 들어가야하므로 실제 구현한 객체를 넣던가
// 내부에 익명객체로 넣어도 되고
// 조건이 성립시 람다식으로 더 간단하게 넣을 수 있다.
execute(()-> System.out.println("3. 매개변수 타입으로 넣어줌, 1.번 예제서 만든 f1을 넣어도 작동하고, 익명객체로 만드는 것도 가능"));
}
}
2. 함수형 인터페이스
2.1. java.util.function pacakge
자주 쓰이는 형식의 메서드를 함수형 인터페이스로 미리 정의해 놓은 것
개발 시 자기가 만드는 것보다 똑똑한 사람들한테 검증받은 패키지를 활용하는 것이 더욱 안전하다.
컬렉션 프레임워크 인터페이스의 default method의 매개변수 타입이 함수형 인터페이스로 된 목록
2.1. 과의 차이점
함수형 인터페이스 패키지 낱개낱개로 사용하지 않는다.
매개변수 타입으로 넣는다. 1.2의 3번 예제같이 사용한다는 뜻
현재 method를 보여줄 때 선언부만 작성되어 있지만 실제로는 구현부도 이미 구현된 상태이다.
우리는 method 선언부를 보고 상황에 맞게 사용하면 되는 것이다.
실제 사용하는 것을 보면 따로 타입을 지정하는 과정이 없는데 이는 Class type의 지네릭스로 부터 이미 타입을 받았기 때문
인터페이스
메서드
설명
Collection
boolean removeIf(Predicate<E> filter)
조건에 맞는 요소 삭제
List
void replaceAll(UnaryOperator<E> operator)
모든 요소를 변환하여 대체
Iterable
void forEach(Consumer<T> action)
모든 요소에 작업 action을 수행
Map
V compute(K key, BiFunction<K, V, V> f)
지정된 키의 값에 작업 f 수행
V computeIfAbsent(K key, Function<K,V> f)
키가 없으면 작업 f 수행후 추가
V computePresent(K key, BiFunction<K, V, V> f)
지정된 키의 값에 작업 f 수행
V merge(K key, V value, BiFunction<V, V, V> f)
모든 요소에 병합작업 f 수행
void forEach(BiConsumer<K, V> action)
모든 요소에 작업 action 수행
void replaceAll(BiFunction<K, V, V> f )
모든 요소에 치환작업 f 수행
2.3. 메서드 참조
조건: 하나의 메서드만 호출하는 람다식 -> 거의 대부분
목적: 그냥 더 줄이고 싶은 것뿐 연연하지 말기
아래와 같이 변경 가능
클래스이름::메서드이름
참조변수::메서드이름
// 원래 람다식
Consumer<Integer> c = k -> System.out.println(k);
Function<String, Integer>f = s->Integer.parseInt(s);
// 메서드 참조로 변경
Consumer<Integer> c = System.out::println;
Function<String, Integer>f = Integer::parseInt;
// 생성자 경우
Supplier<MyClass> s = () -> new MyClass();
Supplier<MyClass> s = MyClass:new;
3. Stream
데이터를 다룰 때 컬렉션, 배열에 담고 원하는 결과를 출력하기 위해 for문과 Iterator를 이용해서 코드를 작성했다.
해당 방식의 문제점
코드의 가독성이 떨어진다.
재사용성도 떨어진다.
데이터 소스마다 다른 방식으로 다뤄야 한다.
List 정렬에서는 Collections.sort() 사용
array 정렬에서는 Arrays.sort()를 사용
stream의 장점
배열, 컬렉션, 파일에 저장된 데이터 모두 같은 방식으로 다루기 가능
stream loadMap
(컬렉션, list, set, map, array, 등등 data 소스들) -> Stream type으로 만들기 -> 중간 연산(0~n 번 수행) -> 최종연산(1번만 수행) -> 결과 출력
기본형으로 다루는 스트림과 IntStream, LongStream, DoubleStream이 존재
IntStream, LongStream, DoubleStream: 추가 메서드 제공
병렬 스트림: 빅 데이터, 멀티 쓰레드에서 사용
3.1 스트림 만들기
컬렉션, 배열, 임의의 수, 특정범위의 정수, 람다식, 파일과 비어있는 스트림
3.1.1 컬렉션 -> 스트림
Collection interface: stream() 정의
// 정의
Stream<E> stream();
// 사용 예시
List<Integer> list = new ArrayList();
// list를 Stream으로 변경
Stream<Integer> intStream = list.stream(); // stream은 한번만 사용 가능
intStream.forEach(System.out::println); // stream 한번 썻으니깐 intStream 재사용 불가
intStream.forEach(System.out::println); // error
stream의 중간연산이므로 현재 type이 stream인데 내부의 실제 class type을 다른 타입으로 변경을 한다.
map과 flatMap에서 stream type은 껍데기일 뿐이라 생각하고 실제 작동은 내부의 class type과 작동한다고 이해해야 한다.
예제
File[] fileArr = {new File("a.java"), new File("b.java"), new File("c.java"), new File("d"),new File("e")};
Stream<File> fileStream = Stream.of(fileArr);
// fileStream.forEach(s-> System.out.println(s.exists())); // 현재 type이 File이여서 관련 method 사용되는지 확인 용도
// map의 1번째 기능 -> 내부 타입 변환
Stream<String> stringStream = fileStream.map(File::getName);
// Stream<String> stringStream 인 이유
// File class - getName() 반환타입: String
// map: stream 내부의 class type을 변경하는 것.-> Stream 내부에서 File->String으로 변경됨.
// Stream 내부에 존재하는 것은 변화 없음
// stringStream.forEach(s-> System.out.println(s.exists())); // 에러발생, String이기 때문
stringStream.forEach(System.out::print);
fileStream = Stream.of(fileArr); // stream은 1회성이라 다시 생성
fileStream.map(File::getName)
.filter(s -> s.indexOf(".") != -1)
// map의 2번째 기능 -> 요소 내부 변환
.map(s -> s.substring(s.indexOf('.')+1))
.map(String::toUpperCase)
.forEach(System.out::print);
}
flatMap()
map에서 해결 못하는 Stream 벗겨내기 기능이 존재
map의 경우 stream 내부의 class type을 변경( == 내부에서 작동).
그래서 원래 둘러싸인 Stream은 그대로이다.
내부가 그럼 왜 Stream <String> 이 된 것인가?
Arrays::stream은 배열을 stream 타입으로 변경하는 것이기 때문에 string 타입의 배열을 stream으로 변경
배열인 경우가 대표적인 것
다른 상황은 없나?
만약 map 사용 시 stream 내부에 stream이나 지저분하게 상자 내부에 상자 형식으로 되면 flatmap 사용
flatMap은 stream을 아예 벗기고 내부가 각각의 상자로 분리되어 있어도 각각의 type을 변경한 후 마지막으로 하나의 상자에 담기 때문
orElse("null일 때 나오는 값") // get과 동일하지만 null 다룰 수 있다.
orElseGet(Supplier <? extends T> other) // null 대체 값을 람다식으로 지정 가능
orElseThrow(Supplier <? extends X> exceptionSupplier) // null일 때 지정된 예외 발생
isPresent() // 지정된 객체 null이면 false, 아니면 true 반환
ifPresent() // null 아닐 때만 작동
OptionalInt, Long, Double
기본형 Stream의 최종 연산은 기본형 Optional을 반환한다.
값을 반환하는 메서드(get())를 제외하고 나머지 메서드는 동일
기본형 Optional에 제공되는 method 존재
// 값을 반환하는 메서드
OptionalInt int getAsInt();
OptionalLong long getAsLong();
OptionalDouble double getAsDouble();
// 추가 메서드 - OptionalInt 타입으로 반환하는 최종 연산 method
findAny()
findFirst()
reduce(IntBinaryOperator op)
max()
min()
average()
// 사용 예
OptionalInt opt = OptionalInt.of(0);
OptionalInt opt = OptionalInt.ofNullable(0);
OptionalInt opt = OptionalInt.empty();
6. 스트림 최종 연산
6.1. 스트림 최종 연산 메서드
void forEach(Consumer<? super T> action) // 각 요소에 지정된 작업 수행
void forEachOrdered(Consumer<? super T> action) // 병렬스트림 작업시 순서유지
long count() // 스트림의 요소의 개수 반환
Optional<T> max(Comparator<? super T> comparator) // 스트림 최대값 반환
Optional<T> min(Comparator<? super T> comparator) // 스트림 최소값 반환
Optional<T> findAny() // 아무거나 하나 반환
Optional<T> findFirst() // 첫 번째 요소 반환
boolean allMatch(Predicate<T> p) // 모두 만족하면 true
boolean anyMatch(Predicate<T> p) // 하나라도 만족하면 true
boolean noneMatch(Predicate<T> p) // 모두 만족하지 않으면 true
Object[] toArray() // 객체에 담아서 배열로 반환
A[] toArray(IntFunction<A[]> generator) // 스트림 모든 요소를 배열로 반환
// 핵심 reduce, collect
// reduce : 스트림의 요소를 하나씩 줄여가면서 계산
Optional<T> reduce(BinaryOperator<T> accumulator)
T reduce(T identity, BinaryOperator<T> accumulator)
U reduce(U identity, BiFunction<U,T,U> accumulator, BinaryOperator<T> combiner) // combiner는 병렬처리된 결과 합하기 위한 조건
// collect : 스트림의 요소를 수집 -> 스트림으로 낸 결과를 따로 컬렉션에 저장
R collect(Collector<T, A, R> collector)
R collect(Supplier<R> supplier, BiConsumer<R, T> accumulator, BiConsumer<R, R> combiner)
reduce()
identity: stream 요소의 몇 번째부터 연산을 시작할지 선택
identity 없는 경우: 첫 번째 요소부터 연산
연산할 요소들이 없으면 초기값이 반환 -> Optional이 반환되지 않고 해당 type이 반환된다.
combiner: 병렬처리된 stream의 연산 결과를 합하는 것
collect()
그룹별 리듀싱 <-> reduce(): 전체 리듀싱
스트림의 요소를 수집하는 최종연산으로 스트림을 어떻게 수집할 것인가에 대한 방법 정의
스트림 수집 방법 = Collector 이용 : collect에 필요한 method 정의한 인터페이스
Collector <T, A, R>
T 요소를 A에 누적한 다음, 결과를 R type으로 변환 후 반환한다.
항상 3가지를 다 사용할 필요 없다.
method 마다 받는 지네릭스 type이 정해져 있다.
그래서 타입만 반환하는 경우, 연산 후 그대로 반환하는 경우, 연산 후 타입 변경해서 반환하는 경우 다양하게 존재한다.