람다식은 익명 객체이고 익명 객체는 타입이 없다. 대입 연산자의 양변의 타입을 일치시키기 위하여 형변환이 필요하다
() -> {} 람다식은 MyFunction 인터페이스를 직접 구현하지는 않았지만, 인터페이스를 구현한 클래스 객체와 동일하기에 아래와 같은 형변환을 허용한다.
@FunctionalInterface
public interface MyFunction {
void run();
}
public class MyFunctionTest {
public static void main(String[] args) {
MyFunction f = () -> {}; // 형변환 생략 가능 - 정상
MyFunction f1 = (MyFunction) (() -> {}); // 정상
Object obj = (Object) (() -> {}); // 에러
Object obj1 = (Object)(MyFunction) (() -> {}); // 정상
String str = ((Object)(MyFunction) (() -> {})).toString(); // 정상
}
}
오직 함수형 인터페이스로만 형변환이 가능하다.
Object 타입으로는 형변환 할 수 없다. 굳이 Object 타입으로 형변환 하려면, 먼저 함수형 인터페이스로 변환해야 한다.
Variable Capture
Lambda Capturing (람다 캡쳐링)
람다식에서 외부 지역변수를 참조하는 행위
람다에서 접근 가능한 변수는 세가지 종류가 있다. 1. 지역 변수 2. static 변수 3. 인스턴스 변수
지역변수는 변경이 불가능하며, 나머지 변수들은 읽고 쓰기가 가능하다.
람다는 지역변수가 존재하는 스택에 직접 접근하지 않고, 지역 변수를 자신(람다가 동작하는 쓰레드)의 스택에 복사한다. 각 쓰레드마다 고유한 스택을 가지고 있어서 지역 변수가 존재하는 쓰레드가 사라져도 람다는 복사된 값을 참조하여 에러가 발생하지 않는다.
멀티 쓰레드 환경이라면, 여러 개의 쓰레드에서 람다식을 사용하며 람다 캡쳐링이 발생하게 된다.
이 때 외부변수 값의 불변성을 보장하지 못하여 동기화 문제가 발생한다.
이러한 문제로 지역변수는 final, Effectively Final 제약조건을 갖게 된다.
인스턴스 / static 변수는 힙 영역에 위치하고, 힙 영역은 모든 쓰레드가 공유하는 메모리 영역이므로 동기화 문제가 일어나지 않는다.
@FunctionalInterface
public interface MyFunction {
void run();
}
class Outer {
int val = 10;
static int staticVal = 0;
class Inner {
void method(int i) {
int innerval = 30;
MyFunction f = () -> {
System.out.println(i);
System.out.println(val);
System.out.println(innerval);
System.out.println(staticVal);
System.out.println(this.getClass());
val = 456;
innerval = 123; // 에러, 지역변수는 final 제약조건을 갖는다. Variable used in lambda expression should be final or effectively final
staticVal = 789;
};
f.run();
}
}
}
public class CaptureEx {
public static void main(String[] args) {
Outer.Inner testClass = new Outer().new Inner();
testClass.method(100);
}
}
// 100
// 10
// 30
// 0
// class lambdaex.Outer$Inner
람다식 내에서 참조하는 지역변수는 final을 붙이지 않아도 상수로 간주된다.
람다식에서 this는 내부적으로 생성되는 익명 객체의 참조가 아닌 람다식을 실행한 객체의 참조이므로, this는 중첩 객체인 inner 이다.
java.util.function 패키지
java.util.function 패키지에 일반적으로 자주 쓰이는 형식의 메소드를 함수형 인터페이스로 미리 정의해 놓았다.
가능하면 이 패키지의 함수형 인터페이스를 사용하자.
기본적인 함수형 인터페이스
Function의 변형으로 Predicate가 있는데, 반환값이 boolean이 것만 제외하면 Function과 동일하다.
매개변수가 두 개인 함수형 인터페이스
UnaryOperator, BinaryOperator
public class FuncInterfaceTest {
public static void main(String[] args) {
Supplier<Integer> s = () -> (int) (Math.random() * 100) + 1;
Consumer<Integer> c = i -> System.out.print(i + ",");
Predicate<Integer> p = i -> i % 2 == 0;
Function<Integer, Integer> f = i -> i / 10 * 10;
List<Integer> list = new ArrayList<>();
makeRandomList(s,list);
System.out.println(list);
printEvenNum(p,c,list);
List<Integer> newList = doSomeTing(f,list);
System.out.println(newList);
}
static <T> List<T> doSomeTing(Function<T,T> f, List<T> list){
List<T> newList = new ArrayList<>(list.size());
for (T t : list) {
newList.add(f.apply(t));
}
return newList;
}
static <T> void printEvenNum(Predicate<T> p, Consumer<T> c, List<T> list) {
System.out.print("[");
for (T t : list) {
if (p.test(t)) {
c.accept(t);
}
System.out.println("]");
}
}
static <T> void makeRandomList(Supplier<T> s, List<T> list) {
for (int i=0; i < 10; i++){
list.add(s.get());
}
}
}
// [48, 4, 25, 17, 42, 46, 85, 55, 47, 11]
// [48,4,42,46,]
// [40, 0, 20, 10, 40, 40, 80, 50, 40, 10]
기본형을 사용하는 함수형 인터페이스
public class FuncInterfaceTest1 {
public static void main(String[] args) {
IntSupplier s = () -> (int) (Math.random() * 100) + 1;
IntConsumer c = i -> System.out.print(i + ",");
IntPredicate p = i -> i % 2 == 0;
IntUnaryOperator op = i -> i / 10 * 10;
int[] arr = new int[10];
makeRandomList(s,arr);
System.out.println(Arrays.toString(arr));
printEvenNum(p,c,arr);
int[] newArr = doSomeTing(op,arr);
System.out.println(Arrays.toString(newArr));
}
static int[] doSomeTing(IntUnaryOperator f, int[] arr){
int[] newArr = new int[arr.length];
for (int i=0;i<newArr.length;i++) {
newArr[i] = f.applyAsInt(arr[i]);
}
return newArr;
}
static void printEvenNum(IntPredicate p, IntConsumer c, int[] arr) {
System.out.print("[");
for (int t : arr) {
if (p.test(t)) {
c.accept(t);
}
}
System.out.println("]");
}
static void makeRandomList(IntSupplier s, int[] arr) {
for (int i=0; i < arr.length; i++){
arr[i] = s.getAsInt();
}
}
}
// [99, 27, 12, 21, 71, 84, 45, 11, 95, 18]
// [12,84,18,]
// [90, 20, 10, 20, 70, 80, 40, 10, 90, 10]
Function 함수형 인터페이스의 default, static 메서드
Default - andThen()
f.andThen(g)
함수 f를 먼저 적용하고 그 다음에 함수 g를 적용
Default -compose()
f.compose(g)
andThen()과 반대 함수 g를 먼저 적용하고 그 다음 f를 적용
Static - identity()
이전과 이후가 동일한 '항등함수'가 필요할 때 사용
x -> x, Function.identity() 두 개가 동일
항등 함수는 잘 사용되지 않는 편이며, map()으로 변환작업할 때, 변환없이 그대로 처리하고자 할 때 사용
Predicate 함수형 인터페이스의 default, static 메서드
여러 조건식들을 논리 연산자인 &&(and), ||(or), !(not) 으로 연결해서 하나의 식을 구성할 수 있는 것처럼, 여러 Predicate를 and(), or(), negate()로 연결해서 하나의 새로운 Predicate로 결합할 수 있다.
static 메소드인 isEqual()은 두 대상을 비교하는 Predicate를 만들 때 사용한다.
public class PredicateExample {
public static void main(String[] args) {
Function<String, Integer> f = s -> Integer.parseInt(s, 16);
Function<Integer, String> g = i -> Integer.toBinaryString(i);
Function<String, String> h = f.andThen(g);
Function<Integer, Integer> h2 = f.compose(g);
System.out.println(h.apply("EE"));
System.out.println(h2.apply(2));
Function<String, String> f2 = x -> x;
System.out.println(f2.apply("AAA"));
Predicate<Integer> p = i -> i<100;
Predicate<Integer> q = i -> i<200;
Predicate<Integer> r = i -> i%2==0;
Predicate<Integer> notP = p.negate();
Predicate<Integer> all = notP.and(q.or(r));
System.out.println(all.test(150));
String str1 = "ABC";
String str2 = "abc";
Predicate<String> p2 = Predicate.isEqual(str1);
boolean test = p2.test(str2);
System.out.println(test);
}
}
// 11101110
// 16
// AAA
// true
// false
메소드, 생성자 레퍼런스
메소드 참조 (method reference)
메소드를 참조하는 방법 1. 클래스이름::메소드이름 2. 참조변수::메소드이름
Function<String, Integer> f = s -> Integer.parseInt(s);
// 메소드 참조
Function<String, Integer> f = Integer::parseInt;
BiFunction<String, String, Boolean> f = (s1, s2) -> s1.equlas(s2);
BiFunction<String, String, Boolean> f = String::equals;
종류
람다
메소드 참조
static 메소드 참조
x -> ClassName.method(x)
ClassName::method
인스턴스 메소드 참조
(obj, x) -> obj.method(x)
ClassName::method
특정 객체 인스턴스 메소드 참조
x -> obj.method(x)
obj:method
생성자의 메소드 참조
Supplier<MyClass> s = () -> new MyClass(); // 람다식
Supplier<MyClass> s = MyClass:new; // 메소드 참조
// 매개변수가 있는 경우
Function<Integer, MyClass> f = i -> new MyClasS(i); // 람다식
Function<Integer, MyClass> f = MyClass:new; // 메소드 참조
BiFunction<Integer, String, MyClass> bf = (i, s) -> new MyClass(i, s); // 람다식
BiFunction<Integer, String, MyClass> bf = MyClass::new; // 메소드 참조
// 배열을 생성하는 방법
Function<Integer, int[]> f = x -> new int[x]; // 람다
Function<Integer, int[]> f2 = int[]::new; // 메소드 참조
class Myclass{
int iv;
public Myclass() {
}
public Myclass(int iv) {
this.iv = iv;
}
}
public class ReferenceExample {
public static void main(String[] args) {
Function<String, Integer> f = s -> Integer.parseInt(s);
Function<String, Integer> f1 = Integer::parseInt;
System.out.println(f1.apply("100") + 100);
Supplier<Myclass> s = () -> new Myclass();
Supplier<Myclass> s1 = Myclass::new;
System.out.println(s1.get());
Function<Integer, Myclass> f2 = Myclass::new;
Myclass m = f2.apply(100);
System.out.println(m.iv);
System.out.println(f2.apply(200).iv);
Function<Integer, int[]> f3 = int[]::new;
System.out.println(f3.apply(10).length);
};
}
// 200
// lambdaex.Myclass@5e9f23b4
// 100
// 200
// 10
