函数式接口,就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口,let's coding。
(1)Consumer
package java.util.function;
import java.util.Objects;
/**
* Represents an operation that accepts a single input argument and returns no
* result. Unlike most other functional interfaces, {@code Consumer} is expected
* to operate via side-effects.
*
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is {@link #accept(Object)}.
*
* @param <T> the type of the input to the operation
*
* @since 1.8
*/
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
/**
* Returns a composed {@code Consumer} that performs, in sequence, this
* operation followed by the {@code after} operation. If performing either
* operation throws an exception, it is relayed to the caller of the
* composed operation. If performing this operation throws an exception,
* the {@code after} operation will not be performed.
*
* @param after the operation to perform after this operation
* @return a composed {@code Consumer} that performs in sequence this
* operation followed by the {@code after} operation
* @throws NullPointerException if {@code after} is null
*/
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
该类使用@FunctionInterface注解表明该类是函数式接口
实例:
package function;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
/**
*
* @author smart 2019/3/25
*/
public class ConsumerInterface {
public static void main(String[] args) {
Consumer<Integer> consumer = (Integer t)-> System.out.println(t);
Consumer<Integer> consumer1 = (Integer t)-> System.out.println(t+1);
List<Integer> result = Arrays.asList(1,2,3);
result.stream().forEach(consumer.andThen(consumer1));
}
}
(2)同理可以学习 Supplier,Predict,Functional 接口,下面主要给出实例
(2.1)Supplier实例
package function;
/**
*
* @author smart 2019/3/25
*/
public class Student {
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
private String name;
}
package function;
import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;
/**
*
* @author smart 2019/3/25
*/
public class SupplierInterface {
public static void main(String[] args) {
Supplier<Student> supplier = ()-> {
Student student = new Student();
student.setName("12222");
return student;
};
Student student = supplier.get();
System.out.println(student);
}
}
(2.2)Predict
package function;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
/**
*
* @author smart 2019/3/25
*/
public class PredictInterface {
public static void main(String[] args) {
List<Integer> result = Arrays.asList(1,2,3);
Predicate<Integer> predicate = (t)->{
if(t%2==0){
return true;
}
return false;
};
System.out.println(result.stream().anyMatch(predicate));
System.out.println(result.stream().allMatch(predicate));
}
}
(2.3)Function
package function;
import java.util.function.Function;
/**
*
* @author smart 2019/3/25
*/
public class FunctionInterface {
public static void main(String[] args) {
Function<Integer,String> function = (t)->
{return String.valueOf(t);};
function.apply(new Integer(2000));
}
}