我正在使用java lambda对列表进行排序.
我怎样才能以相反的方式对它进行排序？
我看到这篇文章,但我想使用java 8 lambda.
这是我的代码(我使用*-1)作为黑客
Arrays.asList(files).stream()
.filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
.sorted(new Comparator<File>() {
public int compare(File o1, File o2) {
int answer;
if (o1.lastModified() == o2.lastModified()) {
answer = 0;
} else if (o1.lastModified() > o2.lastModified()) {
answer = 1;
} else {
answer = -1;
}
return -1 * answer;
}
})
.skip(numOfNewestToLeave)
.forEach(item -> item.delete());
为了尝试深入理解java流和分裂器,我对spliterator特性有一些微妙的问题:
Q1:Stream.empty()vsStream.of()(没有args的Stream.of())
Stream.empty():SUBSIZED,SIZEDStream.of(): SUBSIZED,IMMUTABLE,SIZED,ORDERED为什么Stream.empty()没有相同的特征Stream.of()？请注意,与Stream.concat()(特别是没有ORDERED)一起使用时会产生影响.我会说不Stream.empty()应该只有IMMUTABLE和ORDERED,还有DISTINCT和NONNULL.也很有意义Stream.of()仅具有一个参数DISTICT.
Q2:LongStream.of()没有NONNULL
刚注意到NONNULL不可用LongStream.of.不是NONNULL所有LongStreams,IntStreams和DoubleStreams 的主要特征吗？
Q3:LongStream.range(,)vsLongStream.range(,).boxed()
LongRange.range(,):SUBSIZED,IMMUTABLE,NONNULL,SIZED,ORDERED,SORTED ,DISTINCTLongStream.range(,).boxed():SUBSIZED,SIZED,ORDERED为什么.boxed()失去所有这些特征？它不应该失去任何.
我明白.mapToObj()可以失去NONNULL,IMMUTABLE和DISTICT,但.boxed()......没有意义.
Q4:.peek()输掉IMMUTABLE和NONNULL
LongStream.of(1): …
我已经阅读过这个和这个问题,但仍然怀疑Stream.skipJDK作者是否打算观察到这种行为.
让我们简单输入数字1..20:
List<Integer> input = IntStream.rangeClosed(1, 20).boxed().collect(Collectors.toList());
现在让我们创建一个并行流,以不同的方式结合unordered()使用skip()并收集结果:
System.out.println("skip-skip-unordered-toList: "
+ input.parallelStream().filter(x -> x > 0)
.skip(1)
.skip(1)
.unordered()
.collect(Collectors.toList()));
System.out.println("skip-unordered-skip-toList: "
+ input.parallelStream().filter(x -> x > 0)
.skip(1)
.unordered()
.skip(1)
.collect(Collectors.toList()));
System.out.println("unordered-skip-skip-toList: "
+ input.parallelStream().filter(x -> x > 0)
.unordered()
.skip(1)
.skip(1)
.collect(Collectors.toList()));
过滤步骤在这里基本没什么,但为流引擎增加了更多的难度:现在它不知道输出的确切大小,因此关闭了一些优化.我有以下结果:
skip-skip-unordered-toList: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
// absent values: 1, 2
skip-unordered-skip-toList: …这是一个例子:代码A:
files.forEach(f -> {
//TODO
});
和另一个代码B可以这样使用:
files.stream().forEach(f -> { });
两者之间有什么区别,有stream()没有stream()？
是否有一个操作的任何保证连续和有序流的处理,在遭遇订单？
我的意思是,如果我有这样的代码:
IntStream.range(0, 5)
.map(i -> {
myFunction(i);
return i * 2;
})
.boxed()
.collect(toList());
是否有保证,它将以生成范围的遭遇顺序执行myFunction()调用？
我找到了Stream类的JavaDocs草案,明确说明了这一点:
对于顺序流管道,如果管道源具有已定义的遭遇顺序,则所有操作都以管道源的遭遇顺序执行.
但在官方JavaDocs中,这一行被删除了.它现在仅讨论所选方法的遭遇顺序.该包装java.util.stream文档的副作用款规定:
即使管道被约束以产生与流源的遭遇顺序一致的结果(例如,
IntStream.range(0,5).parallel().map(x -> x*2).toArray()必须产生[0, 2, 4, 6, 8]),也不保证将映射器函数应用于各个元素的顺序,或者什么线程为给定元素执行任何行为参数.
但它没有说明顺序流,而且这个例子是针对并行流的(我的理解是顺序流和并行流都是如此,但这是我不确定的部分).
另一方面,它也在订购部分说明:
如果订购了流,则大多数操作都被约束为对其遭遇顺序中的元素进行操作; 如果流的源是
List包含的[1, 2, 3],那么执行的结果map(x -> x*2)必须是[2, 4, 6].但是,如果源没有定义的遭遇顺序,则值的任何排列[2, 4, 6]都将是有效结果.
但这一次它以"对元素进行操作"开始,但是示例是关于产生的流,所以我不确定它们是否会考虑副作用,副作用实际上就是这个问题.
假设我有这个自定义收藏家:
public class CustomToListCollector<T> implements Collector<T, List<T>, List<T>> {
@Override
public Supplier<List<T>> supplier() {
return ArrayList::new;
}
@Override
public BiConsumer<List<T>, T> accumulator() {
return List::add;
}
@Override
public BinaryOperator<List<T>> combiner() {
return (l1, l2) -> {
l1.addAll(l2);
return l1;
};
}
@Override
public Function<List<T>, List<T>> finisher() {
return Function.identity();
}
@Override
public Set<java.util.stream.Collector.Characteristics> characteristics() {
return EnumSet.of(Characteristics.IDENTITY_FINISH, Characteristics.UNORDERED);
}
}
这正是Collectors#toList实现的一个细微差别:还添加了UNORDERED特性.
我会假设运行此代码:
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
for (int i = 0; …我正在创建多个流,我必须并行(或可能并行)访问.我知道如何在编译时修复资源量时尝试使用资源,但是如果资源量由参数确定怎么办？
我有这样的事情:
private static void foo(String path, String... files) throws IOException {
@SuppressWarnings("unchecked")
Stream<String>[] streams = new Stream[files.length];
try {
for (int i = 0; i < files.length; i++) {
final String file = files[i];
streams[i] = Files.lines(Paths.get(path, file))
.onClose(() -> System.out.println("Closed " + file));
}
// do something with streams
Stream.of(streams)
.parallel()
.flatMap(x -> x)
.distinct()
.sorted()
.limit(10)
.forEach(System.out::println);
}
finally {
for (Stream<String> s : streams) {
if (s != null) {
s.close();
}
}
}
}
当我最初问这个问题,2015年2月,在报道的行为所链接的问题是反直觉的,但那种规范允许(尽管在文档一些小的矛盾).
然而,Tagir Valeev在2015年6月问了一个新问题,我认为他清楚地证明了这个问题中报告的行为实际上是一个错误.Brain Goetz回答了他的问题,并承认,当一个终端操作触发时,不会阻止on 的特性的反向传播是一个错误,这个终端操作不会被迫尊重元素的遭遇顺序(例如) .此外,在他自己的回答的评论中,他分享了JDK的错误跟踪系统中发布的问题的链接.UNORDEREDStreamskip()forEach()
该问题的状态现已解决,其修复版本为9,这意味着该修复程序将在JDK9中可用.但是,它也被反向移植到JDK8 update 60,build 22.
所以从JDK8u60-b22开始,这个问题再也没有意义了,因为现在skip()表现得像直觉一样,甚至在并行流上也是如此.
我原来的问题是......
最近我和一些同事讨论了这件事.我说skip()在并行流上使用它是没用的,因为它似乎没有一个很好的用例.他们告诉我有关性能提升,FJ池处理,jvm可用的核心数量等等,但他们无法给我任何实际的使用示例.
skip()并行流是否存在良好的用例？
我有这个文件:
Line1.
Line2.
Line3.
Line4.
我想从第二行(Line2)开始阅读,直到文件结束.我怎么能用Java做到这一点？