标签: java-stream

想象一下,我有一个List<Map<String,Object>>:

[{'id':1,'name':'xyz'},{'id':2,'name':'abc'},{'id':3,'name':'pqr'}]

我需要生成另一个列表,包括上面列表中的名称:

List<String>

避免使用循环,是否可以通过使用java stream api来实现这一点？

有人可以解释复杂Comparators的以下变体之间的区别吗？

List<String> listOfStrings = Arrays.asList("algo", "test", "is", "a", "common");

listOfStrings.stream()
             .sorted(Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()))
             .sorted(Comparator.naturalOrder().thenComparing(Comparator.comparingInt(String::length))
             .forEach(System.out::println);

为什么第一次调用sorted是可以的,而第二次调用甚至无法编译？

我是并行流的新手,并试图制作一个计算值*100(1到100)并将其存储在地图中的示例程序.在执行代码时,每次迭代都会有不同的数量.我可能在某个地方错了所以请指导我,任何人都知道正确的方法.

代码:

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.stream.Collectors;

public class Main{    
    static int l = 0;       
    public static void main (String[] args) throws java.lang.Exception {
        letsGoParallel();
    }       
    public static int makeSomeMagic(int data) {
        l++;
        return data * 100;
    }        
    public static void letsGoParallel() {
        List<Integer> dataList = new ArrayList<>();
        for(int i = 1; i <= 100 ; i++) {
            dataList.add(i);
        }
        Map<Integer, Integer> resultMap = new HashMap<>();
        dataList.parallelStream().map(f -> {
            Integer xx = 0;
            {
                xx = …

当我进行测试时,我遇到了流的问题.

代码如下:

public class HelloWorld {
    public static void main(String []args) {

    List<Integer> integers = Arrays.asList(-2, -5, -7, -16);
    Integer integer = integers.stream().max(Math::max).orElse(0);
    System.out.println(integer);

    }
} 

返回值为-15,即列表中的最小数字.但是当我将max()更改为min()时,它会返回最大值.为什么？

我有以下代码

final String arr[] = {"A", "B", "C", "D"};
final List<String> list1 = new ArrayList<>();
final List<String> list2 = Arrays.asList(arr).parallelStream()
                          .peek(s -> list1.add(s + s))
                          .map(s -> s + s)
                          .collect(Collectors.toList());
System.out.println(list1);
System.out.println(list2);

我得到以下结果:

[null, AA, DD, null]
[AA, BB, CC, DD]

为什么有些元素null在list1 中显示？我知道我应该使用SynchronizedList带parallelStream,但null值是令我感到诧异.一旦你向列表中添加了一些应该设置插槽的东西,下一次执行就应该为它添加另一个值.

我有一个这样定义的类:

public class Item {

    String name;
    double price;
}

现在我有一个Item对象列表,现在我想找到所有项目的总价.我们怎样才能在Java 8中做到这一点？

如果列表是简单的整数,那么我们在这里给出了解决方案 - 如何用java流汇总整数列表？

HistoryRecord类:

public class DataHistoryRecord {

Long dataCreatedBy;
Long dataModifiedBy;
getters & setters

}

我有List<DataHistoryRecord>,我想用HashSet它创造独特dataCreatedBy和dataModifiedByid.

例如:如果列表有以下两条记录:

HistoryRecord1 with createdBy:1和modifiedBy:2

HistoryRecord2 with createdBy:1和modifiedBy:3

输出HashSet应该有三个值; 1,2,3

注意:请建议没有foreach的方法

我正在尝试编写一个表达式,从缓存中获取数据(它们返回一个List)并将所有内容收集在一起.

我提出了:

List<myDto> myJointSnapshot = cachesMap.values().stream()
  .flatMap(c->c.getSnapshot()).collect(Collectors.toList());

其中getSnapshot还返回List <myDto>.

这给了我一个错误:没有类型变量R的实例存在,所以List <myDto>符合Stream <？扩展R>

我怎样才能将表达式更正为有效？

计算MyDTO,Java 8中amountField的总和

private Double getSum(List<MyDTO> myDTOList) {
    return myDTOList.stream().map(MyDTO::getAmount).reduce(0d, Double::sum);
}

以下代码导致死锁(在我的电脑上):

public class Test {
    static {
        final int SUM = IntStream.range(0, 100)
                .parallel()
                .reduce((n, m) -> n + m)
                .getAsInt();
    }

    public static void main(String[] args) {
        System.out.println("Finished");
    }
}

但是,如果我reduce用匿名类替换lambda参数,它不会导致死锁:

public class Test {
    static {
        final int SUM = IntStream.range(0, 100)
                .parallel()
                .reduce(new IntBinaryOperator() {
                    @Override
                    public int applyAsInt(int n, int m) {
                        return n + m;
                    }
                })
                .getAsInt();
    }

    public static void main(String[] args) {
        System.out.println("Finished");
    }
}

你能解释一下这种情况吗？

PS

我发现代码(与以前有点不同):

public class …