我试图使用Java 8流在LinkedList中查找元素。但是，我想保证与筛选条件有且只有一个匹配。

以这段代码为例:

public static void main(String[] args) {

    LinkedList<User> users = new LinkedList<>();
    users.add(new User(1, "User1"));
    users.add(new User(2, "User2"));
    users.add(new User(3, "User3"));

    User match = users.stream().filter((user) -> user.getId() == 1).findAny().get();
    System.out.println(match.toString());
}

---

static class User {

    @Override
    public String toString() {
        return id + " - " + username;
    }

    int id;
    String username;

    public User() {
    }

    public User(int id, String username) {
        this.id = id;
        this.username = username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public int getId() {
        return id;
    }
}

这段代码根据用户的ID查找用户。但是不能保证有多少用户匹配过滤器。

更改过滤器行为:

User match = users.stream().filter((user) -> user.getId() < 0).findAny().get();

将抛出一个NoSuchElementException(很好!)

但是，如果有多个匹配，我希望它抛出一个错误。有办法做到这一点吗?

我已经快速阅读了Microsoft Lambda表达式文档。

不过，这样的例子帮助我更好地理解:

delegate int del(int i);
del myDelegate = x => x * x;
int j = myDelegate(5); //j = 25

不过，我还是不明白为什么这是一种创新。它只是一个在“方法变量”结束时死亡的方法，对吧?为什么我要用这个而不是真正的方法?

我有一个关于Function.identity()方法使用的问题。

想象下面的代码:

Arrays.asList("a", "b", "c")
          .stream()
          .map(Function.identity()) // <- This,
          .map(str -> str)          // <- is the same as this.
          .collect(Collectors.toMap(
                       Function.identity(), // <-- And this,
                       str -> str));        // <-- is the same as this.

是否有任何理由你应该使用Function.identity()而不是str->str(反之亦然)。我认为第二种选择更具有可读性(当然这是一种品味问题)。但是，有什么“真正”的理由让一个人更受青睐吗?

在Ruby 1.8中，proc/lambda和proc .new之间有细微的区别。

这些区别是什么? 你能告诉我如何决定选择哪一个吗? 在Ruby 1.9中，proc和lambda是不同的。怎么回事?

我如何从Java 8 lambda内部抛出CHECKED异常，例如在流中使用?

换句话说，我想让代码像这样编译:

public List<Class> getClasses() throws ClassNotFoundException {     

    List<Class> classes = 
        Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
              .map(className -> Class.forName(className))
              .collect(Collectors.toList());                  
    return classes;
    }

这段代码无法编译，因为上面的Class.forName()方法会抛出ClassNotFoundException，该异常会被检查。

请注意，我不想将已检查异常包装在运行时异常中，并抛出已包装的未检查异常。我想抛出检查异常本身，而不向流添加丑陋的try/catch。

最近我开始摆弄Python，发现闭包的工作方式有些特殊。考虑下面的代码:

adders=[None, None, None, None]

for i in [0,1,2,3]:
   adders[i]=lambda a: i+a

print adders[1](3)

它构建了一个简单的函数数组，这些函数接受单个输入，并返回该输入加上一个数字。函数是在for循环中构造的，其中迭代器i从0运行到3。对于这些数字中的每一个都创建一个lambda函数，该函数捕获i并将其添加到函数的输入中。最后一行以3作为参数调用第二个lambda函数。令我惊讶的是输出是6。

I expected a 4. My reasoning was: in Python everything is an object and thus every variable is essential a pointer to it. When creating the lambda closures for i, I expected it to store a pointer to the integer object currently pointed to by i. That means that when i assigned a new integer object it shouldn't effect the previously created closures. Sadly, inspecting the adders array within a debugger shows that it does. All lambda functions refer to the last value of i, 3, which results in adders[1](3) returning 6.

这让我想知道以下几点:

闭包究竟捕获了什么? 什么是最优雅的方法来说服lambda函数以一种不受i改变其值的影响的方式捕获i的当前值?

---

关于这个问题更容易理解、更实用的版本，具体到使用循环(或列表推导式、生成器表达式等)的情况，请参见在循环(或推导式)中创建函数(或lambdas)。这个问题的重点是理解Python中代码的底层行为。

如果您在这里试图解决在Tkinter中创建按钮的问题，请尝试Tkinter在for循环中创建按钮，传递命令参数以获得更具体的建议。

查看到底是什么包含在obj.__closure__?以了解Python如何实现闭包的技术细节。参见早期绑定和晚期绑定的区别是什么?有关术语讨论。

我在Java 8中使用lambda，我遇到警告，从lambda表达式引用的局部变量必须是final或有效的final。我知道当我在匿名类中使用变量时，它们在外部类中必须是final，但final和有效final之间的区别是什么?

我有一个表(SQL服务器)引用路径(UNC或其他)，但现在路径将会改变。

在路径列中，我有许多记录，我只需要改变路径的一部分，而不是整个路径。我需要在每条记录中，将相同的字符串更改为新的字符串。

我如何通过简单的更新来做到这一点?

当在Iterable上使用外部迭代时，我们使用break或return from enhanced for-each循环，如下:

for (SomeObject obj : someObjects) {
   if (some_condition_met) {
      break; // or return obj
   }
}

如何在Java 8 lambda表达式中使用内部迭代中断或返回:

someObjects.forEach(obj -> {
   //what to do here?
})

我看着MvcContrib网格组件，我很着迷，但同时又被网格语法中使用的语法技巧所排斥:

.Attributes(style => "width:100%")

上面的语法将生成的HTML的样式属性设置为width:100%。如果你注意的话，'style'并没有被指定。它是从表达式中参数的名称推导出来的!我必须深入研究这个问题，找到“魔法”发生的地方:

Hash(params Func<object, TValue>[] hash)
{
    foreach (var func in hash)
    {
        Add(func.Method.GetParameters()[0].Name, func(null));
    }
}

因此，代码确实使用了正式的、编译时的参数名称来创建属性名称-值对的字典。生成的语法结构确实非常具有表现力，但同时也非常危险。

lambda表达式的一般用法允许替换所使用的名称而不产生副作用。我在一本书上看到一个例子，上面写着收藏。我知道我可以在我的代码集合中写。ForEach(log => fire。burn (log))它的意思是一样的。但是使用这里的MvcContrib Grid语法，我突然发现代码可以根据我为变量选择的名称主动查找并做出决定!

那么这是c# 3.5/4.0社区和lambda表达式爱好者的普遍做法吗?还是说，我不应该担心一个流氓的诡计特立独行?