标签: functional-interface

最近我开始探索Java 8,我无法理解Java功能实现lambda表达式所必需的"功能接口"的概念.有一个非常全面的 Java函数中的lambda函数指南,但我仍然坚持用于定义函数接口概念的章节.定义如下:

更确切地说,功能接口被定义为具有恰好一个抽象方法的任何接口.

然后他进入示例,其中一个是Comparator界面:

public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
} 

Run Code Online (Sandbox Code Playgroud)

我能够测试我可以使用lambda函数代替Comparator参数,它可以工作(即Collections.sort(list, (a, b) -> a-b)).

但是在Comparator接口中,两者compare和equals方法都是抽象的,这意味着它有两个抽象方法.那么如果定义要求接口只有一个抽象方法,那么它如何工作呢？我在这里错过了什么？

为什么供应商只支持no-arg构造函数？

如果存在默认构造函数,我可以这样做:

create(Foo::new)

但如果唯一的构造函数采用String,我必须这样做:

create(() -> new Foo("hello"))

我的问题是关于InterruptedException，它是从Thread.sleep方法中抛出的。在合作时，ExecutorService我注意到一些我不理解的怪异行为；这是我的意思：

ExecutorService executor = Executors.newSingleThreadExecutor();
    executor.submit(() -> {
        while(true)
        {
            //DO SOMETHING
            Thread.sleep(5000);
        }
    });

有了这个代码，编译器不给我任何错误或消息InterruptedException从Thread.sleep应该被抓。但是，当我尝试更改循环条件并用诸如此类的变量替换“ true”时：

ExecutorService executor = Executors.newSingleThreadExecutor();
    executor.submit(() -> {
        while(tasksObserving)
        {
            //DO SOMETHING
            Thread.sleep(5000);
        }
    });

编译器不断抱怨InterruptedException必须处理。有人可以向我解释为什么会发生这种情况，为什么将条件设置为true则编译器会忽略InterruptedException？

跟我说,介绍有点啰嗦,但这是一个有趣的难题.

我有这个代码:

public class Testcase {
    public static void main(String[] args){
        EventQueue queue = new EventQueue();
        queue.add(() -> System.out.println("case1"));
        queue.add(() -> {
            System.out.println("case2");
            throw new IllegalArgumentException("case2-exception");});
        queue.runNextTask();
        queue.add(() -> System.out.println("case3-never-runs"));
    }

    private static class EventQueue {
        private final Queue<Supplier<CompletionStage<Void>>> queue = new ConcurrentLinkedQueue<>();

        public void add(Runnable task) {
            queue.add(() -> CompletableFuture.runAsync(task));
        }

        public void add(Supplier<CompletionStage<Void>> task) {
            queue.add(task);
        }

        public void runNextTask() {
            Supplier<CompletionStage<Void>> task = queue.poll();
            if (task == null)
                return;
            try {
                task.get().
                    whenCompleteAsync((value, exception) -> runNextTask()).
                    exceptionally(exception …

我刚开始学习Java流并遇到了问题.请看下面的例子.这是Node类的一部分:

private Map<String, Node> nodes;

public Optional<Node> child(String name) {
    return Optional.<Node>ofNullable(nodes.get(name));
}

private void findChildren(String name, List<Node> result) {
    child(name).ifPresent(result::add);
    nodes.values().stream()
//          .map(Node::findChildren(name, result))
//          .forEach(Node::findChildren(name, result))
            .forEach(node -> node.findChildren(name, result));
}

我的目的是使用流中每个节点上的名称和结果参数调用#findChildren.我试图使用方法引用Node :: findChildren没有运气.我很欣赏其他与->运营商合作的解决方案.

是否有可能将方法引用与参数一起使用？我喜欢流的想法,我只想让代码更具可读性.

实际上,我认为有一个类似的问题方法引用与我读过的参数,但无法弄清楚如何在我的代码中使用bind2方法.这是唯一的解决方案吗？

我认为这个问题已经存在,但我无法找到它.

我不明白,为什么有必要使用功能界面来处理lambdas.请考虑以下示例:

public class Test {

    public static void main(String...args) {
        TestInterface i = () -> System.out.println("Hans");
//      i = (String a) -> System.out.println(a);

        i.hans();
//      i.hans("Hello");
    }
}

public interface TestInterface {
    public void hans();
//  public void hans(String a);
}

这没有问题,但如果您取消注释注释行,它不会.为什么？在我的理解中,编译器应该能够区分这两种方法,因为它们具有不同的输入参数.为什么我需要一个功能界面并炸毁我的代码？

编辑:链接重复项没有回答我的问题,因为我问的是不同的方法参数.但是我在这里得到了一些非常有用的答案,感谢所有帮助过的人!:)

编辑2:对不起,我显然不是母语人士,但为了准确自己:

public interface TestInterface {
    public void hans();                 //has no input parameters</br>
    public void hans(String a);         //has 1 input parameter, type String</br>
    public void hans(String a, int b);  //has 2 input parameters, 1. type = String, …

正如标题中所述,我正在寻找一个预先存在的功能界面,Predicate但其test方法不需要参数.如果这样的动物存在,我会很感激参考.

谢谢.

在Java 8 中引入了lambda表达式以帮助减少样板代码.如果界面只有一个方法,它可以正常工作.如果它由多个方法组成,那么这些方法都不起作用.我该如何处理多种方法？

我们可以选择以下示例

public interface I1()
{
    void show1();
    void show2();
}

那么主要功能的结构是什么来定义main本身的方法呢？

Comparator接口有自己的equals()方法.equals()默认情况下,任何类都将通过Object类获取.equals()在接口中有什么方法需要？

首先，很抱歉标题不好，但我发现很难用一句话概括我的问题......

我们的软件中有一些代码我非常不满意。事情是这样的：

    @FunctionalInterface
    public interface OneArgCall<T, U, A> {
        T execute(U u, A arg);
    }

    @FunctionalInterface
    public interface TwoArgCall<T, U, A, B> {
        T execute(U u, A arg, B arg2);
    }

    public <T, U, A, B> T execCall(String x, Class<U> c, OneArgCall<T, U, A> call, A arg) {
        U u = doSomething(x, c);
        try {
            return call.execute(u, arg);
        } catch (SomeException se) {
           handleSe(se);
        } catch (SomeOtherException soe) {
           handleSoe(soe);
    }
    
    public <T, U, A, B> T execCall(String x, Class<P> …