Java需要闭包吗？

我最近读了很多关于Java下一版本可能支持的内容。我觉得我对闭包是什么有着相当坚定的理解，但我想不出一个可靠的例子来说明闭包如何使面向对象语言“更好”。有谁能给我一个需要闭包（甚至是首选闭包）的特定用例吗？

最明显的是伪替换所有那些只有一个名为run（）或actionPerformed（）或类似方法的类。因此，您可以使用闭包，而不是使用可运行的嵌入式线程来创建线程。不比我们现在拥有的更强大，但更方便和简洁

---

那么我们需要闭包吗？不，他们会很高兴吗？当然，只要它们不觉得像我担心的那样被拴住就行了。

我想为了支持核心函数式编程概念，您需要闭包。通过对的支持，使代码更加优雅和可组合。另外，我喜欢将代码行作为参数传递给函数的想法。

它们并不能使面向对象语言变得更好。它们使实用语言更加实用

如果您正在用OO锤子攻击一个问题——将所有东西都表示为对象之间的交互——那么闭包就没有意义了。在一种基于类的OO语言中，闭包是烟雾弥漫的密室，在这里可以完成任务，但之后没有人谈论它。从概念上讲，这是令人憎恶的

实际上，它非常方便。我真的不想定义一个新类型的对象来保存上下文，为它建立“do stuff”方法，实例化它，并填充上下文。。。我只想告诉编译器，“看，看看我现在有权访问什么？这是我想要的上下文，这是我想要使用的代码-帮我保留这个，直到我需要它”

---

太棒了

Java从1.1开始就有闭包，只是非常麻烦和有限

只要您有某种描述的回调，它们通常都很有用。一种常见的情况是抽象掉控制流，留下有趣的代码来调用带有闭包的算法，而闭包没有外部控制流

一个简单的例子是针对每一个（尽管Java1.5已经有了）。虽然您可以按原样在Java中实现forEach方法，但它过于冗长而没有用处

---

一个在现有Java中已经有意义的例子是实现“executearound”习惯用法，即抽象资源获取和释放。例如，文件的打开和关闭可以在try/finally中完成，而客户端代码不必获得正确的细节。

作为一名java开发人员，为了成为一名更好的程序员，我想说，我希望看到Josh Block关于闭包的建议得到实施。我发现自己使用匿名内部类来表达一些事情，比如在聚合某些数据时如何处理列表中的每个元素。最好将其表示为闭包，而不必创建抽象类。

Java不需要闭包，面向对象语言可以使用中间对象来存储状态或执行操作（在Java的内部类中），完成闭包所做的一切。 但是闭包作为一种特性是可取的，因为它们大大简化了代码，提高了可读性，从而提高了代码的可维护性

我不是Java专家，但我使用的是C#3.5，闭包是我最喜欢的语言特性之一，例如，以下面的语句为例：

// Example #1 with closures
public IList<Customer> GetFilteredCustomerList(string filter) {
    //Here a closure is created around the filter parameter
    return Customers.Where( c => c.Name.Contains(filter)).ToList();
}

//带有闭包的示例#1
公共IList GetFilteredCustomerList（字符串筛选器）{
//这里围绕过滤器参数创建一个闭包
return Customers.Where（c=>c.Name.Contains（filter））.ToList（）；
}

现在以一个不使用闭包的等效示例为例

//Example #2 without closures, using just basic OO techniques
public IList<Customer> GetFilteredCustomerList(string filter) {
    return new Customers.Where( new CustomerNameFiltrator(filter));
}
... 
public class CustomerNameFiltrator : IFilter<Customer> {
    private string _filter;
    public  CustomerNameFiltrator(string filter) {
         _filter = filter;
    }
    public bool Filter(Customer customer) {
        return customer.Name.Contains( _filter);
    }
}

//示例#2没有闭包，只使用基本的OO技术
公共IList GetFilteredCustomerList（字符串筛选器）{
返回新客户。其中（新客户名称过滤器（过滤器））；
}
... 
公共类CustomerNameFilter:IFilter{
私有字符串过滤器；
公共CustomerNameFilter（字符串筛选器）{
_过滤器=过滤器；
}
公共布尔过滤器（客户）{
return customer.Name.Contains（_filter）；
}
}

我知道这是C#，而不是Java，但想法是一样的，闭包对于简洁性很有用，并且使代码更短、更可读。在幕后，C#3.5的闭包做了一些类似于示例#2的事情，这意味着编译器在幕后创建了一个私有类，并将“filter”参数传递给它

---

Java不需要闭包来工作，作为开发人员，您也不需要闭包，但是，它们是有用的，并提供了好处，这意味着它们在作为生产语言的语言中是可取的，其目标之一是生产率。

有一些非常有用的“高阶函数”，可以使用闭包对列表进行操作。高阶函数是以“函数对象”为参数的函数

例如，对列表中的每个元素应用某种转换是一种非常常见的操作。此高阶函数通常称为“map”或“collect”。（请参阅的*.spread运算符）

例如，要使列表中的每个元素不带闭包，您可能会编写：

List<Integer> squareInts(List<Integer> is){
   List<Integer> result = new ArrayList<Integer>(is.size());
   for (Integer i:is)
      result.add(i*i);
   return result;
}

（关于基本类型的装箱，这里可能存在性能问题。）

正如Pop Catalin所解释的，还有另一个更高阶的函数叫做“select”或“filter”：它可以用来获取符合某些条件的列表中的所有元素。例如：

而不是：

void onlyStringsWithMoreThan4Chars(List<String> strings){
   List<String> result = new ArrayList<String>(str.size()); // should be enough
   for (String str:strings)
      if (str.length() > 4) result.add(str);
   return result;
}

使用该提案

您可以看看Groovy语法，它是Java语言的一个扩展，现在支持闭包。有关如何使用闭包的更多示例，请参见关于集合的一章

一句话：

Th

void onlyStringsWithMoreThan4Chars(List<String> strings){
   List<String> result = new ArrayList<String>(str.size()); // should be enough
   for (String str:strings)
      if (str.length() > 4) result.add(str);
   return result;
}

strings.select({String str => str.length() > 4});

Runnable createStringPrintingRunnable(final String str){
    return new Runnable(){
       public void run(){
          System.out.println(str); // this accesses a variable from an outer scope
       }
    };
}

myArray.sort( (a, b) => a.myProperty().compareTo(b.myProperty() );

myArray.sort(new Comparator<MyClass>() {
   public int compare(MyClass a, MyClass b) {
      return a.myProperty().compareTo(b.myProperty();
   }
});

def reversecmp(x, y):
   return y - x

a = [4, 2, 5, 9, 11]
a.sort(cmp=reversecmp)

a = [4, 2, 5, 9, 11]
a.sort(cmp=lambda x, y : y - x)

class ReverseComparator implements Comparator {
   public compare(Object x, Object y) {
      return (Integer) y - (Integer) x;
   }

...

List<Integer> a = Arrays.asList(4, 2, 5, 9, 11);
Collections.sort(a, new ReverseComparator());

List<Integer> a = Arrays.asList(4, 2, 5, 9, 11);
Comparator reverse = new Comparator() {
   public Compare(Object x, Object y) {
       return (Integer) y - (Integer) x;
   }
}
Collections.sort(a, reverse);