小编shm*_*sel的帖子

我目前有一个多层结构数据,如下所示:

行业类有一个Set<Company>可以为null 的私有字段.

公司类有一个Set<Division>可以为null 的私有字段.

Division类有一个Set<Group>可以为null 的私有字段.

组类有一个私有字段groupName,可以为null,可以使用getter(getGroupName())检索.

我试图将Industry的一个实例流式传输到Group层,并将所有groupName连接成一个String,其间带有"/".

如果此Industry实例不包含任何groupName,则返回字符串"null".

根据我对Java 8的有限知识,我想这样编码:

industry.stream()
     .flatmap(industry -> industry.getCompanies().stream())
     .filter(Objects::nonNull)
     .flatmap(company -> company.getDivisions().stream())
     .filter(Objects::nonNull)
     .flatmap(division -> division.getGroups().stream())
     .map(group -> group.getGroupName)
     .collect(Collectors.joining("/")));

这段代码似乎有些瑕疵.另外,我不知道在哪里添加声明,如果Industry无法检索任何groupName,而不是将所有groupName连接成一个字符串,只需返回一个字符串"null".

在我的情况下使用Java 8流的正确方法是什么？

谢谢.

我有以下内容:

List<String> keys
List<String> values

我想将这两个列表映射到Map<String, String>使用Java 8 Streams.列表具有相同的大小并以相同的方式排序.

我尝试用以下方法映射这两个

Map<String, String> result= keys.stream().
        collect(Collectors.toMap(keys::get, values::get));

但这根本不起作用 - 我怎么能这样做呢？提前致谢 :)

如何将有限的事Stream<Thing>物流变成无限重复的事物流？

我有一个昂贵的方法，我只想在流中必要时调用它。这是一个例子：

public static Optional<MyObject> findTarget(String input, List<MyObject> myList) {
    return Stream.concat(myList.stream(), expensive().stream()).filter(o -> o.hasName(input)).findFirst();
}

目标是根据值MyObject找到目标，但如果它不在ONLY 中，那么它将调用返回更大的列表并从那里查找。myListinputmyListexpensive()

上面的示例没有这样做，因为它似乎在Stream.concat消耗expensive()所有myList.

我能想到的一个丑陋的解决方案是分两步完成，例如：

return myList.stream().filter(o -> o.hasName(input)).findFirst().or(
    () -> expensive().stream().filter(o -> o.hasName(input)).findFirst());

但随后我将不得不重复过滤器和其余部分两次。

有没有更好的解决方案，甚至是单个 Stream 衬里可以做到这一点？

我想使用流从类型B创建类型A的集合.

假设我有两个班级

Class Employee{
   String firstName;
   String lastName;
   int age;
   String id;
   String email;
   double salary;
}

Class Person {
  String firstName;
  String lastName;
  String email;
}

要从Employee的集合创建Person的集合,我写下面的代码

public static List<Person> createPersonsFromEmployees(List<Employee> employees) {

        List<Person> persons = new ArrayList<>();

        employees.stream().filter(Object :: nonNull)
                  .forEach(e -> {
                       persons.add(new Person(e.getFirstName(),
                                           e.getLastName(), 
                                           e.getEmail());
                   };)


        return persons;
}

目前,这段代码有效.但我想知道,想知道是否有更好的方法来创建的集合Person,从Employee没有使用forEach.

public Double getUnitsBefore(Date recordDate) {
    double eligibleUnits = 0;
    ageBucket.forEach((dateStr, units) -> {
        try {
            Date date = DFT.parse(dateStr);
            if (date.before(recordDate)) {
                //TODO These are eligible units for dividend.
                eligibleUnits = eligibleUnits + units.doubleValue();    //TODO 
            }

        } catch(ParseException e) {
            e.printStackTrace();
        }
    });

    return eligibleUnits;
}

• 如您所知，行在eligibleUnits = eligibleUnits + units.doubleValue();Java 8 中无法编译。我如何实现这一目标？我只需要在日期在记录日期之前求和。

我即将从字符串创建二维数组:

char[][] chars;
String alphabet = "abcdefghijklmnopqrstuvwxyz";

所以数组将说明这个矩阵:

但是我怎么能用Java 8 Streams做到这一点,因为我不想通过休闲循环来做到这一点？

我正在尝试自学如何在Java中使用lambda表达式而不是常规的外部迭代类型解决方案.我做了一个简短的程序,我使用整数流并为它们分配等级字母.我没有使用典型的"switch"语句,而是使用了这些lambda表达式.有什么办法可以简化吗？似乎有更好的方法来做到这一点.它有效,但看起来并不整洁.

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 90)
          .forEach(x -> System.out.println(x + " -> A"));

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 80 && x <= 89)
          .forEach(x -> System.out.println(x + " -> B"));

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 70 && x <= 79)
          .forEach(x -> System.out.println(x + " -> C"));

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 60 && x <= 69)
          .forEach(x -> System.out.println(x + " -> D"));

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 50 && x <= 59) …

我希望以前没有问过这个问题.在java 8中,我myArray在输入中有一个String数组和一个整数maxLength.我想计算我的数组中的字符串数小于maxLength.我想使用流来解决此问题.

为此,我想这样做:

int solution = Arrays.stream(myArray).filter(s -> s.length() <= maxLength).count();

但是我不确定这是否是正确的方法.它需要经过第一个数组,然后通过过滤后的数组进行计数.

但是如果我不使用流,我可以轻松地制作一个算法,我在myArray上循环一次.

我的问题很简单:有没有办法用相同的时间性能来解决这个问题而不是循环？它总是一个使用流的"好"解决方案吗？

我正在使用 Java 8 以及包中的 Map、Reduce、Collect API java.util.stream。我有一个用例，我需要对列表的列表进行垂直求和。我的列表的结构是List<List<Integer>> 我想不出一种方法可以使用映射压缩内部列表，并减少或收集流上可用的操作。考虑以下代码。假设我的列表名为transactions. 此交易存储的是内部列表中每个商品的每笔交易中售出的商品数量。内部清单的长度对于所有交易都是相同的，因为它包含库存中每一项的一个条目。如果该项目未参与交易，则仅存储 0。

我在想一些关于

transaction.stream().map(
      /*Try and put sum into an accumulator List*/
).collect(
      /*Collect entries into a list*/
)

我只是不知道如何在代码中实现这一点。网络上的所有资源都是简单的示例，不适用于集合对象。任何指示/提示将不胜感激。