Java의 기능적 인터페이스

안녕하세요! Java Syntax Pro 퀘스트에서 우리는 람다 표현식을 연구했으며 이는 함수형 인터페이스에서 함수형 메서드를 구현한 것에 지나지 않는다고 말했습니다. 즉, 이는 실현되지 않은 메서드인 일부 익명(알 수 없음) 클래스의 구현입니다. 그리고 과정의 강의에서 람다 표현식을 사용한 조작을 탐구했다면 이제는 다른 측면, 즉 바로 이러한 인터페이스를 고려할 것입니다. Java의 8번째 버전에서는 기능적 인터페이스 개념이 도입되었습니다 . 이게 뭔가요? 구현되지 않은(추상) 메소드가 하나 있는 인터페이스는 기능적인 것으로 간주됩니다. 앞서 논의한 인터페이스와 같은 많은 기본 인터페이스가 이 정의에 속합니다 . 또한 다음과 같이 우리가 직접 만드는 인터페이스도 있습니다. Comparator

@FunctionalInterface
public interface Converter<T, N> {
   N convert(T t);
}

한 유형의 개체를 다른 유형의 개체(일종의 어댑터)로 변환하는 작업을 수행하는 인터페이스가 있습니다. 주석은 @FunctionalInterface매우 복잡하거나 중요한 것이 아닙니다. 주석의 목적은 이 인터페이스가 기능적이며 하나의 메서드만 포함해야 함을 컴파일러에 알리는 것이기 때문입니다. 이 주석이 있는 인터페이스에 구현되지 않은(추상) 메서드가 두 개 이상 있는 경우 컴파일러는 이 인터페이스를 잘못된 코드로 인식하므로 이 인터페이스를 건너뛰지 않습니다. 이 주석이 없는 인터페이스는 기능적이며 작동하는 것으로 간주될 수 있지만 @FunctionalInterface이는 추가 보험에 지나지 않습니다. 수업으로 돌아가자 Comparator. 해당 코드(또는 문서 ) 를 보면 두 가지 이상의 메서드가 있음을 알 수 있습니다. 그렇다면 당신은 묻습니다. 그렇다면 어떻게 기능적 인터페이스로 간주될 수 있습니까? 추상 인터페이스에는 단일 메서드의 범위 내에 있지 않은 메서드가 있을 수 있습니다.

• 공전

인터페이스의 개념은 주어진 코드 단위가 어떤 메소드도 구현할 수 없음을 의미합니다. 하지만 Java 8부터는 인터페이스에서 정적 메소드와 기본 메소드를 사용할 수 있게 되었습니다. 정적 메서드는 클래스에 직접 바인딩되며 이러한 메서드를 호출하기 위해 해당 클래스의 특정 개체가 필요하지 않습니다. 즉, 이러한 방법은 인터페이스 개념에 조화롭게 들어맞습니다. 예를 들어, 이전 클래스에 객체의 null을 확인하는 정적 메서드를 추가해 보겠습니다.

@FunctionalInterface
public interface Converter<T, N> {

   N convert(T t);

   static <T> boolean isNotNull(T t){
       return t != null;
   }
}

이 메소드를 수신한 후 컴파일러는 불평하지 않았습니다. 이는 인터페이스가 여전히 작동한다는 것을 의미합니다.

• 기본 방법

Java 8 이전에는 다른 클래스에서 상속된 인터페이스에서 메서드를 생성해야 하는 경우 각 특정 클래스에서 구현된 추상 메서드만 생성할 수 있었습니다. 하지만 이 방법이 모든 클래스에 동일하다면 어떨까요? 이 경우에는 추상 클래스가 가장 자주 사용되었습니다 . 그러나 Java 8부터는 구현된 메소드(기본 메소드)와 함께 인터페이스를 사용하는 옵션이 있습니다. 인터페이스를 상속할 때 이러한 메서드를 재정의하거나 모든 것을 그대로 둘 수 있습니다(기본 로직을 그대로 유지). 기본 메소드를 생성할 때 - 키워드를 추가해야 합니다 default.

@FunctionalInterface
public interface Converter<T, N> {

   N convert(T t);

   static <T> boolean isNotNull(T t){
       return t != null;
   }

   default void writeToConsole(T t) {
       System.out.println("Текущий an object - " + t.toString());
   }
}

다시 말하지만, 우리는 컴파일러가 불평을 시작하지 않았으며 기능적 인터페이스의 한계를 넘어서지 않았음을 알 수 있습니다.

• 객체 클래스 메소드

객체 비교 강의에서 우리는 모든 클래스가 클래스로부터 상속을 받는다는 사실에 대해 이야기했습니다 Object. 이는 인터페이스에는 적용되지 않습니다. 그러나 인터페이스에 클래스의 일부 메서드와 서명이 일치하는 추상 메서드가 있는 경우 Object이러한 메서드(또는 메서드)는 기능적 인터페이스 제한을 깨지 않습니다.

@FunctionalInterface
public interface Converter<T, N> {

   N convert(T t);

   static <T> boolean isNotNull(T t){
       return t != null;
   }

   default void writeToConsole(T t) {
       System.out.println("Текущий an object - " + t.toString());
   }

   boolean equals(Object obj);
}

그리고 다시 말하지만, 우리 컴파일러는 불평하지 않으므로 인터페이스는 Converter여전히 기능적인 것으로 간주됩니다. 이제 질문은: 왜 우리는 기능적 인터페이스에서 구현되지 않은 하나의 메서드로 제한해야 합니까? 그런 다음 람다를 사용하여 구현할 수 있습니다. 예를 들어 이를 살펴보겠습니다 Converter. 이를 위해 클래스를 생성해 보겠습니다 Dog.

public class Dog {
  String name;
  int age;
  int weight;

  public Dog(final String name, final int age, final int weight) {
     this.name = name;
     this.age = age;
     this.weight = weight;
  }
}

그리고 비슷한 것 Raccoon(너구리):

public class Raccoon {
  String name;
  int age;
  int weight;

  public Raccoon(final String name, final int age, final int weight) {
     this.name = name;
     this.age = age;
     this.weight = weight;
  }
}

객체가 있고 Dog해당 필드를 기반으로 객체를 생성해야 한다고 가정해 보겠습니다 Raccoon. 즉, Converter한 유형의 객체를 다른 유형으로 변환합니다. 어떻게 보일까요?

public static void main(String[] args) {
  Dog dog = new Dog("Bobbie", 5, 3);

  Converter<Dog, Raccoon> converter = x -> new Raccoon(x.name, x.age, x.weight);

  Raccoon raccoon = converter.convert(dog);

  System.out.println("Raccoon has parameters: name - " + raccoon.name + ", age - " + raccoon.age + ", weight - " + raccoon.weight);
}

이를 실행하면 콘솔에 다음과 같은 출력이 표시됩니다.

Raccoon has parameters: name - Bobbbie, age - 5, weight - 3

이는 우리의 방법이 올바르게 작동했음을 의미합니다.

기본 Java 8 기능 인터페이스

이제 Java 8이 제공하고 Stream API와 함께 적극적으로 사용되는 몇 가지 기능적 인터페이스를 살펴보겠습니다.

술부

Predicate— 특정 조건이 충족되는지 확인하기 위한 기능적 인터페이스입니다. 조건이 충족되면 를 반환하고 true, 그렇지 않으면 -를 반환합니다 false.

@FunctionalInterface
public interface Predicate<T> {
   boolean test(T t);
}

예를 들어, 다음과 같은 Predicate여러 유형의 패리티를 확인하는 를 만드는 것을 고려해 보세요 Integer.

public static void main(String[] args) {
   Predicate<Integer> isEvenNumber = x -> x % 2==0;

   System.out.println(isEvenNumber.test(4));
   System.out.println(isEvenNumber.test(3));
}

콘솔 출력:

true
false

소비자

Consumer(영어 - "consumer") - T 유형의 객체를 입력 인수로 사용하고 일부 작업을 수행하지만 아무것도 반환하지 않는 기능적 인터페이스입니다.

@FunctionalInterface
public interface Consumer<T> {
   void accept(T t);
}

예를 들어, 전달된 문자열 인수를 사용하여 콘솔에 인사말을 출력하는 작업을 수행하는 를 생각해 보세요. Consumer

public static void main(String[] args) {
   Consumer<String> greetings = x -> System.out.println("Hello " + x + " !!!");
   greetings.accept("Elena");
}

콘솔 출력:

Hello Elena !!!

공급자

Supplier(영어 - 공급자) - 인수를 사용하지 않지만 T 유형의 객체를 반환하는 기능적 인터페이스:

@FunctionalInterface
public interface Supplier<T> {
   T get();
}

예를 들어 Supplier목록에서 임의의 이름을 생성하는 을 고려하십시오.

public static void main(String[] args) {
   ArrayList<String> nameList = new ArrayList<>();
   nameList .add("Elena");
   nameList .add("John");
   nameList .add("Alex");
   nameList .add("Jim");
   nameList .add("Sara");

   Supplier<String> randomName = () -> {
       int value = (int)(Math.random() * nameList.size());
       return nameList.get(value);
   };

   System.out.println(randomName.get());
}

그리고 이것을 실행하면 콘솔의 이름 목록에서 무작위 결과가 표시됩니다.

기능

Function— 이 기능적 인터페이스는 인수 T를 취해 이를 R 유형의 객체로 캐스팅하고 결과로 반환됩니다.

@FunctionalInterface
public interface Function<T, R> {
   R apply(T t);
}

예를 들어 숫자를 문자열 형식( )에서 숫자 형식( ) 으로 변환하는 을 살펴보겠습니다.FunctionStringInteger

public static void main(String[] args) {
   Function<String, Integer> valueConverter = x -> Integer.valueOf(x);
   System.out.println(valueConverter.apply("678"));
}

이를 실행하면 콘솔에 다음과 같은 출력이 표시됩니다.

678

추신: 숫자 뿐만 아니라 다른 문자도 문자열에 전달하면 예외가 발생합니다 .NumberFormatException

단항 연산자

UnaryOperator— T 유형의 객체를 매개변수로 취하여 이에 대해 일부 작업을 수행하고 동일한 T 유형의 객체 형태로 작업 결과를 반환하는 기능적 인터페이스입니다.

@FunctionalInterface
public interface UnaryOperator<T> {
   T apply(T t);
}

UnaryOperatorapply, 숫자를 제곱하는 방법을 사용합니다 .

public static void main(String[] args) {
   UnaryOperator<Integer> squareValue = x -> x * x;
   System.out.println(squareValue.apply(9));
}

콘솔 출력:

81

우리는 다섯 가지 기능적 인터페이스를 살펴보았습니다. 이것이 Java 8부터 사용할 수 있는 전부는 아닙니다. 이것이 기본 인터페이스입니다. 사용 가능한 나머지 것들은 복잡한 유사품입니다. 전체 목록은 공식 Oracle 설명서에서 확인할 수 있습니다 .

Stream의 기능적 인터페이스

위에서 설명한 것처럼 이러한 기능적 인터페이스는 Stream API와 긴밀하게 결합되어 있습니다. 어떻게 물어보나요? 그리고 많은 메소드가 Stream이러한 기능적 인터페이스와 특별히 작동합니다. NET에서 기능적 인터페이스를 어떻게 사용할 수 있는지 살펴보겠습니다 Stream.

술어가 있는 방법

예를 들어, 인수로 사용 하고 조건을 만족하는 요소만 반환하는 클래스 메서드를 살펴 Stream보겠습니다 . -a 의 맥락에서 이는 인터페이스 메소드 에서 사용될 때 반환되는 요소만 통과한다는 의미입니다 . 이것은 우리의 예가 에 대한 모습 이지만 다음의 요소 필터에 대한 것 입니다 . filterPredicateStreamPredicateStreamtruetestPredicatePredicateStream

public static void main(String[] args) {
   List<Integer> evenNumbers = Stream.of(1, 2, 3, 4, 5, 6, 7, 8)
           .filter(x -> x % 2==0)
           .collect(Collectors.toList());
}

결과적으로 목록은 evenNumbers{2, 4, 6, 8} 요소로 구성됩니다. 그리고 우리가 기억하는 것처럼 collect모든 요소를 ​​특정 컬렉션으로 수집합니다. 우리의 경우 List.

소비자와의 방법

Stream기능적 인터페이스를 사용하는 의 메소드 중 하나는 Consumer입니다 peek. Consumerin 에 대한 예시는 다음과 같습니다 Stream:

public static void main(String[] args) {
   List<String> peopleGreetings = Stream.of("Elena", "John", "Alex", "Jim", "Sara")
           .peek(x -> System.out.println("Hello " + x + " !!!"))
           .collect(Collectors.toList());
}

콘솔 출력:

Hello Elena !!!
Hello John !!!
Hello Alex !!!
Hello Jim !!!
Hello Sara !!!

그러나 이 메서드는 peek와 함께 작동 하므로 Consumer문자열 수정은 Stream발생하지 않지만 원래 요소와 동일하게 peek반환됩니다 . Stream따라서 목록은 peopleGreetings"Elena", "John", "Alex", "Jim", "Sara" 요소로 구성됩니다. 일반적으로 사용되는 방법도 있는데 foreach, 이 방법과 유사 peek하지만 최종-종료적이라는 점이 다릅니다.

공급자와의 방법

Stream함수 인터페이스를 사용하는 의 메서드 예로 전달된 함수 인터페이스를 기반으로 무한 시퀀스를 생성하는 가 Supplier있습니다 . generate예제를 사용하여 Supplier5개의 임의의 이름을 콘솔에 인쇄해 보겠습니다.

public static void main(String[] args) {
   ArrayList<String> nameList = new ArrayList<>();
   nameList.add("Elena");
   nameList.add("John");
   nameList.add("Alex");
   nameList.add("Jim");
   nameList.add("Sara");

   Stream.generate(() -> {
       int value = (int) (Math.random() * nameList.size());
       return nameList.get(value);
   }).limit(5).forEach(System.out::println);
}

그리고 이것은 콘솔에서 얻는 출력입니다:

John
Elena
Elena
Elena
Jim

limit(5)여기서는 메소드에 제한을 설정하기 위해 메소드를 사용했습니다 generate. 그렇지 않으면 프로그램은 콘솔에 임의의 이름을 무기한으로 인쇄합니다.

함수가 있는 방법

Stream인수가 있는 메서드의 일반적인 예는 한 유형의 요소를 가져와서 이를 사용하여 작업을 수행하고 전달하는 Function메서드입니다 . 그러나 이러한 요소는 이미 다른 유형의 요소일 수 있습니다. in을 map사용한 예는 다음 과 같습니다 . FunctionStream

public static void main(String[] args) {
   List<Integer> values = Stream.of("32", "43", "74", "54", "3")
           .map(x -> Integer.valueOf(x)).collect(Collectors.toList());
}

결과적으로 우리는 숫자 목록을 얻지만 Integer.

UnaryOperator를 사용하는 메서드

인수로 사용하는 메소드로 클래스 메소드 - UnaryOperator를 사용하겠습니다 . 이 메소드는 메소드와 유사합니다 . 또한 무한 시퀀스를 생성하지만 두 개의 인수가 있습니다.Streamiterategenerate

• 첫 번째는 시퀀스 생성이 시작되는 요소입니다.
• 두 번째는 이며 UnaryOperator, 이는 첫 번째 요소에서 새 요소를 생성하는 원리를 나타냅니다.

이것이 우리 예제의 모습입니다 UnaryOperator. 그러나 메소드에서는 다음과 같습니다 iterate.

public static void main(String[] args) {
   Stream.iterate(9, x -> x * x)
           .limit(4)
           .forEach(System.out::println);
}

이를 실행하면 콘솔에 다음과 같은 출력이 표시됩니다.

9
81
6561
43046721

즉, 각 요소는 자체적으로 곱해지고 처음 네 숫자에 대해서도 마찬가지입니다. 그게 다야! 이 기사를 읽은 후 Java의 Stream API를 이해하고 마스터하는 데 한 걸음 더 가까워지면 좋을 것입니다!