标签: java-stream

我想从 Bean 列表生成一个字符串列表，包括 id 和外部 id。

public class User {
    private String id;
    private List<String> externalIds;
}

我使用下面的代码得到了它，但这里我需要进行两次流。

List<User> references = new ArrayList();
Stream.concat(references.stream().map(User::getId),
references.stream().map(User::getExternalIds).flatMap(Collection::stream))
            .collect(Collectors.toList());

有没有更好的方法来重写这段代码？

我有一个接收收集器的方法。收集器应该合并传入列表：

reducing(Lists.newArrayList(), (container, list) -> {
   container.addAll(list);
   return container;
})

这对我来说似乎是一个非常常见的场景，我相信 Java 自己的收集器应该有一些东西来涵盖这个用例，但我不记得是什么了。再说了，我还想让它回来ImmutableList。

我想将 a 转换Map<String,List<String>>为Map<String,Set<String>>优化搜索。我想出了下面的传统方法。

 for (Map.Entry<String, List<String>> entry : this.mapWithList.entrySet()) {
        Set<String> hSet = new HashSet<>(entry.getValue());
        this.mapWithSet.put(entry.getKey(), hSet);
   }

forEach我想知道如何在Java 8中使用它。

另外，使用forEachlambda 后，代码性能会更好吗？

给定一个订单类，例如：

@ToString
@AllArgsConstructor
@Getter
static class Order {
    long customerId;
    LocalDate orderDate;
}

和订单列表：

List<Order> orderList = List.of(new Order(1, LocalDate.of(2020,Month.APRIL,21)),
                                new Order(1, LocalDate.of(2021,Month.APRIL,21)),
                                new Order(1, LocalDate.of(2022,Month.APRIL,21)),
                                new Order(2, LocalDate.of(2020,Month.APRIL,21)),
                                new Order(2, LocalDate.of(2021,Month.APRIL,21)),
                                new Order(3, LocalDate.of(2020,Month.APRIL,21)),
                                new Order(3, LocalDate.of(2022,Month.APRIL,21)),
                                new Order(4, LocalDate.of(2020,Month.APRIL,21)));

我需要获得一份清单，customerId其中列出了最后一次orderDate超过 6 个月的情况。所以对于上面的例子[2,4]。我的想法是首先按 分组customerId，第二个地图到最后orderDate，第三个过滤那些超过 6 个月的地图。我陷入了如何将最近的订单映射到单个订单的第二步orderDate

第一步

Map<Long, List<Order>> grouped =
        orderList.stream()
                .collect(Collectors.groupingBy(Order::getCustomerId));

第二步（卡在这里如何更改上述内容以仅获取一项作为值）

Map<Long, Order> grouped =
        orderList.stream()
                .collect(Collectors.groupingBy(Order::getCustomerId, ???));

甚至更好

Map<Long, LocalDate> grouped =
        orderList.stream()
                .collect(Collectors.groupingBy(Order::getCustomerId, …

如何从字符串列表中获取映射，其中索引是键，字符串是值？

如果我有这样一个清单

List<String> list = List.of("foo","bar","baz","doo");

我想要得到一个Map<Integer,String>喜欢

{0=foo, 1=bar, 2=baz, 3=doo}

当我执行以下操作时出现错误

static Map<Integer,String> mapToIndex(List<String> list) {
    return IntStream.range(0, list.size())
            .collect(Collectors.toMap(Function.identity(), i -> list.get(i)));
}

错误

所需类型：int 提供：Object

当我将其转换为 int 或 Integer 时

static Map<Integer,String> mapToIndex(List<String> list) {
    return IntStream.range(0, list.size())
            .collect(Collectors.toMap(Function.identity(), i -> list.get((Integer) i)));
}

我明白了

'java.util.stream.IntStream' 中的 'collect(java.util.function.Supplier, java.util.function.ObjIntConsumer, java.util.function.BiConsumer<R,R>)' 无法应用于 '(java .util.stream.Collector<java.lang.Object,capture<?>,java.util.Map<java.lang.Object,java.lang.String>>)'

我缺少什么？

我正在尝试过滤实现接口的对象列表。我正在尝试为所有类创建一个通用方法。

就像是：

interface SomeInterface {
    String getFlag();
}


class SomeObject implements SomeInterface {
    public String getFlag() {
        return "X";
    }
}


List<SomeObject> someObjectList = new ArrayList<>();

// Compilation error here
List<SomeObject> filterList = filterGenericList(someObjectList, "X");


private List<?> filterGenericList(List<? extends SomeInterface> objects, String flag) {
        return objects.stream()
                .filter(it -> it.getFlag().equals(flag))
                .collect(Collectors.toList());
}

如何避免编译错误？

 Incompatible types. 
 Found: 'java.util.List<capture<?>>', 
 Required: 'java.util.List<SomeObject>'

代码是：

public TreeSet<VehicleTransportation> allVehicleTransportations(){
        
        Set<VehicleTransportation> sortedVehicles = allVehicleTransportation.entrySet().stream()
                .sorted(Comparator.comparing(Map.Entry::getValue.pollutionLevel , Comparator.reverseOrder()))
                .sorted(Comparator.comparing(Map.Entry::getValue.price))
                .map(Map.Entry::getValue)
                .collect(Collectors.toSet());

        return sortedVehicles;
    }

HashMap 在哪里

HashMap<String, VehicleTransportation> allVehicleTransportation = new HashMap<String, VehicleTransportation>();

我使用这段代码遇到了两个问题。首先，由于某种原因Map.Entry::getValue遇到错误： The target type of this expression must be a functional interface 我认为这里的问题是比较器无法在两个类型的对象之间进行比较，VehicleTransportation尽管 pollutionLevel和price都是字符串。

其次，我不太清楚如何将 Set 转换为 TreeSet （也许使用(TreeSet<VehicleTransportation>)？）

我有一个字符串流：

Stream<String> st = Arrays.stream(new String[]{"10", "20", "30",  "40", "50"});

我想将它们转换为整数并使用该方法对它们进行求和reduce。我使用以下格式的reduce：

int result = st.reduce(0, (a, b) -> a + Integer.parseInt(b));

我收到此错误：

no suitable method found for reduce(int, (a, b) -> a + [...]nt(b))

有关如何重写reduce 方法以使其工作的任何提示吗？

我试图从集合（HashSet）中删除一些对象，但前提是它们也存在于列表（LinkedList）中。如何使用 Java 8+ 功能（流）来实现这一目标。

Set<MyObject> theSet -> want to remove items that are present in the list

List<MyObject> theList

我已经覆盖了 MyObject 的 equals 和 hashcode（仅使用几个字段来比较相等性）。

我有这样的代码，它应该Map从整数数组创建一个。键代表位数。​

public static Map<Integer, List<String>> groupByDigitNumbersArray(int[] x) {
    return Arrays.stream(x)  // array to stream
        .filter(n -> n >= 0) // filter negative numbers
        .collect(Collectors.groupingBy(n -> Integer.toString((Integer) n).length(), // group by number of digits
            Collectors.mapping(d -> (d % 2 == 0 ? "e" : "o") + d,
                Collectors.toList()))); // if even e odd o add to list
}

public static Map<Integer, List<String>> groupByDigitNumbersArray(int[] x) {
    return Arrays.stream(x)  // array to stream
        .filter(n …