标签: java-stream

问题:通过lambda表达式解决以下问题.给定一个字符串列表,创建一个地图

Key=Integer(string.length)
value=List

如果两个字符串与长度匹配,则创建所有此类匹配字符串长度的列表.

我不知道如何为流中所有匹配的字符串长度创建列表!我尝试了以下方式,这给了我重复键的例外,这很明显.

private static void changeToMap(List<String> listString)
{
    Map<Integer, String> map=listString.stream().collect(Collectors.toMap(x->x.toString().length(),x->x));
    System.out.println(map);        
}

假设我有3辆汽车,每辆汽车有3个发动机,每个发动机有3个零件.如何map of <engine_model, List<parts>>使用Java8流创建一个？

在常规Java中,我会执行以下操作:

Map<String, List<Parts>> map = new HashMap<String, List<Parts>>();
for (Car car: cars){
  for (Engine engine: car.getEngines()){
    if (!map.contains(engine.getModel())){
      map.put(engine.getModel(), new ArrayList<Part>());
    }
    for (Part  part: engine.getParts()){
      map.get(engine.getModel()).add(part);
    }
  }
}

这map是一个map将引擎的model(type String)映射到与该模型相关的所有部件的列表.不同的车可以有相同的发动机型号.

我试着做以下事情:

carList.stream().flatMap(p -> p.getEngines().stream())
  .collect(Collectors.groupingBy(p -> p.getModel(),
               Collectors.mapping(Engine::getParts, Collectors.toList())))

问题是上面的使用我得到了 Map<String, List<List<Part>>> 我想要的 Map<String, List<Part>>

我想一个等效的问题是:我怎么改变List of Lists,只是List在上面的例子中的情况下？

我有一张地图:

Map<String, Map<Integer, List<Integer>>>
e.g. Map<Name, Map<Id, List<ReferenceId>>>

Outcome:
List<Id>
List<ReferenceId>

我想将这个地图转换成两个整数列表.一个列表包含内部映射键,另一个列表包含内部映射值(即List<Integer>)

任何人都可以告诉我如何使用流在Java 8中执行此操作？

我试过这种方式但得到了Cast Exception,无法将String转换为Integer.

map.values().stream()
    .map(m -> m.entrySet()
    .stream()
    .map(e -> e.getKey())
    .collect(Collectors.toList()))
    .flatMap(l -> l.stream())
    .collect(Collectors.toList());

流式传输时List,如何将输出收集到链表？

我尝试过以下方法:

public static void main(String[] args) {
    List<String> firstList = new ArrayList<>();
    firstList.add("pavan");
    firstList.add("kumar");
    LinkedList<String> filtered= new LinkedList<>();
    filtered = (LinkedList<String>) firstList.stream().filter(t->firstList.contains("p")).collect(Collectors.toList());
    System.out.println(filtered);        
}

但 这是让java.util.ArrayList无法强制转换为java.util.LinkedList.

鉴于:

    List<Integer> integers = new ArrayList<>(Arrays.asList(
            10, 12
    ));

    List<Optional<Integer>> optionalIntegers = Arrays.asList(
            Optional.of(5),
            Optional.empty(),
            Optional.of(3),
            Optional.of(2),
            Optional.empty()
    );

    List<Integer> unwrappedOptionals = optionalIntegers.stream()
            .filter(Optional::isPresent)
            .map(Optional::get)
            .collect(Collectors.toList());

    integers.addAll(unwrappedOptionals);

有没有更好的方法来展开Optionals,或者将它们合并到一起的其他方式List<Integer>？List在做之前将它们收集到新的中感觉非常浪费addAll().

请考虑以下代码段:

public class JavaApplication4 {

    static <T> List<T> functionConcat(List<T> l1, List<T> l2) {
        return Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList());
    }

    // functionConcat in lambda form
    static final BinaryOperator<List<? extends Number>> lambdaConcat = (l1, l2)
            -> Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList());

    public static void main(String[] args) {
        // DOES NOT WORK with lambdaConcat
        final List<Integer> x = new LinkedList<List<Integer>>()
                .stream().reduce(new LinkedList<>(), lambdaConcat);
        final List<Double> y = new LinkedList<List<Double>>()
                .stream().reduce(new LinkedList<>(), lambdaConcat);

        // WORKS with functionConcat
        final List<Integer> x2 = new LinkedList<List<Integer>>()
                .stream().reduce(new LinkedList<>(), JavaApplication4::functionConcat);
        final List<Double> y2 …

目前我们使用的基本方法的实现Set<String> clients如下 -

if (clients.isEmpty()) {
    throw new InvalidClientException();
}

for (String client : clients) {
    if (!myMay.containsKey(client)) {
        throw new InvalidClientException(client);
    }
}

我尝试使用lambda表达式转换它,如下所示 -

clients.stream().filter(client -> !myMay.containsKey(client) || clients.isEmpty())
            .forEach(InvalidClientException::new);

但这似乎不是以同样的方式工作,参数化构造函数在这里调用错过了吗？

我有一个方法,如:

private List<Person> findFilteredPersons(List<Person> persons,
            Predicate<Person> filter) {
        return persons
                .stream()
                .filter(filter)
                .sorted(BY_NAME.thenComparing(BY_AGE))
                .collect(Collectors.toList());
}

现在我想在几个地方使用这个方法,但在一个地方我不需要过滤列表,我只想对它进行排序.实现这一目标的最佳方法是什么？

假设我有一个SchoolDistrict,有许多Schools,有许多Students有很多Classes.

我想计算给予SchoolDistrict的课程数量.

Java 7的方式是这样的:

Integer classCount = 0;
for (School school : schoolDistrict)
{
    for (Student student : school.getStudents())
    {
        classCount += student.getClasses().size();
    }
}

我知道Java 8带来的流应该会使这种事情在眼睛上变得容易一些.

但我无法弄清楚如何去做.

任何接受者？

编辑:有人将此标记为此帖的副本,我不相信这是因为该示例仅深入2级(国家/地区).我的问题涉及一个深入四个层次的问题(SchoolDistricts to Schools to Students to Classes)

下面是代码片段,正如预期的那样,在编译时失败.

我真正想要做的是使用流找到所有列表中的最小值和最大值.

public class Delete {

   public static void main(String[] args) {

      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 677, 0);
      List<Integer> list1 = Arrays.asList(11, 12, 23, 34, 25, 77);
      List<Integer> list2 = Arrays.asList(12, 21, 30, 14, 25, 67);
      List<Integer> list3 = Arrays.asList(41, 25, 37, 84, 95, 7);

      List<List<Integer>> largeList = Arrays.asList(list, list1, list2, list3);

      System.out.println(largeList.stream().max(Integer::compare).get());
      System.out.println(largeList.stream().min(Integer::compare).get());
   }

}