标签: java-stream

我正在尝试将双打列表流式传输到a Map<Double, Double>,其中键是原始列表中的双打,并且值是一些计算值.

这就是我的代码:

// "values" is a List<Double> that was passed in
ImmutableMap<Double, Double> valueMap = values.parallelStream()
    .collect(Collectors.toMap(p -> p, p -> doThing(values, p)));

private Double doThing(List<Double>, Double p) {
    Double computedValue = 0.0;
    // Do math here with p
    return computedValue;
}

然而,IntelliJ抱怨这p -> p不是一个有效的lambda表达式 - 它抱怨循环推理.我打电话时也遇到错误doThing,因为p是lambda参数而不是Double.

当我在调用中尝试强制p转换为无法投射时.DoubledoThing

我错过了一些非常明显的东西吗 似乎没有办法真正对我的lambda参数做任何事情......

我有以下课程:

public class Item {
    int id;
    String name;
    // few other fields, contructor, getters and setters
}

我有一个项目清单.我想迭代列表并找到具有特定id的实例.我正试图通过溪流来做.

public void foobar() {

    List<Item> items = getItemList();
    List<Integer> ids = getIdsToLookup();
    int id, i = ids.size() - 1;

    while (i >= 0) {
        id = ids.get(i);
        Optional<Item> item = items
            .stream()
            .filter(a -> a.getId() == id)
            .findFirst();
        // do stuff
        i--;
    }
}

这是迭代列表并获得我需要的元素的最佳方法吗？另外,我在id的过滤行上得到一个错误,它表示lambda表达式中使用的变量必须是final或者有效的final.也许我可以在while循环中定义id,这应该摆脱异常.谢谢.

在这个问题中,已经回答说两个表达式都是相同的,但在这种情况下它们会产生不同的结果.对于给定的int[] scores,为什么这有效:

Arrays.stream(scores)
        .forEach(System.out::println);

......但这不是:

Arrays.asList(scores).stream()
        .forEach(System.out::println);

据我所知,.stream()可以在任何Collection上调用,列表肯定是.第二个代码片段只返回一个包含整个数组的流而不是元素.

对这个问题有更好,更简单的方法吗？

@Test
public void testReduce() {
    Set<Integer> foo = ImmutableSet.of(1,2,3,4,8,9);
    Set<Integer> bar = ImmutableSet.of(1,3,8,5,11);

    //DO think about solution for 1..n sets, and not only two.
    Set<Integer> intersection = ImmutableList.of(foo,bar)
            .stream()
            .reduce( null, (a, b) -> {
                if ( a == null ) {
                    a = new HashSet<Integer>(b);
                }
                else {
                    a.retainAll(b);
                }
                return a;
            });
    assertThat( intersection, is( ImmutableSet.of( 1,3,8) ) );
}

在Java 8的Streams中,我知道如何基于谓词过滤集合,并处理谓词为真的项目.我想知道的是,如果谓词将集合分成两组,是否可以通过API根据谓词进行过滤,处理过滤后的结果,然后立即链接调用以处理过滤器排除的所有元素？

例如,请考虑以下列表:

List<Integer> intList = Arrays.asList(1,2,3,4);

有可能做到:

intList.stream()
    .filter(lessThanThree -> lessThanThree < 3)
    .forEach(/* process */)
    .exclusions(/* process exclusions */); //<-- obviously sudocode

或者我是否必须只forEach对已过滤的项目执行此过程,然后调用stream()并filter()在原始列表上处理剩余的项目？

谢谢!

我使用的是Java 8.

以下代码工作正常:

public void testMethod(List<String> prop1, EmailJson randomModel) {
    prop1.stream().forEach(s -> randomModel.getSomeList()
            .removeIf(model -> model.getSomeProp().equalsIgnoreCase(s)));
}

如果条件为真,是否可以记录消息？

我正在寻找类似的东西:

public void testMethod(List<String> prop1, EmailJson randomModel) {
    prop1.stream().forEach(s -> randomModel.getSomeList()
            .removeIf(model -> model.getSomeProp().equalsIgnoreCase(s))
                    - > if this is true then log some action);
}

我一直在玩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

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