小编Tag*_*eev的帖子

使用Stream API获取一对一映射时遇到一些麻烦.基本上,说你上课了.

public class Item {
    private final String uuid;

    private Item(String uuid) {
        this.uuid = uuid;
    }

    /**
    * @return universally unique identifier
    */
    public String getUuid() {
        return uuid;
    }
}

我想要一个Map<String, Item>容易的查找.但鉴于此Stream<Item>,似乎没有一种简单的方法可以实现Map<String, Item>.

显然,Map<String, List<Item>>不是没有的事情:

public static Map<String, List<Item>> streamToOneToMany(Stream<Item> itemStream) {
    return itemStream.collect(groupingBy(Item::getUuid));
}

这是更安全更普遍的情况,但在这种情况下我们确实知道只会​​有一对一的情况.我找不到任何可编译的东西 - 我特意试图将downstream参数设置为muck Collectors.groupingBy.就像是:

// DOESN'T COMPILE
public static Map<String, Item> streamToOneToOne(Stream<Item> itemStream) {
    return itemStream.collect(groupingBy(Item::getUuid, Function.identity()));
}

我错过了什么？

我正在尝试使用一个流List<Map<String, Integer>>来合并包含在一个中的所有地图.这是将多个请求响应聚合为一个.

考虑这个数据集(使用JSON使其更容易阅读):

[
    {"field1": 1, "field2": 5},
    {"field2": 6, "field3": 10},
    {"field1": 3, "field4": 15}
]

我希望它会导致以下(顺序并没有关系):

{"field1": 4, "field2": 11, "field3": 10, "field4": 15}

我想将所有键相加并将它们组合成一个地图.使用Java 8中的Stream接口有一个很好的方法吗？

我发现Collectors.groupingBy(o -> o, Collectors.counting()),所以也许我在正确的界限上,我只需要弄清楚如何在不搞砸结果的情况下实际合并它们.

提前致谢.

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

例子 :

错误:

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

正确:

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

我正在尝试将java8 forEach循环中的布尔变量更改为true,这是非final.但是我遇到了以下错误:在封闭范围内定义的局部变量必须是最终的或有效的最终.

如何解决此错误？

代码:

boolean required = false; 

这是我在函数中创建的变量.

现在,当我试图改变它时:

   map.forEach((key, value) -> {
        System.out.println("Key : " + key + " Value : " + value);
        required = true;
    });

我收到错误:在封闭范围内定义的本地变量必须是最终的或有效的最终.

为什么会出现此错误以及如何解决？

我想摆脱这种依赖: import com.google.common.base.MoreObjects;

有没有简单和/或优雅的方法来toString()使用Java 8本机函数重写以下函数？

@Override
public String toString() {
  return MoreObjects
    .toStringHelper(this)
    .add("userId", this.userId)
    .add("timestamp", this.timestamp)
    .toString();
}

你能解释一下吗？为什么

Stream.of(l1, l2).flatMap((x)->x.stream()).forEach((x)->System.out.println(x));

和

Stream.of(l1, l2).flatMap((x)->Stream.of(x)).forEach((x)->System.out.println(x));

是不同的？

我想知道是否有任何方法可以转换Predicate为String.例如,将有一个功能:

public static <T> String convertPredicate(Predicate<T> objPredicate) {
    return ?...
}

以便以下调用将返回(obj) -> obj.value== 1:

convertPredicate((obj) -> obj.value== 1) 

我正在尝试编写一个API,用文本文件中的不同字符串替换包含某个子字符串的所有行.

我正在使用Java 8流来过滤包含给定模式的行.我有文件写入部分的问题.

Files.lines(targetFile).filter(line -> line.contains(plainTextPattern)).parallel()
      .map(line-> line.replaceAll(plainTextPattern, replaceWith)).parallel();

上面的代码按行读取文件,过滤与模式匹配的行并替换为give字符串,并返回仅包含替换行的字符串流.

我们需要将这些行写回文件.由于我们在管道结束后丢失了流,因此我将以下内容添加到管道中:

.forEach(line -> {
try {
            Files.write(targetFile, line.toString().getBytes());
} catch (IOException e) {
  e.printStackTrace();
}

我希望它只会写入修改后的文件(因为它在管道中),并保持其他行不变.

但它似乎截断文件中每一行的文件,并仅保留最后一个处理的行并删除管道中未匹配的所有行.

有没有我在使用流处理文件时缺少的东西？

我想将流转换为不可变列表.以下方法之间的区别是什么？从性能角度来看哪个更好？

1. collect( Collectors.collectingAndThen(Collectors.toList(), ImmutableList::copyOf));

2. ImmutableList.copyOf( stream.iterator() );

3. collect( Collector.of( ImmutableList.Builder<Path>::new, ImmutableList.Builder<Path>::add, (l, r) -> l.addAll(r.build()), ImmutableList.Builder<Path>::build) );

一些性能或效率的参数,

1. 列表/集合中可能有许多条目.

2. 如果我希望使用".sorted()"自定义比较器的中间操作对集进行排序,该怎么办？

3. 因此,如果我添加.parallel()到流中该怎么办？

我正在尝试计算一些大数字.为了加快计算速度,我想利用多线程.每个线程都应该计算一个数字,最后计算一个总和.

我曾经看过一些与a SumThread和a Collector有关的东西,如下所示:

public BigInteger compute(int p) {
    Collector c = new Collector(p);

    for(T element : Collection<T> bigCollection) {
        new SumThread(c) {

            @Override
            protected void doTheJob() {
                long big = someVeryComplexCalculation(element, ...); //n!
                receive(BigInteger.valueOf(big));
            }

        }
    }

    if(collector.isReady())
        return collector.getResult();

    return null;
}

public class Collector {

    private int numberOfProcesses;
    private int numberOfAllowedProcesses;
    private BigInteger result;

    public Collector(int n) {
        numberOfAllowedProcesses = n;
        numberOfProcesses = 0;
        result = BigInteger.ZERO;
    }

    synchronized public void enter() throws InterruptedException { …