我想看看f在map/flatmap中传递的函数,但没有运气.我抛出一个例外,看到任何迹象f,没有用.那是什么功能？它是如何在幕后产生的？
Exception in thread "main" java.lang.RuntimeException
at x.x.Main$A.getInt(Empty.scala:8)
at x.x.Main$A.flatMap(Empty.scala:10)
object Main extends App {
class A {
def getInt: Int = throw new RuntimeException
def map(f: Int => Boolean): Boolean = f(getInt)
def flatMap(f: Int => Boolean): Boolean = f(getInt)
}
for {
x <- new A
y <- new A
} yield x == y
}
我正在尝试使用flatMap OptionalJava.这是一个简化的例子:
List<String> x = Arrays.asList("a", "b", "c");
List<String> result = x.stream().flatMap((val) -> val.equals("b") ? Optional.empty() : Optional.of(val)).collect(Collectors.toList());
我从编译器收到此错误消息:
Error:(10, 27) java: incompatible types: no instance(s) of type variable(s) T exist so that java.util.Optional<T> conforms to java.util.stream.Stream<? extends R>
怎么了？以下是我在Scala中尝试实现的示例:
List("a", "b", "c").flatMap(x => if (x == "b") None else Some(x))
它返回:
res2: List[String] = List(a, c)
正如所料.
如何将其转换为Java以便编译？
如何将a Set<Result>转换为Map<Item, Set<String>>或SetMultimap<Item, String>使用Java 8流或Multimaps,其中Result:
class Result {
String name;
Set<Item> items;
}
例如,我从:
result1:
name: name1
items:
- item1
- item2
result2:
name: name2
items:
- item2
- item3
并以:
item1:
- name1
item2:
- name1
- name2
item3:
- name2
说我有这样的事情:
let values = [1,2,3,4];
let newValues = values.map((v) => {
return v *v ;
});
console.log(newValues); //[1,4,9,16]
挺直的.
现在,如果我想为每个对象返回多个值,该怎么办？
例如.
let values = [1,2,3,4];
let newValues = values.map((v) => {
return [v *v, v*v*v, v+1] ;
});
console.log(newValues); //This is what I want to get
//[1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64, 5]
我可以使用reduce函数
let values = [1,2,3,4];
let newValues = values.map((v) => {
return [v *v, v*v*v,v+1] ;
}).reduce((a, c) => {
return a.concat(c); …我正在检查.lazy高阶函数,并且得到了一些与flatMap函数相关的有趣编译错误(可能还有其他函数)
例子
let array = [1, 2, 3, 4, 5, 6]
array
.flatMap {
print("DD")
return $0 // Cannot convert return expression of type 'Int' to return type 'String?'
}
.forEach {
print("SS")
print($0)
}
评论一下
array
.flatMap {
// print("DD")
return $0
}
.forEach {
print("SS")
print($0)
}
一切正常......更有趣的例子
array
.flatMap {
let z = $0
return $0 // Or return z - all is the same "Cannot convert return expression of type 'Int' to return type … 在Clojure中,你在Clojure中有一个名为mapcat的函数,它与Scala中的flatmap有一些相似之处.它用于将函数映射到列表并返回列表.
在Haskell中,我们有一个函数ConcatMap,它的名字看起来非常相似.
我的问题是 - Clojure中的mapcat和Haskell中的concatmap有什么区别？
我有以下Scala代码:
def f(x: Int, y: Int): Option[String] = x*y match {
case 0 => None
case n => Some(n.toString)
}
val data = List((0, 1), (1, 0), (2, 3), (4, -1))
data flatMap {case (x, y) => f(x, y)}
但是,最后一行太冗长,所以我尝试了所有这些并且没有一个编译.
data flatMap f
data flatMap f.tupled
data flatMap Function.tupled(f)
data flatMap {f _}
data flatMap (f _).tupled
data flatMap f(_)
我究竟做错了什么？唯一有效的是:
(data map Function.tupled(f)).flatten
我认为map随后flatten可以总是被替换为flatMap,但是虽然上面的行编译,但这不是:
data flatMap Function.tupled(f)
如果我使用xxx.flatMap(_.split(" "))，它会拆分数组然后展平还是会展平然后拆分？
我是一名 Java 初学者，我刚刚学习了map和flatMap.
当 2d List 应该转换为 1d List 时，它是如下实现的。
List<List<Integer>> list_2d = List.of(List.of(1, 2), List.of(3, 4));
List<Integer> lst1 = list_2d
.stream()
.flatMap(arr -> arr.stream())
.collect(Collectors.toList());
printAll(lst1); // [1, 2, 3, 4]
但是，我认为它看起来可以不使用flatMap.
有什么方法可以使代码具有相同的逻辑，只是使用map，而不是使用flatMap？
只是问，因为如果map可以全部替换flatMap，就没有理由记住flatMap。我总是追求简单和基本的东西。
skipUntil当使用和flatMap(fn, concurrency)运算符时，我在 Reactor (v. 3.4.2) 中经历了奇怪的行为concurrency=1。管道挂了。
为了证明我的意思，这里有一个简短的例子，它按我的预期工作：
Flux.range(1, 5)
.skipUntil(v -> v > 1)
.flatMap(v -> Mono.just(v))
.doOnNext(System.out::println)
.blockLast();
它将2、3、4和打印5到单独的行。但是，如果我添加等于运算符的并发参数，1则flatMap执行将挂起：
Flux.range(1, 5)
.skipUntil(v -> v > 1)
.flatMap(v -> Mono.just(v), 1)
.doOnNext(System.out::println)
.blockLast();
我不知道我是否错过了某些东西，或者skipUntil在它跳过第一个项目后，它不会从上游请求下一个项目，或者存在一些错误的行为。第二个例子有效吗？