标签: lambda

我想复制Java 8流,以便我可以处理它两次.我可以collect作为一个列表并从中获得新的流;

// doSomething() returns a stream
List<A> thing = doSomething().collect(toList());
thing.stream()... // do stuff
thing.stream()... // do other stuff

但我认为应该有一种更有效/更优雅的方式.

有没有办法复制流而不将其转换为集合？

我实际上正在使用Eithers 流,所以想要在移动到正确的投影之前以一种方式处理左投影并以另一种方式处理.有点像这样(到目前为止,我被迫使用这个toList技巧).

List<Either<Pair<A, Throwable>, A>> results = doSomething().collect(toList());

Stream<Pair<A, Throwable>> failures = results.stream().flatMap(either -> either.left());
failures.forEach(failure -> ... );

Stream<A> successes = results.stream().flatMap(either -> either.right());
successes.forEach(success -> ... );

我正在使用第三方库,它具有将函数作为参数的函数.我正在做一些条件检查来决定是否将特定函数添加为参数,在某些情况下我不想提供函数.在这种情况下提供null会引发错误.

我发现这个代码有效,但我不完全理解发生了什么.

compose(__DEV__ ? devTools() : f => f)

是f => f相当于() => {}一个空的匿名函数？

我正在使用LINQ lambda表达式,如下所示:

int Value = 1;
qryContent objContentLine;

using (Entities db = new Entities())
{
    objContentLine = (from q in db.qryContents
                      where q.LineID == Value
                      orderby q.RowID descending
                      select q).FirstOrDefault();
}

但是,我收到以下错误:

无法将lambda表达式转换为类型'string',因为它不是委托类型

我看到java.util.function.BiFunction,所以我可以这样做:

BiFunction<Integer, Integer, Integer> f = (x, y) -> { return 0; };

如果那还不够好我需要TriFunction怎么办？它不存在!

TriFunction<Integer, Integer, Integer, Integer> f = (x, y, z) -> { return 0; };

我想我应该补充一点,我知道我可以定义自己的TriFunction,我只是想了解不在标准库中包含它的原理.

我非常想使用Map.computeIfAbsent,但是因为lambdas在本科课程中已经太长了.

几乎直接来自文档:它给出了一个旧方法的例子:

Map<String, Boolean> whoLetDogsOut = new ConcurrentHashMap<>();
String key = "snoop";
if (whoLetDogsOut.get(key) == null) {
  Boolean isLetOut = tryToLetOut(key);
  if (isLetOut != null)
    map.putIfAbsent(key, isLetOut);
}

而新的方式:

map.computeIfAbsent(key, k -> new Value(f(k)));

但在他们的例子中,我认为我并没有"得到它".我如何转换代码以使用新的lambda表达方式？

我知道这是Linq:

var _Results = from item in _List
                where item.Value == 1
                select item;

我知道这是Lambda:

var _Results = _List.Where(x => x.Value == 1);

编者注:以上不仅仅是Lambda,Linq使用的是"方法语法",其谓词是Lambda.需要说明的是,以上两个样本都是Linq(我原来的帖子不正确,但我留下了错误来说明提示问题的混乱).

但是Linq是Lambda的子集还是什么？

为什么有两个看似相同的技术？

是否有技术上的理由来选择其中一个？

我主要使用lambda函数,但有时使用似乎提供相同行为的嵌套函数.

这里有一些简单的例子,如果在另一个函数中找到它们,它们在功能上做同样的事情:

Lambda函数

>>> a = lambda x : 1 + x
>>> a(5)
6

嵌套功能

>>> def b(x): return 1 + x

>>> b(5)
6

使用一个优于另一个是否有优势？(性能？可读性？限制？一致性？等)

它甚至重要吗？如果不这样做那就违反了Pythonic原则:

"应该有一种 - 最好只有一种 - 显而易见的方法".

为什么我不能在"快速监视"窗口中调试时使用lambda表达式？

UPD:另见

http://blogs.msdn.com/b/jaredpar/archive/2009/08/26/why-no-linq-in-debugger-windows.aspx

http://blogs.msdn.com/b/jaredpar/archive/2010/06/02/why-is-linq-absent-from-debugger-windows-part-2.aspx

有没有办法按值捕获,并使捕获的值非const？我有一个库函子,我想捕获并调用一个非常量但应该是的方法.

以下不编译,但使foo :: operator()const修复它.

struct foo
{
  bool operator () ( const bool & a )
  {
    return a;
  }
};


int _tmain(int argc, _TCHAR* argv[])
{
  foo afoo;

  auto bar = [=] () -> bool
    {
      afoo(true);
    };

  return 0;
}

我有下面的代码,对于多次空检查有点难看.

String s = null;

if (str1 != null) {
    s = str1;
} else if (str2 != null) {
    s = str2;
} else if (str3 != null) {
    s = str3;
} else {
    s = str4;
}

所以我尝试使用Optional.ofNullable如下所示,但如果有人读取我的代码仍然很难理解.在Java 8中这样做的最佳方法是什么.

String s = Optional.ofNullable(str1)
                   .orElse(Optional.ofNullable(str2)
                                   .orElse(Optional.ofNullable(str3)
                                                   .orElse(str4)));

在Java中9,我们可以使用Optional.ofNullable同OR,但在Java8还有没有其他办法？