我试图解析以下JSON:
{
"String For Key 1": [
"Some String A",
"Some String B",
"Some String C",
],
"String For Key 2": [
"Some String D",
"Some String E",
"Some String F"
],
"String For Key 3": [
"Some String G",
"Some String H",
"Some String I",
],
"String For Key 4": [
"Some String J",
"Some String K",
"Some String L"
],
"String For Key 5": [
"Some String M",
"Some String N",
"Some String O"
],
"String For Key …我有两个方法func1和func2返回Optional.如果从func1返回的Optional具有值,则返回可选,否则调用func2并返回其Optional.一种方法是使用if-else.
Optional<MyObject> opt1 = func1();
if (opt1.isPresent()) {
return opt1;
}
return func2();
但是,我希望使用Java 8 Optional来实现它并避免使用它if-else.
就像是:
return Optional.of(obj1)
.flatMap_returnOptionalIfvaluePresent(func1)
.orElseReturnOptionalFromThis(func2)
任何人都可以建议一个好方法吗？
假设我有一组字符串到整数值的映射:
Map<HashSet<String>, Integer> map = new HashMap<>().
例如,mapis(我们假设没有重复的字符串):
{x,y} -> 2
{z} -> 3
{u,v,w} -> 4
如何使用Java 8 Stream API获取如下another_map类型:Map<String, Integer>
x -> 2
y -> 2
z -> 3
u -> 4
v -> 4
w -> 4
它看起来像一个flatMap操作,但是如何将Integer值与每个String键相关联？
我有一个包含多行文本的文本文件sherlock.txt.我使用以下命令将其加载到spark-shell中:
val textFile = sc.textFile("sherlock.txt")
我的目的是计算文件中的单词数.我遇到了两种替代方法来完成这项工作.
首先使用flatMap:
textFile.flatMap(line => line.split(" ")).count()
第二个使用map后跟reduce:
textFile.map(line => line.split(" ").size).reduce((a, b) => a + b)
两者都正确地产生相同的结果.我想知道上述两种替代实现的时间和空间复杂性的差异,如果确实存在的话？
scala解释器是否将两者都转换为最有效的形式？
我试图理解flatMap:flatMap(x->stream.of(x) )不平坦流和flatMap(x->x.stream())工作,并给出所需的结果.有人可以解释两者之间的区别吗？
import java.util.*;
import java.util.stream.*;
class TestFlatMap{
public static void main(String args[]){
List<String> l1 = Arrays.asList("a","b");
List<String> l2 = Arrays.asList("c","d");
Stream.of(l1, l2).flatMap((x)->Stream.of(x)).forEach((x)->System.out.println(x));
Stream.of(l1, l2).flatMap((x)->x.stream()).forEach((x)->System.out.println(x));
}
}
输出:
[a, b]
[c, d]
a
b
c
d
为什么以下语句对 有效.map()但对无效.flatMap()？
val tupled = input.map(x => (x*2, x*3))
//Compilation error: cannot resolve reference flatMap with such signature
val tupled = input.flatMap(x => (x*2, x*3))
不过这个说法没有问题：
val tupled = input.flatMap(x => List(x*2, x*3))
我有一个Bools数组,想要编辑一个Scores数组和一个Dates数组,其值为False.我无法理解.我想到了获取false的元素并使用该数组从score数组中删除这些元素,但我可以想象有一种直接的方法.
let hbiCompleteArray = [true, true, true, true, false, true, true, false, false]
let hbiScoreArray = [12, 12, 12, 12, 3, 13, 13, 2, 2]
我想要一个完整的HbiScores数组= [12,12,12,12,13,13]
我正在尝试使用flatmap与Stream API进行嵌套循环,但我似乎无法弄明白.作为示例,我想重新创建以下循环:
List<String> xs = Arrays.asList(new String[]{ "one","two", "three"});
List<String> ys = Arrays.asList(new String[]{"four", "five"});
System.out.println("*** Nested Loop ***");
for (String x : xs)
for (String y : ys)
System.out.println(x + " + " + y);
我可以这样做,但这看起来很难看:
System.out.println("*** Nested Stream ***");
xs.stream().forEach(x ->
ys.stream().forEach(y -> System.out.println(x + " + " + y))
);
Flatmap看起来很有前景,但是如何在外部循环中访问变量？
System.out.println("*** Flatmap *** ");
xs.stream().flatMap(x -> ys.stream()).forEach(y -> System.out.println("? + " + y));
输出:
*** Nested Loop ***
one + four
one + five
two + …我想要实现的是有条件地运行一系列可观察量.
return observable.map(response => response)
.flatmap(response1 => observable1(response1))
.flatmap(response2 => observable2(response2))
.flatmap(response3 => observable3(response3))
我需要检查response1并在需要时调用剩余的observable,否则我需要返回response1并中断执行,依此类推.
我已经完成了以下SO问题,但他们似乎没有回答我的问题
我是rxjs的新手,如果这个问题看起来太蹩脚,请原谅我.
任何帮助将不胜感激.
谢谢
我希望从java中的地图列表中获取最小值.我使用flatmap,stream和min的组合来做到这一点并没有得到预期的结果.这是代码公共类TestMin {
public static class TestHolder{
public static Map<String,Integer> getValues(){
Map<String,Integer> map = new HashMap<>();
map.put("a",1);
map.put("b",3);
map.put("c",2);
return map;
}
}
public static void main(String[] args) {
List<Map<String, Integer>> l = new ArrayList<>();
l.add(TestHolder.getValues());
l.add(TestHolder.getValues());
l.add(TestHolder.getValues());
// Getting min
int min = l.stream().map((m)->m.values()).flatMap((v)->v.stream()).min(Integer::min).get();
System.out.println(min);
}
}
输出为:2
当然,我期望的输出是1.尝试一些调试表明它提供的输出值对应于"c".即如果地图看起来像
[a->2 , b->3, c->1]
然后我得到的输出是1.问题是为什么它不是按值排序而是按键排序并为我提供意外的输出.