标签: java-stream

StaticClass::new给定外部类实例的内部类是否有相同的东西？

编辑:

即如果我有

class Outer {
    class Inner {
    }
}

我可以Outer o = new Outer(); Inner i = o.new Inner()用旧Java 做.如何表达o.new Inner()as函数引用.

我实际上试图回答这个问题如何跳过从Files.lines获得的Stream <String>的行.所以我虽然这个收集器并不能很好地并行工作:

private static Collector<String, ?, List<String>> oddLines() {
    int[] counter = {1};
    return Collector.of(ArrayList::new,
            (l, line) -> {
                if (counter[0] % 2 == 1) l.add(line);
                counter[0]++;
            },
            (l1, l2) -> {
                l1.addAll(l2);
                return l1;
            });
}

但它的确有效.

编辑:它实际上没有工作; 我被我的输入集太小而无法触发任何并行性这一事实所迷惑; 见评论中的讨论.

我认为这是行不通的,因为我想到了以下两个执行计划.

1. counter数组在所有线程之间共享.

线程t1读取Stream的第一个元素,因此满足if条件.它将第一个元素添加到其列表中.然后在他有时间更新数组值之前停止执行.

线程t2,从流的第4个元素开始,将其添加到列表中.所以我们最终得到了一个非想要的元素.

当然,既然这个收藏家似乎有效,我猜它不会那样.而且无论如何更新都不是原子的.

2.每个线程都有自己的数组副本

在这种情况下,更新没有更多的问题,但没有什么能阻止线程t2不会从流的第4个元素开始.所以他也不像那样工作.

有人能解释我基本上它是如何工作的以及为什么我的收藏家在并行运行时工作？

非常感谢你!

通常当使用Java 8的parallelStream()时,结果是通过默认的公共fork-join池(即ForkJoinPool.commonPool())执行.

然而,如果一个人的工作远离CPU限制,例如可能在很多时候都在等待IO,那么这显然是不可取的.在这种情况下,人们会想要使用一个单独的池,根据其他标准确定大小(例如,任务可能实际使用CPU的时间有多少).

有没有明显得到parallelStream()使用不同池的方式,但作为一个详细的方式在这里.

不幸的是,这种方法需要从fork-join池线程调用并行流上的终端操作.这样做的缺点是,如果目标分支连接池完全忙于现有工作,整个执行将等待它,而什么都不做.因此,池可能成为比单线程执行更糟糕的瓶颈.相反,当以"正常"方式使用parallelStream()时,使用ForkJoinPool.common.externalHelpComplete()或ForkJoinPool.common.tryExternalUnpush()来让池外的调用线程帮助处理.

有谁知道的方式既获得parallelStream()使用非默认的fork-join池,并有从的fork-join池帮助外的调用线程在这项工作中的处理(但fork-不休息加入游泳池的工作)？

我有以下方法:

public String getResult() {

        List<String> serversList = getServerListFromDB();

        List<String> appList = getAppListFromDB();

        List<String> userList = getUserFromDB();

        return getResult(serversList, appList, userList);
    }

在这里,我按顺序调用三个方法,然后点击DB并获取结果,然后我对从DB命中获得的结果进行后处理.我知道如何通过使用同时调用这三种方法Threads.但我想用Java 8 Parallel Stream来实现这一目标.有人可以指导我如何通过Parallel Streams实现同样的目标吗？

编辑我只想通过Stream并行调用方法.

private void getInformation() {
    method1();
    method2();
    method3();
    method4();
    method5();
}

众所周知,Javadoc谈到了Stream界面:

Streams有一个BaseStream.close()方法并实现AutoCloseable,但几乎所有的流实例实际上都不需要在使用后关闭.通常,只有源为IO通道的流(例如Files.lines(Path,Charset)返回的流)才需要关闭.大多数流都由集合,数组或生成函数支持,不需要特殊的资源管理.(如果流确实需要关闭,则可以在try-with-resources语句中将其声明为资源.)

好的,但同时flatMapToInt在这个界面中有类似的方法:

IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);

Javadoc规范说:

每个映射的流在其内容放入此流后关闭.

所以,我没有想到:如果IntStream没有设计在他的源代码中有IO通道,为什么它在这个方法中关闭？

例如,ReferencePipeline实现以这种方式执行:

try (IntStream result = mapper.apply(u)) {     
   if (result != null)
       result.sequential().forEach(downstreamAsInt);
}

更普遍的问题可能是:我们是否应该关注像IntStream(或其后代)那样关闭流？如果没有,那为什么要flatMapTo*关心？

编辑 @Tunaki提供了非常有趣的电子邮件链接.但这一切都是关于flatMap,我同意我们应该在一般情况下关闭流.但我的问题是关于特殊情况:flatMapToInt,flatMapToLong等等,在这里我没有看到收盘流的任何必要性.

EDIT-2 @BrianGoetz在这里上诉,因为这是他引用的电子邮件,因此他在主题:)

使用Java 8 Stream API时,将多个地图调用合并为一个有什么好处,还是不会真正影响性能？

例如:

stream.map(SomeClass::operation1).map(SomeClass::operation2);

与

stream.map(o -> o.operation1().operation2());

我一直在玩Java中新的和闪亮的功能部分,其中一个让我最困惑的事情是流？

它们的用途是什么？

在谷歌上,我主要找到了如何使用它们的解释和实际例子,我已经说过,没有具体的幕后魔术,这是我感兴趣的.

我不是指在实际意义上,来自一些函数式语言我想出了map/filter/reduce/etc. 相当快,但为什么我们需要先转换为流？Java已经有了迭代器.流和迭代器之间是否存在根本区别,例如一个是懒惰而另一个不是？或者是别的什么？

底线:迭代器和流之间的根本区别是什么,哪些功能无法实现为迭代器的扩展,需要一个全新的类型系列？

所以情况就是这样:我需要在某些日期登记人们的投票.简而言之,提出了一个日期,人们投票支持他们想要的日期.

数据结构如下:

private HashMap<LocalDateTime, Set<Vote>> votes;

投票是:

public class Vote {
    private String name;
    private VoteType vote;

    public Vote(String name, VoteType vote) {
        super();
        this.name = name;
        this.vote = vote;
    }
}

其中VoteType只是一个枚举:

public enum VoteType {YES, NO, MAYBE}

现在我已经创建了一个返回可用性投票数量的流(VoteType):

public Map<LocalDateTime, Integer> voteCount(VoteType targetVote) {
    return this.votes.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new Integer(
            e.getValue().stream().filter(v -> v.getVote() == targetVote).collect(Collectors.toList()).size())));
}

所以我的问题是:如何使用Java Streams获得最多"YES"的日期.

/* Returns the date that got the most 'YES' votes */
public LocalDateTime winningDate() {
    // TODO
}

感谢您的帮助!

请原谅我,如果解决方案非常明显,但我似乎无法弄清楚如何做到这一点

public static void main(String[] args) {
    Map<String, String> map = new HashMap<>();
    map.put("b1", "a1");
    map.put("b2", "a2");
    map.put("b3", "a1");
    Map<String, List<String>> mm = map.values().stream().collect(Collectors.groupingBy(m -> m));
    System.out.println(mm);
}

我想根据hashmap中的值进行分组.我想要输出,{a1=[b1, b3], a2=[b2]}但它现在正在出现{a1=[a1, a1], a2=[a2]}

我对溪流很新,所以请帮帮我(并且温柔).

我想做的是以下内容.我有一个BufferedReader从一个文件读取,其中每行看起来像这样:"a,b".例如:

示例输入文件

"a,b"

"d,e"

"f,g"

我想将其转换为LinkedList<String[]>:

例 LinkedList<String[]>

[{"a","b"},{"c","d"},{"f","g"}]

你会如何使用流方法？

这是我试过的:

List numbers = reader.lines().map(s -> s.split("[\\W]")).collect(Collectors.toList());

这不起作用.我的IDE提供以下反馈:

Incompatible types. Required List but 'collect' was inferred to R: no instance(s) of type variable(s) T exist so that List<T> conforms to List

它显示......我仍在努力想出流.