Java闭包介绍

发布于 2024-11-09 16:51:54 字数 300 浏览 2 评论 0原文

谁能描述一下这种代码来理解 Java 闭包。

public static <T> void sort(List<T> l, final {T, T=>Number} block) {

    Collections.sort(l, new Comparator<T>() {
        public int compare(T arg0, T arg1) {
            return block.invoke(arg0, arg1);
        }
    }
}

原文

Can any one please describe this sort of code to understand Java closure.

public static <T> void sort(List<T> l, final {T, T=>Number} block) {

    Collections.sort(l, new Comparator<T>() {
        public int compare(T arg0, T arg1) {
            return block.invoke(arg0, arg1);
        }
    }
}

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

生来就爱笑 2024-11-16 16:51:54

重要说明：问题是关于之前的提案。这不是所选择的语法。将此问答视为“历史参考”。

Gilad Bracha、Neal Gafter、James Gosling 和 Peter von der Ahé 的 BGGA-proposal 中描述了此语法。

这段代码可以描述如下：

它采用一个函数作为第二个参数，该函数接受参数 (T, T) 并返回 Number （并将其分配给参数 block)
然后它创建一个Comparator。它通过将 compare 方法委托给对 block 的调用来实现该方法。
将此比较器传递给 Collections.sort 方法。

下面是语法的细分：

public static <T> void sort(List<T> l, final {T, T=>Number} block) {
                                             ^^^^^^^^^^^^^^^^^^^^

一个名为 block 的参数，其类型为“函数，需要两个 T 并返回一个 Number”。

    Collections.sort(l, new Comparator<T>() {
        public int compare(T arg0, T arg1) {
            ...
        }
    }
}

对 Collections.sort 的普通调用，使用 Comparator 的匿名子类的实例作为第二个参数...

        ...
            return block.invoke(arg0, arg1);
        ...

...返回由定义的函数计算的数字块参数。

就经典 Java 而言，您的代码片段将对应于类似的内容

interface Block<T> {
    public int invoke(T arg1, T arg2);
}


class Test {
    public static <T> void sort(List<T> l, final Block<T> block) {
        Collections.sort(l, new Comparator<T>() {
            public int compare(T arg0, T arg1) {
                return block.invoke(arg0, arg1);
            }
        });
    }
}

Important note: The question was regarding an earlier proposal. This was not the syntax chosen. See this Q/A as a "historical reference".

This syntax is described in the BGGA-proposal by Gilad Bracha, Neal Gafter, James Gosling, and Peter von der Ahé.

This snippet of code can be described as follows:

It takes as the second argument a function taking parameters (T, T) and returning Number (and assigns it to parameter block)
It then creates a Comparator<T> out of it. This it does by implementing the compare method by delegating it to a call to block.
Passes this comparator to the Collections.sort method.

Here comes a break down of the syntax:

public static <T> void sort(List<T> l, final {T, T=>Number} block) {
                                             ^^^^^^^^^^^^^^^^^^^^

An argument called block which is of type "function that takes two T and returns a Number".

    Collections.sort(l, new Comparator<T>() {
        public int compare(T arg0, T arg1) {
            ...
        }
    }
}

An ordinary call to Collections.sort with an instance of an anonymous subclass of Comparator as second argument...

        ...
            return block.invoke(arg0, arg1);
        ...

...which returns the number computed by the function defined by the block argument.

Put in terms of classical Java, your snippet would correspond to something like

interface Block<T> {
    public int invoke(T arg1, T arg2);
}


class Test {
    public static <T> void sort(List<T> l, final Block<T> block) {
        Collections.sort(l, new Comparator<T>() {
            public int compare(T arg0, T arg1) {
                return block.invoke(arg0, arg1);
            }
        });
    }
}

回复收藏 0 原文