함수형 프로그래밍 & 람다

😶‍🌫️함수형 프로그래밍

Java는 객체지향 언어이기 때문에 기본적으로 함수형 프로그래밍이 불가능하다. 하지만 JDK8부터 Stream API와 람다식, 함수형 인터페이스 등을 지원하면서 Java를 이용해 함수형으로 프로그래밍할 수 있는 API 들을 제공해주고 있다.

First Class Citizon

First Class Citizon 은 아래의 속성들을 모주 만족해야 합니다.

• 변수에 값을 할당할 수 있어야 합니다.

• 함수의 파라미터로 넘겨줄 수 있어야 합니다.

• 함수의 반환값이 될 수 있어야 합니다.

https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html

Function (Java Platform SE 8 )

docs.oracle.com

@FunctionalInterface

함수형 인터페이스

추상 메소드가 딱 하나만 존재하는 인터페이스 이다.

💡 public abstract가 단 하나만 있으면 가능하며 다른 형태로 정의가 되어져 있는 것은 상관이 없다.

@FunctionalInterface
public interface PracticeLambda {
    void practice(); //public abstract 생략

    static void practice2() {
        System.out.println("연습1");
    }

    default void practice3() {
        System.out.println("연습2");
    }
}

만약에 추상 메소드가 2개 이상이면 @functionalInterface에서 컴파일 오류가 나온다.

자바에서 제공하는 함수형 인터페이스

Function<T,R> , UnaryOperator<T>
- 두개의 인자를 받아서 하나의 결과를 Return한다.
- 여기서 두개의 인자의 타입은 T,R 서로 다르거나 같아도 상관이 없다.
- 만약에 두개의 인자가 같은 타입이면 UnaryOperator<T>를 사용

🦖현재의 이 코드는 Function 인터페이스를 익명객체 스타일로 구현을 했다.

public class PracticeLamdba {
    public static void main(String[] args) {
        Function<Integer, Integer> pricaticeTest = new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer+10;
            }
        };
        
        System.out.println(pricaticeTest.apply(3));
    }
}

값을 받아와서 apply를 오버라이드 해서 +10을 해주는 함수를 만들었다.

🦖이러한 익명의 느낌을 람다로 표현이 가능하다.

public class PracticeLamdba {
    public static void main(String[] args) {
        Function<Integer, Integer> pricaticeTest = integer -> integer+10;
        System.out.println(pricaticeTest.apply(3));
    }
}

코드가 엄청 간결하고 가독성이 높아졌다.

Function<T,R> → apply()

→T는 입력하는 타입을 의미하며 R은 return 되는 값의 타입을 의미한다.

여기서 만약에 Funciotn 함수가 여러개 있을 때 Function의 다양한 기능을

사용할 수 있다.

compose

간단하게 코드를 보여주고 설명을 하겠다.

public class PracticeLamdba {
    public static void main(String[] args) {
        Function<Integer, Integer> plus = (number) -> number+10;
        
        Function<Integer , Integer> multiple = number2 ->number2*2;
        
        int result=plus.compose(multiple).apply(10);
				System.out.println(result);
        
    }
}

더하기 기능과 곱하기 기능을 만들었고 copose를 사용을 했다.

이때 result의 값은 어떻게 나올까? —> 결과는 30이 나오게 된다.

Compose란

()의 기능을 먼저 연산을 하고 그 뒤에 첫번 째로 오는 기능을 연산을 한다.

multiple → 결과 → 결과 & plus 라고 생각을 하면 좋다.

andThen란

public class PracticeLamdba {
    public static void main(String[] args) {
        Function<Integer, Integer> plus = (number) -> number+10;
        Function<Integer , Integer> multiple = number2 ->number2*2;
        int result=plus.andThen(multiple).apply(10);
        System.out.println(result);
    }
}

andThen은 compose와 반대로 먼저오는 기능을 연산하고 그 뒤에 () 기능을 연산을 하는 것을 의미한다.

즉. plus → 결과 → multiple을 하며 결과는 40이 나오게 된다.

BiFuntion<T,U,R>
- BiFunction은 입력값이 2개를 받고 두개의 연산에 대한 결과값 R로
- 반환하는 기능을 가진다.
- 기본적인 기능은 Function<T,R>과 비슷하며 입력값이 2개라는 차이만 있다.

익명

public class PracticeLamdba {
    public static void main(String[] args) {
        BiFunction<Integer,Integer,Integer>biFunction = new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer+integer2;
            }
        };
        int result=biFunction.apply(10 , 20);
        System.out.println(result);
    }
}

람다

public class PracticeLamdba {
    public static void main(String[] args) {
        BiFunction<Integer,Integer,Integer>biFunction = (integer, integer2) -> integer+integer2;
        int result=biFunction.apply(10 , 20);
        System.out.println(result);
    }
}

Function<T,R> & BiFunction<T,U,R> 같은 타입

<aside> 💡 만약에 T ,U ,R이 다 똑같은 Integer 타입이면 다 적어야 되는가?

</aside>

만약에 타입이 같으면 Function은 UnaryOperator<T>를 사용하면 된다.

그러면 입력 , 출력값의 타입이 모두 T로 정해진다.

BiFunction<T,U,R>은 입력 출력 모두 같으면 BinaryOperator<T>를 사용

public class PracticeLamdba {
    public static void main(String[] args) {
        UnaryOperator<Integer>unaryOperator = (n) -> n+10;
        System.out.println(unaryOperator.apply(10));

        BinaryOperator<Integer>binaryOperator=(a,b)->a+10+b;
        System.out.println(binaryOperator.apply(10,20));
    }
}

Consumer<T> - apply()

T타입을 입력 받아서 아무값도 리턴하지 않는 함수 인터페이스를 의미

익명

public class PracticeLamdba {
    public static void main(String[] args) {
        Consumer<String>consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("내 이름은 "+s +"입니다.");
            }
        };
        consumer.accept("김무건");
    }
}

람다

public class PracticeLamdba {
    public static void main(String[] args) {
        Consumer<String>consumer = (name) -> System.out.println("내 이름은"+name+"입니다.");
        consumer.accept("김무건");
    }
}

Suppiler<T>
- T 타입의 값을 제공하는 함수 인터페이스
  - 인자가 필요 없다.
  - 내가 어떤 값을 받을지 결정
  - T get()

익명

public class PracticeLamdba {
    public static void main(String[] args) {
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "김무건";
            }
        };
        System.out.println("내 이름은 "+supplier.get());
    }
}

람다

public class PracticeLamdba {
    public static void main(String[] args) {
        Supplier<String> supplier = () -> "김무건";
        System.out.println("내 이름은 "+supplier.get());
    }
}

Predicate<T>
- T타입을 받아서 Boolean을 리턴하는 함수 인터페이스
- 함수 조합용 메소드
  - and
  - or
  - negate()

익명

public class PracticeLamdba {
    public static void main(String[] args) {
      Predicate<Integer>predicate = new Predicate<Integer>() {
          @Override
          public boolean test(Integer integer) {
              return integer%2==0;
          }
      };
        System.out.println(predicate.test(10));
    }
}

람다

public class PracticeLamdba {
    public static void main(String[] args) {
      Predicate<Integer>predicate = integer -> integer%2==0;
        System.out.println(predicate.test(10));
    }
}

만약에 다양한 조건이 있다고 생각하면 and or를 이용하면 된다.

예를 들어서 짝수이면서 값이 4인 결과를 받고 싶다고 조건을 만들면

짝수
값이 4

이 두개의 조건을 and연산을 하면 되는데

and

public class PracticeLamdba {
    public static void main(String[] args) {
      Predicate<Integer>integerPredicate = integer -> integer%2==0;
      Predicate<Integer>predicate = num ->num==4;
      
      if(integerPredicate.and(predicate).test(4)){
          System.out.println("참");
      }else System.out.println("거짓");
      
    }
}

or

public class PracticeLamdba {
    public static void main(String[] args) {
      Predicate<Integer>integerPredicate = integer -> integer%2==0;
      Predicate<Integer>predicate = num ->num==4;
      
      if(integerPredicate.or(predicate).test(4)){
          System.out.println("참");
      }else System.out.println("거짓");
      
    }
}

negate()

public class PracticeLamdba {
    public static void main(String[] args) {
      Predicate<Integer>integerPredicate = integer -> integer%2==0;
      Predicate<Integer>predicate = num ->num==4;
        System.out.println(predicate.negate().test(4));
    }
}

'🌾BackEnd > 🐛 Java' 카테고리의 다른 글

람다식 로컬 변수 - Effectively Final (0)	2023.01.28

mugeon.log

함수형 프로그래밍 & 람다