Java 8の新しい特性の学習を覚えます(中間編)---関数式インタフェース@FunctionalInterface

一:関数インタフェースとは
関数式インタフェースとは,もちろんまずインタフェースであり,次にこのインタフェースには抽象的な方法しかない.
このタイプのインタフェースはSAMインタフェース、すなわちSingle Abstract Method interfacesとも呼ばれる
特長

インタフェースには、抽象的な方法が1つしかない

がある.

静的方法

の定義を可能にする.

デフォルトメソッドの定義を許可する

javaを許可する.lang.Objectにおけるpublicメソッド

注記は必須ではありません.1つのインタフェースが「関数インタフェース」定義に合致する場合、注記を追加しても追加しても影響しません.この注釈を加えると、コンパイラがよりよくチェックされます.関数インタフェースではないが@FunctionInterfaceが付いている場合、コンパイラは

とエラーを報告します.
例

//         
@FunctionalInterface
public interface TestInterface {
 
    //     
    public void sub();
 
    // java.lang.Object  public  
    public boolean equals(Object var1);
 
    //     
    public default void defaultMethod(){
    
    }
 
    //     
    public static void staticMethod(){
 
    }
}

//         (       )
@FunctionalInterface
public interface TestInterface2 {

    void add();
    
    void sub();
}

　　
使用法

Runnableの使い方

社内の使い方紹介

/**
 *        
 */
@FunctionalInterface
public static interface RequestExecutor {
    Object doExecute() throws BusinessException;
}

/**
 *     
 */
public void templateRequest(RequestExecutor executor) {
    //   response  
    HttpServletResponse response =
        ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
    
    try {
        
        Object result = executor.doExecute();
        writeAjaxJSONResponse(ResultMessageBuilder.build(true, "success!", result), response);
        
    } catch (Exception e) {
    
        logger.error("    ", e);
        writeAjaxJSONResponse(ResultMessageBuilder.build(false, 500, "    "), response);
        
    }
}

/**
 * controller    
 */
@PostMapping(path = "/pageQuery")
public void pageQuery(@RequestBody Query query) {
    templateRequest(() -> service.pageQuery(query));
}

/**
 * service    
 */
public PagedResult pageQuery(Query query);

　　
JDKの関数インタフェースの例
java.lang.Runnable,
java.awt.event.ActionListener,
java.util.Comparator,
java.util.concurrent.Callable
java.util.Consumer、Predicate、Supplierなどのfunctionパッケージのインタフェース
Comparatorの例:

package java.util;

import java.io.Serializable;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
import java.util.Comparators;

@FunctionalInterface
public interface Comparator {

    int compare(T o1, T o2);

    boolean equals(Object obj);

    default Comparator reversed() {
        return Collections.reverseOrder(this);
    }


    default Comparator thenComparing(Comparator super T> other) {
        Objects.requireNonNull(other);
        return (Comparator & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }

 
    default  Comparator thenComparing(
            Function super T, ? extends U> keyExtractor,
            Comparator super U> keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }


    default > Comparator thenComparing(
            Function super T, ? extends U> keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }

    default Comparator thenComparingInt(ToIntFunction super T> keyExtractor) {
        return thenComparing(comparingInt(keyExtractor));
    }

    default Comparator thenComparingLong(ToLongFunction super T> keyExtractor) {
        return thenComparing(comparingLong(keyExtractor));
    }


    default Comparator thenComparingDouble(ToDoubleFunction super T> keyExtractor) {
        return thenComparing(comparingDouble(keyExtractor));
    }


    public static > Comparator reverseOrder() {
        return Collections.reverseOrder();
    }

  
    @SuppressWarnings("unchecked")
    public static > Comparator naturalOrder() {
        return (Comparator) Comparators.NaturalOrderComparator.INSTANCE;
    }


    public static  Comparator nullsFirst(Comparator super T> comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }

    public static  Comparator nullsLast(Comparator super T> comparator) {
        return new Comparators.NullComparator<>(false, comparator);
    }


    public static  Comparator comparing(
            Function super T, ? extends U> keyExtractor,
            Comparator super U> keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

  
    public static > Comparator comparing(
            Function super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }


    public static  Comparator comparingInt(ToIntFunction super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }

 
    public static Comparator comparingDouble(ToDoubleFunction super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
    }
}