标签: java-stream

在Java 8流API中,调用chars()任何String对象都会返回IntStream包含所有字符的对象.

将返回的IntStream对象转换回String？的正确方法是什么？调用toArray()会给我一个int[],任何String构造函数都不接受.

假设我有一个抛出运行时异常的方法.我正在使用a Stream来对列表中的项目调用此方法.

class ABC {

    public void doStuff(MyObject myObj) {
        if (...) {
            throw new IllegalStateException("Fire! Fear! Foes! Awake!");
        }
        // do stuff...
    }

    public void doStuffOnList(List<MyObject> myObjs) {
        try {
            myObjs.stream().forEach(ABC:doStuff);
        } catch(AggregateRuntimeException??? are) {
            ...
        }             
    }
}

现在我希望处理列表中的所有项目,并将各个项目的任何运行时异常收集到最终将抛出的"聚合"运行时异常中.

在我的真实代码中,我正在进行第三方API调用,这可能会引发运行时异常.我想确保处理所有项目并在最后报告任何错误.

我可以想出一些方法来解决这个问题,例如map()捕获并返回异常的函数(..shudder ..).但有没有一种本地方式来做到这一点？如果没有,还有另一种方法可以干净利落地实施吗？

FileWriter writer = new FileWriter(output_file);
    int i = 0;

    try (Stream<String> lines = Files.lines(Paths.get(input_file))) {
        lines.forEach(line -> {
            try {
                writer.write(i + " # " + line + System.lineSeparator());
            } catch (Exception e) {
                e.printStackTrace();
            }   
        }
                    );
        writer.close();
    }

我需要用行号写行,所以我试着在.forEach()中添加一个计数器,但是我无法让它工作.我只是不知道把i ++放在哪里; 进入代码,随机搞砸到目前为止没有帮助.

让我们ArrayList用一些简单的东西来填充它:

List<String> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    list.add(""+i);
}

我将尝试使用不同的流API方法删除一个名为5的成员.为此我定义了方法,这将给我一个ConcurentModificationException使用迭代器的传统迭代.

void removeMember(String clientListener) {
    list.remove(clientListener);
}

这段代码给了我这个例外,我明白了:

list.parallelStream()
    .filter(string -> string.equalsIgnoreCase("5"))
    .forEach(string -> removeMember(string));

但是,尝试只是stream(),不parallelStream()给出空指针异常(NPE),这对我来说很奇怪:

list.stream()
    .filter(string -> string.equalsIgnoreCase("5"))
    .forEach(string -> removeMember(string));

现在将List类型更改为LinkedList<>.最后的代码stream()给了我一个ConcurentModificationException,parallelStream()突然工作!

所以,问题.

1. 内部parallelStream()厨房(Spliterators和其他魔法)是否足够聪明,可以使用这种元素去除LinkedList？它会一直有效吗？

2. 为什么NPE适合ArrayList？为什么选择NPE,不是ConcurentModificationException我的意思.

我有以下代码:

List<Long> list = new ArrayList<>();
list.add(4L);
list.add(92L);
list.add(100L);
List<Long> newList = list.stream().map(i -> i * 2.5)
                                  .mapToLong(Double::doubleToRawLongBits)
                                  .collect(Collectors.toList());

此代码不起作用,编译错误是:

方法collect在接口java.util.stream.LongStream不能被应用到给定的类型;
required:java.util.function.Supplier<R>,java.util.function.ObjLongConsumer<R>,java.util.function.BiConsumer<R,R>
found:java.util.stream.Collector<java.lang.Object,capture#1 of ?,java.util.List<java.lang.Object>>
reason:无法推断类型变量R (实际和形式参数列表长度不同)

我尝试了许多收藏家的用法,但我仍然无法使其发挥作用.我究竟做错了什么？

我需要在代码块中使用流中的'n'项然后完成,实质上:

 public static <T> void eat(Stream<T> stream, int n) 
     // consume n items of the stream (and throw them away)
 }

在我的情况下,我无法改变签名返回Stream<T>简单return stream.skip(n); 我必须实际丢弃流中的一些元素(不是简单的逻辑) - 为下游消费者做好准备,这不需要知道这是怎么发生的,甚至不知道发生了什么.

最简单的方法是使用limit(n),但我必须调用流终止方法来激活流,所以本质上我有:

public static <T> void skip(Stream<T> stream, int n) {
    stream.limit(n).forEach(t -> {});
}

注意:此代码完全简化了实际代码,仅用于说明目的.实际上,限制将不起作用,因为存在围绕什么/如何消耗元素的逻辑.可以把它想象成从流中消费"header"元素,然后让消费者使用"body"元素.

这个问题是关于"无所事事"的lambda t -> {}.

在JDK中的某个地方是否有"无所事事"的消费者,比如"无所事事"功能Function.identity()？

随着Collection一切都清楚了,但是怎么样以下几点:

有object一种count()方法和getPart(int i)方法.因此,提取所有对象会产生以下样板代码:

List<Part> result = new ArrayList<Part>();
for (int i = 0, i < object.count(), i++) {
    result.add(object.getPart(i));        
}
return result.stream(); 

是否有任何标准的方法来传递2个生产者:() -> object.count()并(int i) -> object.getPart(i)创建一个流？像这样:

SomeUtil.stream(object::count, object::getPart);

我想List<E>从一个Map<String,List<E>>(E是一个随机类)中提取一个stream().

我想要一个使用java 8流的简单单行方法.

我到现在为止尝试过的事情:

HashMap<String,List<E>> map = new HashMap<>();
List<E> list = map.values(); // does not compile
list = map.values().stream().collect(Collectors.toList()); // does not compile

有简单的解决方案可以连接两个String[]或Integer[]在java中Streams.因为int[]经常使用.连接两个有什么简单的方法int[]吗？

这是我的想法:

int[] c = {1, 34};
int[] d = {3, 1, 5};
Integer[] cc = IntStream.of(c).boxed().toArray(Integer[]::new);
Integer[] dd = Arrays.stream(d).boxed().toArray(Integer[]::new);
int[] m = Stream.concat(Stream.of(cc), Stream.of(dd)).mapToInt(Integer::intValue).toArray();
System.out.println(Arrays.toString(m));

>>
[1, 34, 3, 1, 5]

它可以工作,但它实际上转换int[]为Integer[],然后再转换Integer[]回来int[].

Stream继承一个iterator()方法来生成一个Iterator.

但我需要一个Iterable而不是一个Iterator.

例如，给定这个字符串：

String input = "this\n" +
        "that\n" +
        "the_other";

...我需要将字符串的这些部分作为 anIterable传递给特定的库。调用input.lines()产生一个Stream. 所以如果我能把它Stream变成Iterable它的一个元素，我会很高兴的。