我使用Java 8流尝试了以下代码:
Arrays.asList("A", "B").stream()
.flatMap(s -> Arrays.asList("X", "Y").stream().map(s1 -> s + s1)).collect(Collectors.toList());
我得到的是List<Object>我想要的一段时间List<String>.如果我删除收集,我尝试:
Arrays.asList("A", "B").stream().flatMap(s -> Arrays.asList("X", "Y").stream().map(s1 -> s + s1));
我正确得到了Stream<String>.
我哪里错了？有人能帮我吗？
提前谢谢了.
编辑:
问题是由于Eclipse(现在使用Kepler SR2和java 8补丁1.0.0.v20140317-1956).如果使用javac进行编译,或者如Holger所评论,使用Netbeans进行编译,则不会出现此问题
我有这个方法:
public static long sumDigits(final List<Long> list) {
return list
.stream()
.map(l -> toDigits(l))
.flatMapToLong(x -> x.stream())
.sum()
}
toDigits有这个签名:
List<Long> toDigits(long l)
在flatMapToLong行上,它给出了这个错误
类型不匹配:无法从Stream <Long>转换为LongStream
当我改为
flatMapToLong(x -> x)
我收到这个错误
类型不匹配:无法从List <Long>转换为LongStream
唯一有效的是这个
public static long sumDigits(final List<Long> list) {
return list
.stream()
.map(l -> toDigits(l))
.flatMap(x -> x.stream())
.reduce(0L, (accumulator, add) -> Math.addExact(accumulator, add));
}
双方map并flatMap都defind上ImplicitlyUnwrappedOptional,但他们根据不同的文件(显然)在他们的定义:
func map(f:@noescape(T) - > U) - > U!
如果self == nil,则返回nil.否则,返回f(self!).
func flatMap(f:@noescape(T) - > U!) - > U!
返回f(自我)!iff self和f(self)不是nil.
我尝试使用它们的一个简单示例:
let number: Int? = 1
let res1 = number.map { $0 + 1 }.map { $0 + 1 }
let res2 = number.flatMap { $0 + 1 }.flatMap { $0 + 1 }
res1 //3
res2 //3
但是,他们生产的相同的结果,即使number是nil.
我的问题是,它们之间有什么实际的区别,如果我申请map或flatMap到ImplicitlyUnwrappedOptionalS' 我应该选择哪一个以及何时？
对于学校的编码工作,我必须做平板图的工作,但我完全不知道它做了什么,我已经在网上阅读了几页,并在我的教科书中阅读,但我仍然没有真正理解它的作用.我知道地图有什么作用,但由于某种原因,我很难将头部包裹在flatmap中.有人可以帮忙吗？谢谢.
只是为了添加更多信息 - 当我在线查看示例时,我会看到flatmap如何返回与地图不同的内容.但是当flatmap被调用时,它实际上在做什么呢？flatmap如何实际工作？它在返回结果之前做了什么？
例如,
Vector(Some(1), Some(2), Some(3), None).flatMap{
n => n
}
产生一个Vector(1, 2, 3)而不是给出一个错误.正如我在其他语言中看到的那样,flatMap当你有一个生成嵌套的mapper函数时使用,所以我希望这是一个有效的flatMap:
Vector(1, 2, 3).flatMap{
eachNum => Vector(eachNum)
}
我的mapper函数产生一个Vector会导致嵌套(即Vector(Vector(1), Vector(2), Vector(3), Vector(4))),如果我使用了一个map由于容器包装.但是,flatMap将删除此嵌套并将其展平.当有两个相同的monad嵌套时,这是有意义的.
但是,我不明白如何使用一个flatMapmapper函数返回一个Optionmake Vector[Option[Int]]成为a Vector[Int].是否存在某种转变(我以前从未见过这种转变),有人可以解释并且可能指向我一些资源吗？
非常感谢你
根据这个线程, conCatMap和flatmap仅根据项目的发射顺序而不同.所以我做了一个测试并创建了一个简单的整数流,并希望看到它们将以什么顺序发出.我制作了一个小的可观察量,它将在1-5的范围内取数,并将它们乘以2.简单.
以下是flatmap的代码:
myObservable.flatMap(new Func1<Integer, Observable<Integer>>() {
@Override
public Observable<Integer> call(Integer integer) {
return Observable.just(integer * 2);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
Log.v("myapp","from flatMap:"+integer);
}
});
和使用concatMap完全相同的代码:
myObservable.concatMap(new Func1<Integer, Observable<Integer>>() {
@Override
public Observable<Integer> call(Integer integer) {
return Observable.just(integer * 2);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void …结构
我尝试在dotSwift 2016 Demo中重新创建Chris Edihoff演示的代码.这是代码.
struct List {
let name:String
let id:Int
}
extension List {
init?(json: [String:AnyObject]) {
guard
let name = json["name"] as? String,
let id = json["id"] as? Int else
{
return nil
}
self.name = name
self.id = id
}
}
let listData = json["data"] as? [[String:AnyObject]]
到目前为止,一切似乎都很好.但这就是问题所在.他做了这样的事情:
let list:[List] = listData.flatMap(List.init)
上面的行应该是返回列表对象的数组.Chris Edihoff似乎没有遇到任何问题,但是当我这样做时,Xcode警告说
- flatMap生成'U？',而不是预期的上下文结果类型'_？
还有什么在List.init这里？我从未见过这种初始化对象的方式.它应该是List()或者如果我们在这里使用客户初始化,那应该是List(json:someObject)对的吗？
参考Chris Edihof讲座:https://www.youtube.com/watch？v = ewk-XNzXzAA
在我目前正在进行的项目中,我们有三个嵌套for循环的构造:
List<OutputDataType> resultList = new ArrayList<>();
for (OrgStructureEntity product : products) {
for (String region : regions) {
for (SalesType salesType : SalesType.values()) {
resultList.addAll(new SalesRequest(getConnection(),
product.getProductMainGroup(), product.getSbu(), planYear, currentPeriod, region, salesType,
exchangeRates).calculateSalesKpis());
}
}
}
产品和地区都是套装.resultList是一个带有"OutputDataType"对象的ArrayList.方法calculateSalesKpis()还返回"OutputDataType"对象的列表.应该将所有这些对象添加到resultList中.我想用并行流完成所有这些以使其更快,但我没有比这更进一步:
products.stream()
.map(product -> regions.stream()
.map(region -> Arrays.stream(SalesType.values())
.map(salesType -> new SalesRequest(getConnection(),
product.getProductMainGroup(), product.getSbu(), planYear, currentPeriod, region, salesType,
exchangeRates).calculateSalesKpis())))
.
我现在不知道如何将它全部放在结果列表中以及如何正确关闭流.我希望你能帮帮我 :)
我想知道两种平面图之间是否存在任何显着差异.
情况1:
someCollection
.stream()
.map(CollectionElement::getAnotherCollection)
.flatMap(Collection::stream);
案例2:
someCollection
.stream()
.flatMap(element -> element.getAnotherCollection().stream());
应该首选哪一个？在性能方面有哪些更好？
我有一组按顺序完成的操作,但如果中间序列返回"null",我想提前中止操作(跳过后续步骤).
我编造了这样其给定的输入参数的功能,执行对Redis的几个操作,如果它存在,会返回一个产品.由于其中一个中间请求可能返回空值,因此完整的操作可能会"失败",并且我希望将之后发生的不必要的步骤短路.
这里的筑巢变得疯狂,我想让它更清晰.是否有适当的"功能"方式来执行此类"if/else"短路？
def getSingleProduct(firstSku: String): Option[Product] = {
val jedis = pool.getResource
val sid: Array[Byte] = jedis.get(Keys.sidForSku(firstSku, sectionId, feedId).getBytes)
Option(sid).flatMap {
sid: Array[Byte] =>
Option(jedis.get(Keys.latestVersionForSid(sectionId, feedId, sid))) flatMap {
version: Array[Byte] =>
Option(Keys.dataForSid(sectionId, feedId, version, sid)) flatMap {
getDataKey: Array[Byte] =>
Option(jedis.get(getDataKey)) flatMap {
packedData: Array[Byte] =>
val data = doSomeStuffWith(packedData)
Option(Product(data, "more interesting things"))
}
}
}
}
}