New features of Java 8: Detailed explanation of built-in functional interfaces

Java 8 new features built-in functional interface

In a previous blog post, Lambda expression, I mentioned the functional interface provided by Java 8. In this article, we will introduce the four most basic functional interfaces in Java 8

. Strictly speaking, for method references, an interface needs to be defined. No matter how we operate, there are only four interfaces that are actually possible to operate.

Java 8 provides the functional interface package java.util.function.*, under which there are many built-in functional interfaces in Java 8. But it is basically divided into four basic types:

Functional interface (Function)

takes T as input and returns R as output. It also includes combinations with other functions. Default method.

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

Sample code

public static void main(String[] args) {
     
    // 这里用到了Java8的 方法引用，功能型函数式接口！
    Function<String,Boolean> function = "Hello Java" :: endsWith;
    System.out.println(function.apply("Java"));
}

Consumer interface (Consumer)

will T takes input, returns nothing, and represents an operation on a single argument.

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

Sample code

class TestDemo{
  //此方法没有返回值，但是有输入参数
  public void fun(String str){
    System.out.println(str);
  }
}
 
 
public class TestFunctional {
  public static void main(String[] args) {
    TestDemo demo = new TestDemo();
    //消费型接口，只有输入参数，没有输出参数
    Consumer<String> consumer = demo :: fun;
    consumer.accept("");
 
  }
}
 
<br>

Supply interface (Supplier)

No input parameters, only T returns output

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

Sample code

public class TestFunctional {
  public static void main(String[] args) {
 
    //供应商类型接口，只有输出参数，没有输入参数！
    Supplier<String> supplier = "java 8" :: toUpperCase;
    System.out.println(supplier.get());
  }
}

Assertive interface (Predicate)

Take T as input and return a Boolean value as output. This interface contains a variety of default methods to combine Predicate into other complex logic (AND, OR, NOT).

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

Sample code

  public class TestFunctional {
  public static void main(String[] args) {
     
    //断言类型接口。有输入参数，输出参数为布尔值
    Predicate<String> predicate = "Android" :: equalsIgnoreCase;
    System.out.println(predicate.test("android"));
     
  }
}    　　

Therefore, in Java 8, due to the existence of the above four functional interfaces, it is generally rare for users to define new functions. interface!

Thank you for reading, I hope it can help you, thank you for your support of this site!

For more Java 8 new features and detailed explanations of the built-in functional interface, please pay attention to the PHP Chinese website for related articles!