#4. 자바 함수형 인터페이스

# 함수형 인터페이스

함수형 인터페이스 (Functional Interface)

• 추상 메소드를 딱 하나만 가지고 있는 인터페이스
• SAM (Single Abstract Method) 인터페이스
• @FuncationInterface 애노테이션을 가지고 있는 인터페이스

함수형 인터페이스(Functional Interface) 는 기본 자바에도 사용했던 개념인데, 추상 메서드를 딱 하나만 가지고 있는 인터페이스를 의미한다. (다른 메서드의 개수는 상관없다.) 이를 SAM (Single Abstract Method) 인터페이스 이라고 부르기도 한다.

public interface Hello {
    void doSomething();
    // void doSomething2(); 추상화 메서드가 2개 이상이면 함수형이 아니다.
    
    static void printName(){
        System.out.println("다른 메서드의 수는 상관없다.");
    }
}

 

이렇게 만든 인터페이스는 기존의 자바에서 다음과 같은 익명함수를 작성 할 수 있었다.

public class Main {
    public static void main(String[] args) { 
    // 기존의 익명 내부 클래스
        Hello hello = new Hello(){
            @Override
            public void doSomething(){
                System.out.println("Hello");
            }
        };
    }
}

 

---

# 람다 표현식(Lambda Expressions)

이를 다른 함수형 언어(python, Js)처럼 화살표 표현식의 인라인 코드로 바꾼 것이 자바의 람다 표현식 (Lambda Expressions) 이다. 함수형 프로그래밍을 공부해봤다면, 익숙한 모양의 코드일 것이다.

• 함수형 인터페이스의 인스턴스를 만드는 방법으로 쓰일 수 있다.
• 코드를 줄일 수 있다.
• 메소드 매개변수, 리턴 타입, 변수로 만들어 사용할 수도 있다.

public class Main {
    public static void main(String[] args) {
    // 람다 표현식. 단 함수형 인터페이스에만 사용 가능하다.
        Hello hello = () -> System.out.println("Hello");
        hello.doSomething(); // hello 자체는 객체이지 함수가 아님을 유의하자. 
    }
}

---

# 메서드 레퍼런스, 생성자 레퍼런스

함수형 프로그래밍에서는 함수 자체를 파라메타로 줄 수 있다. 자바는 모든 것이 클래스로 이루어져 있기에 함수를 바로 전달 할 수는 없고, 메서드 레퍼런스(::method)를 비슷하게 구현 할 수있다.

// 이 두 코드는 같은 동작을 한다.
// setFunction(System.out::println);
// setFunction(msg -> System.out.println(msg));

import java.util.function.UnaryOperator;

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting();
        UnaryOperator<String> toStr = greeting::toString;; // Greeting.toString() 함수
    }
}

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        String[] names = {"hello","bye","see you"};
        // 이미 존재하는 함수 사용
        Arrays.sort(names, String::compareToIgnoreCase);
        // 직접 람다함수로 정의
        Arrays.sort(names, (n1,n2)-> n1.toString().compareTo(n2.toString()));
        
        
        // 익명 클래스로 같은 내용을 구현한 코드, Java8 이전의 방식
        Arrays.sort(names, new Comparator<String>() {
            @Override
            public int compare(String n1, String n2) {
                return n1.toString().compareTo(n2.toString());
            }
        });
    }
}

 

같은 문법으로 메서드 이름 대신 ::new 를 이용하면 아예 해당 클래스의 새로운 객체를 생성하는 함수를 만들 수 있다.

Function<String, Greeting> createGreeting = Greeting::new; // 생성자 함수 정의
Greeting myGreeting = createGreeting.apply("myClassName"); // 실행(객체 생성)

// label 배열의 각각의 요소에 접근(map)하여 stream을 생성하고, 이를 이용해 Button 객체 배열을 만든다. 
// 스트림(Stream)은 나중에 자세하게 설명할 예정이니, 일단 넘어가자
Stream<Button> stream = labels.stream().map(Button::new);
List<Button> buttons = stream.collect(Collectors.toList());

// ::new 를 이용하여 button 배열을 초기화 하는 방법
Button[] buttons = stream.toArray(Button[]::new)

 

 

---

# 자바에서의 함수형 프로그래밍

즉 함수형 인터페이스와 람다는 자바에서 함수형 프로그래밍을 지원하는 기능인데, 요약하면 다음과 같다.

• 함수를 First class object로 사용할 수 있다.
• 순수 함수 (Pure function) : SideEffect가 없다. 같은 입력에는 같은 출력을 보장한다.
• 고차 함수 (Higher-Order Function) : 함수를 입력, 반환 값으로 사용 할 수 있다.
• 값이 불변성을 가진다.

물론 순수함수 원칙을 깨고 JS 클로저 처럼 클래스 내의 변수나 외부의 값을 가져와 사용할 수도 있다. 함수형 프로그래밍에서 추천하는 방법이 아니지만, 사용한다고해서 무조건 나쁜 코드인 건 아니다.

public class Main {
    public static void main(String[] args) {
        int baseNumber = 10;
        Hello hello = () -> System.out.println(baseNumber + 5);
    }
}

 

참고로 이 람다표현식을 익명함수로 정의하면 아래와 같다.

public class Main {
    public static void main(String[] args) {
        int baseNumber = 10;

        // 이 코드는 위의 람다표현식과 동일한 코드이다.
        Hello hello = new Hello() {
            @Override
            public void doSomething() {
                System.out.println(baseNumber + 5);
            }
        };
    }
}

 

---

# 함수형 인터페이스 API

java.util.function 에서 레퍼런스를 볼 수 있다. 매번 함수형 인터페이스 클래스를 만들기 번거로우므로, 자주 사용하는 형태의 함수들을 쉽게 만들 수 있게 해주는 API 이다. 당연한 것이지만, 이를 람다가 아닌 익명함수로 구현하면 가독성이 매우 떨어진다.

 

단순히 표로 봤을 때는 어려워 보일 수 있는데, 아래에 있는 코드를 보면 쉽게 이해 할 수 있다. 참고로 함수형 프로그래밍 답게, API 메서드를 이용해 여러 함수를 조합해서 하나로 합칠 수도 있다.

// B실행 후 반환값 전달, 이후 A실행 즉 함수의 합성이다.
newFunc = funcA.compose(funcB)

// A실행 후 B실행. 그냥 단순히 연달아 실행하는 것 뿐이다.
newFunc = fucnA.andThen(funcB)

 

종류	특징	함수 조합용 메서드
Runnable	인자와 반환값이 모두 없음. 단지 실행만 가능
Function<T,R>	인자1개, 반환1개 R apply(T t)	andThen, Compose
BiFunction<T,U,R>	인자2개, 반환1개 R apply(T t, U u)
Consumer<T>	인자만 있음. void accept(T t)	andThen
Supplier<T>	반환값만 있음. T get()
Predicate<T>	반환값만 있음. boolean test(T t)	And, Or, Negate
UnaryOperator<T>	Function<T, T> 와 동일, 인자와 같은 제네릭 타입을 반환함
BinaryOperator<T>	BiFunction<T, T, T> 와 동일, 입력값 두개를 받아 동일한 타입을 리턴함.
Comparator<T>	BiFunction<T,T,Integer> 와 동일, 객체간의 값 비교하는데 사용됨 (compare)
기타 생략	BiCosumer<T,U> BiPredicate<T,U>, ObjIntConsumer, LongSupplier 등.

 

 

---

Function - R apply(T t)

import java.util.function.DoubleFunction;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        // 이렇게 함수를 정의하고 apply 를 이용하여 함수를 실행합니다.
        Function<String, Integer> toStr = str -> Integer.parseInt(str);
        Integer result = toStr.apply("10");

        // 입력값이 객체가 아니라면 DoubleFunction, IntFunction 등을 사용해도 됩니다.
        DoubleFunction<Integer> func = a -> (int) (a * 10);
        System.out.println(func.apply(3.2)); // 32

        // 이는 위에 코드와 같습니다.
        Function<Integer,Integer> multiply10 = a -> (int) (a * 10);

        // 이런식으로 함수를 합성해서 사용 할 수도 있습니다.
        Function<String,Integer> toStringAndMultiply10 = multiply10.compose(toStr);
        System.out.println(toStringAndMultiply10.apply("10")); // 100
    }
}

 

BiFucntion - R apply(T t, U u)

import java.util.function.BiFunction;
  
public class Main {
    public static void main(String args[])
    {
        // add 함수는 인자 2개를 받아 더해 반환하는 함수입니다.
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
  
        // Fucntion 인터페이스에 구현된 apply 메서드를 이용합니다.
        System.out.println("Sum = " + add.apply(2, 3));
  
        // multiply 함수는 두 인자를 받아 곱해 반환합니다.
        BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
  
        // 마찬가지로 apply를 이용해 해당 함수를 사용 할 수 있습니다.
        System.out.println("Product = " + multiply.apply(2, 3));
    }
}

 

 

Consumer<T> - void accept(T t) 

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.function.Consumer;
  
public class Main {
    public static void main(String args[])
    {
        // display 함수는 숫자를 출력하는 함수입니다.
        Consumer<Integer> display = a -> System.out.println(a);
  
        // Consumer 인터페이스에 내장된 accept을 사용합니다.
        display.accept(10);
  
        // modify 함수는 Int 리스트 내의 모든 요소를 2배로 곱합니다.
        Consumer<List<Integer> > modify = list ->
        {
            for (int i = 0; i < list.size(); i++)
                list.set(i, 2 * list.get(i));
        };
  
        // dispList 함수는 리스트 안에 있는 숫자들을 출력합니다.
        Consumer<List<Integer> >
            dispList = list -> list.stream().forEach(a -> System.out.print(a + " "));
  
        List<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(1);
        list.add(3);
  
        // 이런식으로 사용 할 수 있습니다.
        modify.accept(list);
        dispList.accept(list);
    }
}

Supplier<T> - T get()

import java.util.function.Supplier;
  
public class Main {
    public static void main(String args[])
    {
  
        // randomValue 함수는 랜덤한 값을 반환하는 함수이다. 입력은 없다.
        Supplier<Double> randomValue = () -> Math.random();
  
        // Supplier 인터페이스의 get을 이용해 값을 얻어온다.
        System.out.println(randomValue.get());
    }
}

 

Predicate<T> - boolean test(T t)

boolean 값을 기본으로 사용하는 만큼, .and(~) .or(~) .negate(~) 같은 메서드가 존재한다.

import java.util.function.Predicate;

public class PredicateInterfaceExample1 {
    public static void main(String[] args)
    {
        // lesserthan 함수는 i가 18보다 작은지 검사하는 함수이다.
        Predicate<Integer> lesserthan = i -> (i < 18); 
  
        // Predicate 인터페이스의 test 메서드를 이용하여 사용한다.
        System.out.println(lesserthan.test(10)); // true
    }
}

 

UnaryOperator<T>

- Function<T, R> 응용, 단일값을 사용하는 연산자 함수를 구현할 때 사용한다.

import java.util.function.Function;
import java.util.function.UnaryOperator;
  
public class GFG {
    public static void main(String args[])
    {
        UnaryOperator<Integer> xor = a -> a ^ 1;
        UnaryOperator<Integer> and = a -> a & 1;
        
        // compose를 이용하여 2개의 연산을 하나로 합친다.
        Function<Integer, Integer> compose = xor.compose(and);
        System.out.println(compose.apply(231));
    }
}

 

BinaryOperator<T>

- BiFunction<T, U, R> 응용. compare, max 같은 기능을 하는 함수를 구현할 때 사용한다.

import java.util.function.BinaryOperator;
  
public class GFG {
    public static void main(String args[])
    {
    	// 이런식으로 사용된다는거 정도만 알고있자.
        BinaryOperator<Integer>
            op = BinaryOperator
                     .maxBy(
                         (a, b) -> (a > b) ? 1 : ((a == b) ? 0 : -1));
  
        System.out.println(op.apply(98, 11));
    }
}

---

# effective final , 자바의 변수 캡처 (Variable Capture)

다음과 같이 Local 클래스, 익명클래스, 람다가 있다고 가정해보자.

import java.util.function.Consumer;
import java.util.function.IntConsumer;

public class Main {
    public static void main(String[] args) {
        int baseNumber = 10;
    
        // 내부 (Local) 클래스
        class LocalClass {
            void print(int i) {
                System.out.println(i + baseNumber);
            }
        }

        // 익명 클래스
        Consumer<Integer> print = new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer + baseNumber);
            }
        };

        // 람다 표현식
        IntConsumer printInt = i -> System.out.println(i + baseNumber);
        printInt.accept(10);
    }
}

각각의 함수들은 클래스 안의 변수인 baseNumber를 참조하고 있다.

내부 클래스나 익명 클래스의 경우, 스코프{~} 가 달라 내부에서 사용하고있는 baseNumber라는 변수가 사용되었는지 알기 어렵다. 이를 파라메타가 Shadowing 되었다고 표현한다.

 

내부클래스에서 외부의 지역변수를 사용하게되면

 

baseNumber 가 final 키워드로 상수화 되지 않았더라도 람다 표현식은 함수형 인터페이스를 사용, 즉 순수함수를 보장하기에 컴파일시 자동으로 baseNumber는 상수화 된다. 이를 변수 캡쳐(Variable Capture)라고 말하고 baseNumber는 effective final 인 변수라고 부른다.

 

변수 캡쳐는 말 그대로 지역변수를 복사해서 다른 쓰레드로 가져온다고 이해하면 된다. 지역변수는 JVM에서 쓰레드마다 별도의 스택영역에 저장되므로, 다른 스코프 (=다른 쓰레드)간의 공유가 어렵다. 다른 쓰레드 영역에서 지역 변수를 가져와 사용하기 위해서는 애초에 전역으로 선언하거나 지역 변수 자체를 복사해서 쓰레드로 가져오는 방법이 있다. 다만 값을 복사해왔을 경우 각각의 다른 쓰레드에서 같은 변수의 값이 같을거라고 보장할 수 없다.

 

람다를 사용하는 함수형 프로그래밍은 기본적으로 독립적인 쓰레드를 사용할 수 있게 설계되어 있기에 위의 예제와 같이 지역변수를 사용할 때에는 해당 쓰레드의 메모리를 참조하는 것이 아니라 변수를 복사 (=캡쳐)하여 람다의 쓰레드로 가져온다. 이 때 복사한 값이 달라지면 Side-effect가 생길 수 있으므로 final 키워드를 통해 상수화 시키는 것이다.

Java 1.8이후 명시적으로 final을 선언하지 않더라도 람다에서 사용하는 지역변수는 자동으로 상수화 (effective final)된다.

 

실제로 람다 표현식에서 사용하는 baseNumber의 값을 변경하게되면 상수의 값을 변경했다고 컴파일 오류가 뜨게 된다.

// baseNumber++; 같은 코드로 값을 변경하면 오류가 뜨게 된다. 상수를 변경했기 때문.

C:\javaTest\src\com\company\Main.java:13:40
java: local variables referenced from an inner class must be final or effectively final