标签: collectors

为什么当我从得到一个列表LongStream用Collectors.toList()了一个错误,但有Stream没有错误？

例子 :

错误:

Something.mapToLong(Long::parseLong).collect(Collectors.toList())

正确:

Something.map(Long::valueOf).collect(Collectors.toList())

在官方文档中,您可以阅读:

UNORDERED 指示集合操作不承诺保留输入元素的遭遇顺序.

没有任何例子,这没有太大帮助.

我的问题是,UNORDERED特征究竟意味着什么？我应该使用减少收集器,如min或sum,还是只适用于收集器？

在OpenJDK看起来像减少操作(min,sum,avg)具有空特征.我预计至少发现有CONCURRENT和UNORDERED.

有一个Student类,它们有name, surname, age字段和getter.

给定一个Student对象流.

如何调用一个collect方法,使得它将返回Map键所在的位置age,Student并且值TreeSet包含surname具有此类的学生age.

我想用Collectors.toMap(),但卡住了.

我以为我可以这样做并将第三个参数传递给toMap方法:

stream().collect(Collectors.toMap(Student::getAge, Student::getSurname, new TreeSet<String>()))`.

一般来说,这两段代码之间是否存在性能差异？

List<Integer> list1 = someStream1.sorted().collect(toList());
// vs.
List<Integer> list2 = someStream2.collect(toList());
list2.sort(Comparator.naturalOrder())

变体2显然是令人讨厌的,应该避免,但我很好奇是否在Stream 的主流(heh,main stream)实现中内置了任何性能优化,这将导致这两者之间的性能差异.

我想,因为流有关于情况的更多信息,所以它将有更好的优化机会.例如,我想如果这个问题得到了findFirst()解决,那么它就会忽略这种操作,而不是min操作.

有一个Person对象列表.

List<Person> persons = generatePersons();

使用它创建一个unmodifiableList.

List<Person> unmodifiableList = Collections.unmodifiableList(persons);

据我所知,unmodifiableList这不支持添加/删除/设置操作.同时它不是不可变的,因为它引用了现有的可修改列表,persons并且每当对persons列表进行更改时,更改也会反映出来unmodifiableList.

以这种方式创建不可变列表.

List<Person> immutableList = Collections.unmodifiableList(new ArrayList<>(persons));

这会创建一个不可变列表,因为正在使用转换构造函数.不能执行添加/删除/设置操作,immutableList也不能persons反映原始列表中的任何更改immutableList.让我们假设Person对象也是不可变的.

现在,我想使用流创建这两个列表.

第一个,我创建使用:

List<Person> unmodifiablePersons = persons.stream() .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));

我迷失了通过流创建等效的immutableList.

我怎样才能做到这一点？

编辑:

我Person在原始列表中添加了一个新对象persons并打印了persons列表的大小和unmodifiablePersons.两者都给我相同的大小.因此,变化正在反映unmodifiablePersons,因此它不是一成不变的.我在这里错过了什么吗？

编辑2

愚蠢.本应该通过文档.unmodifiablePersons确实是一个不可改变的清单.此外,新Person对象在unmodifiablePersons创建之前添加,因此上述观察.超级傻.

I have some code that I need help with ... I'm trying to build a map using two maps as a source and at the same time using java lambdas

Map<String, List<String>> motorsMapping = new HashMap<>();

motorsMapping.put("CAR", Collections.singletonList("AUDI"));
motorsMapping.put("CAR_AND_BIKE", Arrays.asList("AUDI", "BMW"));
motorsMapping.put("BIKE", Collections.singletonList("BMW"));

Map<String, List<String>> models = new HashMap<>();
models.put("AUDI", Arrays.asList("A1", "Q2"));
models.put("BMW", Arrays.asList("X1", "X5"));


motorsMapping.keySet().forEach(key -> {
     Map<String, List<String>> result = new HashMap<>();
     result.put(key, new ArrayList<>());
     motorsMapping.get(key).forEach(value -> models.getOrDefault(value, Collections.emptyList()).forEach(property -> result.get(key).add(property)));
});

I can do that with the …

我有以下对象:

public class Item {
    String value;
    List<Person> owners;
    Person creator;
}

public class Person {
    String name;
    int id;
    Person manager;
}

现在我有一个包含3个Item对象的列表:

i1 -> {value="1", owners=[p1, p2, p3], creator=p4}
i2 -> {value="2", owners=[p2, p3], creator=p5}
i3 -> {value="3", owners=[p5], creator=p1}

Person对象如下:

p1 -> {manager=m1, ...}
p2 -> {manager=m2, ...}
p3 -> {manager=m3, ...}
p4 -> {manager=m2, ...}
p5 -> {manager=m1, ...}

我想根据所有者和创建者的管理者对Item对象的流进行分组.结果Map<Person, List<Item>>应如下所示:

{
  m1: [i1, i2, i3],
  m2: [i1, i2],
  m3: [i1, i2]
}

我认为使用Stream和Collector …

简而言之: collect(groupingBy())返回一张地图Map<K, List<T>>.我怎样才能更换,每个K的价值List<T>由(类新的值U),这是基于计算的List<T>,并返回Map<K, U>在同一 stream()？

一个例子:假设我有一个Task,它由一个taskId和一个Jobs列表组成:

public class Task { int taskId; List<Job> jobList; }

对于每个Job方法,方法getAgentId确定能够处理它的"代理":

// in class Job
int getAgentId() { // return the "agent" who is responsible for @param job }

A Task被划分为多个子,Task这样每个子都可以由一个单独的"代理"处理:

// in class Partition; `Integer` for "agent" id
Map<Integer, Task> partition(Task task) { }

我的尝试: …

我一直在努力阅读javadocs,以确定如何使用lambdas优雅地将一种类型的行列表组合成另一种类型的分组列表.

我已经弄清楚如何使用Collectors.groupingBy语法来获取数据,Map<String, List<String>>但是因为结果将用于各种后来的函数调用...我理想地希望将这些缩减为包含以下内容的对象列表新的映射.

这是我的数据类型,RowData是源...我想将数据合并到一个列表中CodesToBrands:

class RowData {
    private String id;
    private String name;

    public RowData() {

    }

    public RowData(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class CodeToBrands {
    private String code;
    private List<String> brands …

我有一个自定义对象项，其中有两个字段金额和税额。我有一个Itemized对象的数组，并且我希望对同一流中的两个字段求和。下面是我如何计算两个字段的总和。

double totalAmount = Arrays.stream(getCharges()).map(Itemized::getAmount).reduce(0.0, Double::sum));
double totalTax = Arrays.stream(getCharges()).map(Itemized::getTax).reduce(0.0, Double::sum));

我有什么办法不必解析两次流并且可以一次性将两个字段求和？我不希望对totalTax和totalAmount求和，但要分别求和。我当时在看收集器，但找不到任何可以一口气汇总多个字段的示例。