我对Java 8中的以下构造感到好奇:
double[] doubles = //...
double sum = DoubleStream.of(doubles).parallel().sum();
切入追逐:
sum始终相同,例如在不同的计算机上运行时？更多背景......
浮点运算是有损的,并且(与实值运算不同)不是关联的.因此,除非注意工作如何分割和重新组合,否则可能导致不确定的结果.
我很高兴地发现这种sum()方法采用了Kahan Summation.这显着减少了错误,但仍未提供精确的*结果.
在我的测试中,重复调用似乎每次返回相同的结果,但我想知道我们可以安全地假设它是多么稳定.例如:
我很高兴在每台计算机上采用相同的JVM版本.
这是我掀起的一项测试:
public static void main(String[] args) {
Random random = new Random(42L);
for (int j = 1; j < 20; j++) {
// Stream increases in size and the magnitude of the values at each iteration.
double[] doubles = generate(random, j*100, j);
// Like a simple for loop
double sum1 = DoubleStream.of(doubles).reduce(0, …我有一个java 8流循环,其中包含以下内容:
void matchSellOrder(Market market, Order sellOrder) {
System.out.println("selling " + market.pair() + " : " + sellOrder);
market.buyOrders()
.stream()
.filter(buyOrder -> buyOrder.price >= sellOrder.price)
.sorted(BY_ASCENDING_PRICE)
.forEach((buyOrder) -> {
double tradeVolume = Math.min(buyOrder.quantity, sellOrder.quantity);
double price = buyOrder.price;
buyOrder.quantity -= tradeVolume;
sellOrder.quantity -= tradeVolume;
Trade trade = new Trade.Builder(market, price, tradeVolume, Trade.Type.SELL).build();
CommonUtil.convertToJSON(trade);
if (sellOrder.quantity == 0) {
System.out.println("order fulfilled");
// break loop there
}
});
}
当满足某些条件时,如何摆脱循环？什么是正确的关闭流的方式？
UPDATE
我误用了流tecnique,假设它是一个循环,它不是为此而设计的.这是我最终使用以下答案提供的代码:
List<Order> applicableSortedBuyOrders = market.buyOrders()
.stream()
.filter(buyOrder -> buyOrder.price >= sellOrder.price) …我想将两个Java-8-Streams一起迭代,以便我在每次迭代中都有两个参数.像这样的东西,somefunction产生类似的东西Stream<Pair<A,B>>.
Stream<A> as;
Stream<B> bs;
somefunction (as, bs)
.forEach ((a, b) -> foo (a, b));
// or something like
somefunction (as, bs)
.forEach ((Pair<A, B> abs) -> foo (abs.left (), abs.right ()));
我想知道,如果Java提供类似的东西,虽然Pair在Java中没有:-(如果没有像这样的API函数,是否有另一种方式同时迭代两个流？
我有一种感觉,我在这里遗漏了一些东西.我发现自己做了以下事情
private static int getHighestValue(Map<Character, Integer> countMap) {
return countMap.values().stream().mapToInt(Integer::intValue).max().getAsInt();
}
我的问题是从愚蠢的转换Stream到 IntStream通过mapToInt(Integer::intValue)
有没有更好的转换方式？这一切都是为了避免使用max()从Stream,这需要传递一个Comparator但问题是专门对的皈依Stream到IntStream
我想知道是否有替代方案
List<X> lastN = all.subList(Math.max(0, all.size() - n), all.size());
用流？
我有以下集合类型:
Map<String, Collection<String>> map;
我想map.size()从每个Key的集合中的单个值创建每个组的唯一组合.
例如,假设地图如下所示:
A, {a1, a2, a3, ..., an}
B, {b1, b2, b3, ..., bn}
C, {c1, c2, c3, ..., cn}
我希望获得的List<Set<String>>结果是一个结果,看起来类似于(排序并不重要,它只需要是一个由所有可能的组合组成的'完整'结果):
{a1, b1, c1},
{a1, b1, c2},
{a1, b1, c3},
{a1, b2, c1},
{a1, b2, c2},
{a1, b2, c3},
...
{a2, b1, c1},
{a2, b1, c2},
...
{a3, b1, c1},
{a3, b1, c2},
...
{an, bn, cn}
这基本上是一个计数问题,但我想看看是否可以使用Java 8流解决方案.
我试图用代替位掩码来代码
public static Set<Amenities> fromBitFlags(int bitFlag) {
return ALL_OPTS.stream().filter(a -> (a.ameityId & bitFlag) > 0).collect(Collectors.toSet());
}
我想返回EnumSet而不是简单的集合(不要因为转换而放弃EnumSet的实用性).
需要一些有关如何创建自定义收集器以收集EnumSet的说明.
我在这个论坛和谷歌搜索后发布我的查询,但无法解决相同问题.例如:Link1 Link2 Link3
我试图根据列表1中的值过滤列表2(多列).
List1:
- [Datsun]
- [Volvo]
- [BMW]
- [Mercedes]
List2:
- [1-Jun-1995, Audi, 25.3, 500.4, 300]
- [7-Apr-1996, BMW, 35.3, 250.2, 500]
- [3-May-1996, Porsche, 45.3, 750.8, 200]
- [2-Nov-1998, Volvo, 75.3, 150.2, 100]
- [7-Dec-1999, BMW, 95.3, 850.2, 900]
expected o/p:
- [7-Apr-1996, BMW, 35.3, 250.2, 500]
- [2-Nov-1998, Volvo, 75.3, 150.2, 100]
- [7-Dec-1999, BMW, 95.3, 850.2, 900]
码
// List 1 in above eg
List<dataCarName> listCarName = new ArrayList<>();
// List 2 …我Stream处理了几百万个元素.它背后的Map-Reduce算法需要几毫秒,因此任务完成大约需要20分钟.
Stream<MyData> myStream = readData();
MyResult result = myStream
.map(row -> process(row))
.peek(stat -> System.out.println("Hi, I processed another item"))
.reduce(MyStat::aggregate);
我想要一种显示整体进度的方法,而不是每个元素打印一行(这导致每秒数千行,需要时间,并且不提供有关整体进度的任何有用信息).我想展示类似于:
5% (08s)
10% (14s)
15% (20s)
...
最好(和/或最简单)的方法是什么？
如果我在顺序流上调用collect(例如,从调用Collection.stream()),那么它将使用我传递的汇编器参数来收集吗？我猜不是,但我在文档中看不到任何内容.如果我是正确的,那么不得不提供我知道不会被使用的东西(如果我知道它是顺序流)似乎是不幸的.