标签: java-stream

我有 2 个列表，比方说

1 -> List<Employee> list1;
2 -> List<Age> list2

class Employee {
    String name;
    String age;
    String address;
}

class Age {
    String name;
    String age;
}

我喜欢做的是我需要更换的年龄在所有记录员工列表随着年龄的年龄列表具有相同名称的两个。我如何在 Java 8 中实现这一目标？

我正在研究 Java8 中 Stream 和 Lambda 的用法。您将如何将 Stream 和 Lambda 应用于以下内容：使用 Stream 和 Lambda 打印出以下字符串中的奇数：“[3, 6, 8, 96, 7, 23]”。

我发现使用 for 循环和 parseInt 非常简单，但是如何实现流和 lambda。

我一直在 HackerRank 做一些练习测试，并在某个时候决定只使用流来解决它（作为个人挑战）。我做到了。程序工作一般。但是，当涉及到大量数据需要遍历时，程序需要很长时间才能完成。正因为如此，最终我没有解决测试，因为“因超时而终止:(”。我完全同意。当我在自己的 PC 上运行这个程序时，不仅需要很长时间才能完成，而且我的工作期间CPU温度暴涨...

这是我创建的代码：

List<Integer> duplicatesCount = arr.stream()
        .map(x -> Collections.frequency(arr, x))
        .collect(Collectors.toList());
OptionalInt maxDuplicate = duplicatesCount.stream().mapToInt(Integer::intValue).max();
Set<Integer> duplicates = arr.stream()
        .filter(x -> Collections.frequency(arr, x) == maxDuplicate.getAsInt())
        .collect(Collectors.toSet());
OptionalInt result = duplicates.stream().mapToInt(Integer::intValue).min();
return result.getAsInt();

谁可以给我解释一下这个？流通常会给 CPU 带来如此大的压力吗？还是只是这个程序？

附注。我上面提到的数据（这个程序无法处理的数据）有 73966 位从 1 到 5 的数字。如果这很重要或有人感兴趣......

我有以下嵌套的 for 循环，我需要将其转换为 JAVA 8 流 API 格式

for (EmpInfo empInfo : empInfos) {

  for (AddressInfo address : addressInfos) {

    if (address.getStreetNumber() != null 
      && empInfo.getStreetNumber() != null 
      && address.getStreetNumber().longValue() == empInfo.getStreetNumber().longValue()) {

      empInfo.setStreetName(address.getStreetName());
      empInfo.setStreetZipCode(address.getStreetZipCode());
    }
  }
}

有什么建议？

我有一个数组，想将大于 9 的元素乘以 2 且小于或等于 9 的元素乘以 3。

  List<Integer> list = Arrays.asList(3, 6, 9, 12, 15);
  list.stream().map(number -> number * 3).forEach(System.out::println); 

这个乘以 3 ，其中

list.stream().filter(number -> number>3).map(number -> number * 3).forEach(System.out::println);

这一乘法但也过滤器。

我想要 3 ,6 ,9 乘以 3 和 12, 15 乘以 2。

任何帮助表示赞赏。

我完全相信我的问题很简单，但我无法用流来做（如果有没有流的方法也会有帮助）假设我们有这个用户列表

public class Users {
   String firstName;
   String lastName;
   double accountBalance;
   String type;
   String extraField;
}

并假设我们的 List < Users > 中有以下数据

"Users": [{
            "firstName": "Scott",
            "lastName": "Salisbury",
            "accountBalance": "100",
            "type" : "A"
        }, {
            "firstName": "John",
            "lastName": "Richards",
            "accountBalance": "200",
            "type" :"C"

        }, {
            "firstName": "John",
            "lastName": "Richards",
            "accountBalance": "200",
            "type " : "C",
            "ExtraField": "Apply"
        }]

这里的预期结果是因为 firstName、lastName 和 type 在列表中出现两次，只需合并常见的结果，而不会丢失任何字段
预期输出

"Users": [{
            "firstName": "Scott",
            "lastName": "Salisbury",
            "accountBalance": "100",
            "type" : "A"
        }, {
            "firstName": "John",
            "lastName": …

对于以下 Java 7 代码，

public static boolean java8Test() {
    boolean flag = true;
    for(int i = 67 ; i < 79 ; i++) {
        if(!testBoolean(i)) {
            flag = false;
        }
    }
    return flag;
}

我想编写一个 Java8 代码来使用 java 8 功能对从 67 到 78（包括两者）的一系列数字执行 testBoolean 方法。

此外，java8Test()如果testBoolean返回 false，则应返回 false，但是对于给定数字范围内的所有数字，处理不应停止并继续。

我已经尝试过下面的代码，但是这段代码在返回我不想要的 false 后停止执行 testBoolean 方法。我希望继续执行并记住 java8Test 方法可以在所有数字范围执行后返回的错误标志

public static boolean java8Test() {
    return IntStream.range(67, 78+1).anyMatch(index -> !testBoolean(index));
}

private static boolean testBoolean(int index) {
    System.out.println(index + "\n");
    switch(index) …

reduce 方法在这里实际做什么？我已经阅读了 Oracle 文档，但我仍然不明白这个例子中的 reduce 方法在做什么

public static Coder findCoderWithWorstBMI(List<Coder> coders) {
    return coders.stream().sorted(Comparator.comparing(BMICalculator::calculateBMI))
            .reduce((first, second) -> second).orElse(null);
}

private static double calculateBMI(Coder coder) {
    double height = coder.getHeight();
    double weight = coder.getWeight();
    if (height == 0.0)
        throw new ArithmeticException();
    double bmi = weight / (height * height);
    return Math.round(bmi * 100) / 100.0;
}

我正在尝试将 Java 8 中的迭代代码块转换为函数式。函数式方法无法在共享的集合中找到匹配的消息。

List<Optional<Message>> allMessages = new ArrayList<>();

Set<Status> allStatuses = getAllStatuses();

//Iterative : Working
Set<StatusMessage> set = new HashSet<>(STATUS_MESSAGE.values());
for (StatusMessage statusMessage : set) {
    for (Status status : statusMessage.getStatusAndInfo().keySet()) {
        Optional<Message> message = MessageBuilder.createMessage(allStatuses, status, this::createMessage);
        if (message.isPresent()) {
            allMessages.add(message);
            break;
        }
    }
}

//Functional : Not working  - Never adds anything to the 
//map even when matching status is present
STATUS_MESSAGE.values().stream()
        .distinct()
        .map(statusMessage -> statusMessage.getStatusAndInfo().keySet())
        .flatMap(Collection::stream)
        .map(key -> MessageBuilder.createMessage(allStatuses, key, this::createMessage))
        .anyMatch(allMessages::add);

该MessageBuilder.createMessage如下所示：

Optional<Status> …

在处理 Java 流时，我们可以使用收集器来生成诸如流之类的集合。

例如，这里我们制作了一个Month枚举对象的流，并为每个对象生成一个String保存月份的本地化名称的流。我们通过调用 将结果收集到 a Listof 类型中。StringCollectors.toList()

List < String > monthNames = 
        Arrays
        .stream( Month.values() )
        .map( month -> month.getDisplayName( TextStyle.FULL , Locale.CANADA_FRENCH ) )
        .collect( Collectors.toList() )
;

monthNames.toString(): [janvier, février, mars, avril, mai, juin, juillet, août, septembre, octobre, novembre, décembre]

为了使该列表不可修改，我们可以List.copyOf在 Java 10 及更高版本中调用。

List < String > monthNamesUnmod = List.copyOf( monthNames );

? 有没有办法让带有收集器的流生成不可修改的列表，而我不需要包装对 的调用List.copyOf？