标签: functional-interface

这段代码有什么区别？

Supplier<LocalDate> s1 = LocalDate::now;
LocalDate s2 = LocalDate.now();

System.out.println(s1.get()); //2016-10-25
System.out.println(s2); //2016-10-25

我开始学习Java 8中的功能接口,而不了解供应商的好处.究竟何时以及如何使用它们.供应商是否提高了绩效或者提取抽象水平的好处？

谢谢你的回答!这不是重复的问题,因为我使用搜索并没有找到我需要的东西.

更新1: 你的意思是这个？

    Supplier<Long> s1 = System::currentTimeMillis;
    Long s2 = System.currentTimeMillis();

    System.out.println(s1.get()); //1477411877817
    System.out.println(s2); //1477411877817
    try {
        Thread.sleep(3000l);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(s1.get()); //1477411880817 - different
    System.out.println(s2); //1477411877817

我遇到了奇怪的错误消息，我认为这可能是不正确的。考虑以下代码：

public class Overloaded {
    public interface Supplier {
        int get();
    }

    public interface Processor {
        String process(String s);
    }

    public static void load(Supplier s) {}
    public static void load(Processor p) {}

    public static int genuinelyAmbiguous() { return 4; }
    public static String genuinelyAmbiguous(String s) { return "string"; }

    public static int notAmbiguous() { return 4; }
    public static String notAmbiguous(int x, int y) { return "string"; }

    public static int strangelyAmbiguous() { return 4; }
    public static String strangelyAmbiguous(int …

import java.util.function.*;

class Test { 
    void test(int    foo, Consumer<Integer> bar) { }
    void test(long   foo, Consumer<Long>    bar) { }
    void test(float  foo, Consumer<Float>   bar) { }
    void test(double foo, Consumer<Double>  bar) { }
}

当我编译这个时,javac -Xlint Test.java我会得到一些警告:

Test.java:4: warning: [overloads] test(int,Consumer<Integer>) in Test is potentially ambiguous with test(long,Consumer<Long>) in Test
    void test(int    foo, Consumer<Integer> bar) { }
         ^
Test.java:6: warning: [overloads] test(float,Consumer<Float>) in Test is potentially ambiguous with test(double,Consumer<Double>) in Test
    void test(float  foo, Consumer<Float>   bar) { } …

我试图看看是否有任何方法可以获得Java 8中作为功能接口的所有接口的列表.我不是在谈论这个页面上的列表:

https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

相反,我在谈论像Comparator,FileFilter和Runnable这样的接口--API文档显示的接口是这样的功能:

@FunctionalInterface公共接口Runnable

这些地方有完整的清单吗？

谢谢!

我试图理解Comparator.comparing函数是如何工作的.我创建了自己的比较方法来理解它.

private static <T,U extends Comparable<U>> Comparator<T> comparing(Function<T,U> f) {
    BiFunction<T,T,Integer> bfun = (T a, T b) -> f.apply(a).compareTo(f.apply(b));
    return (Comparator<T>) bfun;
}

此函数的最后一行抛出异常.

但是,如果我将此功能更改为

private static <T,U extends Comparable<U>> Comparator<T> comparing(Function<T,U> f) {
    return (T a, T b) -> f.apply(a).compareTo(f.apply(b));
}

它按预期工作得很好.

第二次尝试使用的中间功能接口是什么,能够将lambda转换为Comparator？

我这样做了:

public class LambdaConflict
{
    public static void main(String args[]){
        //*
        System.out.println(LambdaConflict.get(
            (str) -> "Hello World!! By ME?"
        ));
        /*/
        System.out.println(LambdaConflict.get(new Intf<String> (){
            @Override public String get1(String str){
                return "Hello World!! By get1 " + str;
            }
        }));
        /*****/
    }

    public static String get(Intf<String> i, boolean b){
        return i.get1("from 1");
    }
}

interface Intf<T>
{
    public T get1(T arg1);

    public T get2(T arg1);
}

并获得此异常:

不兼容的类型:Intf不是函数接口在接口Intf中找到的多个非重写抽象方法注意:某些消息已被简化; 使用-Xdiags重新编译:详细以获得完整输出1错误

是否有任何条件我不能使用lambda来替换匿名类？

我刚刚开始学习Camel,我看到的第一件事就是

    context.addRoutes(new RouteBuilder() {
        public void configure() {
            from("file:data/inbox?noop=true").to("file:data/outbox");
        }
    });

我(合理地恕我直言)尝试替换

    context.addRoutes(()->from("file:data/inbox?noop=true").to("file:data/outbox"));

但那是无效的.

当我挖掘时,我发现lambdas适用于功能接口(如果接口符合条件,则暗示)但@FunctionalInterface注释只能应用于接口(足够公平)并且据我所知,没有抽象类的等效注释.当然,RouteBuilder是一个抽象类.

为什么lambdas仅限于接口？

界面和类之间的本质区别是什么使"功能类"不安全/不可预测/不合理？

我可以理解是否有一些限定符,例如抽象方法必须公开,但我无法解释为什么上述是不合理的.

我怎样才能在Java 8中做这样的事情？

boolean x = ((boolean p)->{return p;}).apply(true);

现在我收到以下错误:

此表达式的目标类型必须是功能接口

我有几个实现相同方法的预定义静态"处理器",例如:

default double process(double num){

样品:

public class Test {
    public static void main(String[] args) {
        test(Test::processor1, 1d);
        test(Test::processor2, 1d);
    }

    static double processor1(double num){
        return num * 10;
    }

    static double processor2(double num){
        return num * 20;
    }
    //...

    static void test(Function<Double, Double> f, double d){
        // Do something util here
        System.out.println(f.apply(d));
    }   
    ...

现在假设我有一些对象可以提供额外的"处理器"列表.

我正在尝试使用a interface来定义那些额外的"处理器".

    static interface IProcessor{
        double process(double num);
    }

使用附加"处理器"实现对象:

    static class SomeObject{
        // Just return one but should be a list...
        static …

StreamJava 8中的类定义了一个max需要Comparator参数的方法.这是方法签名:

Optional<T> max(Comparator<? super T> comparator)

Comparator是一个compare具有此签名的抽象方法的功能接口.通知compare需要2个参数.

int compare(T o1, T o2)

该Comparable接口具有compareTo带此签名的抽象方法.通知compareTo只需要1个参数.

int compareTo(T o)

在Java 8中,以下代码完美地运行.但是,我期望编译错误,例如"Integer类没有定义compareTo(Integer,Integer)".

int max = Stream.of(0, 4, 1, 5).max(Integer::compareTo).get();

有人可以帮助解释为什么即使他们的方法签名不兼容Comparable,Comparator也可以将实例传递给期望实例的方法？