标签: java-stream

double average = LongStream
   .of(-4480186093928204294L, -1340542863544260591L, -6004296286240039273L)
   .average()
   .getAsDouble()

这会返回,2.20723960999901594E18但我希望它会返回-3.9416750812375014E18.

另一方面,这会返回正确的结果(-1.4628605853333333E9):

double average = IntStream
   .of(-1282256274, -1645263673, -1461061809)
   .average()
   .getAsDouble()

为什么IntStream.average()总是返回正确的平均值,LongStream.average()有时却没有？

我试图将一个字节数组转换为LinkedList<Byte>:

//data is of type byte[]
List<Byte> list = Arrays.stream(toObjects(data)).boxed().collect(Collectors.toList());

Byte[] toObjects(byte[] bytesPrim) {
    Byte[] bytes = new Byte[bytesPrim.length];
    Arrays.setAll(bytes, n -> bytesPrim[n]);

    return bytes;
}

第一行引发一条错误消息:

该boxed()类型的方法未定义Stream<Byte>.

知道为什么我会收到此错误消息以及如何规避这个问题吗？

假设我有一份月度商店销售清单,以便:

ID, date, amount
1, Jan 2016, $500
2, Feb 2017, $200
3, October 2017, $300

我的财政年度是2016年9月1日到2017年8月31日.换句话说,前两个条目是在一个会计年度,另一个是在第二个会计年度.实际会计年度是特定于用户的.

我想storeSales为每个会计年度创建一个列表.

到目前为止,我有:

Map<fiscalYearID, List<StoreSale> = storeSales.stream()
                                .collect(
                                    Collectors.groupingBy(
                                        storeSale -> storeSale.getSaleLocalDate()));

问题是上面的代码只会按确切日期分组.我可以添加,.getYear()但只能按年份而不是财政年度.我还考虑过使用Stream.iterate()每个会计年度日期范围,然后浏览该日期范围内所有商店的商店销售列表到列表中,但这会非常难看,大O值开始迅速攀升.这将是这样的:

Stream.iterate(startDate, date -> date.plusMonths(1))
        .limit(ChronoUnit.MONTHS.between(startDate, endDate.plusMonths(1)))
        .forEach(
        {
            addToFiscalYear(fiscalYearID, 
                    storeSales.stream().
                            .filter(storeSale -> storeSale.getSaleLocalDate().equals(date))
                            .collect(Collectors.toList());
        });

或类似的东西.我没有太多探索它,因为它的大O快速增加,我希望有更好的解决方案......

我有一张像波纹管的地图,

 [key = "car", value = ["bmw", "toyota"]]
 [key = "bike", value = ["honda", "kawasaki"]]

我想使用java 8功能apis将其转换为另一个地图,如bellow,

 [key = "bmw", value = "car"]
 [key = "toyota", value = "car"]
 [key = "honda", value = "bike"]
 [key = "kawasaki", value = "bike"]

我在Haskell中有这个函数,我想知道如何将它转换为Java,特别是使用流:

build = [(w,m,n,g) | w <- [240..1280], m <- [2,4..20], n <- [2..100], g <- [240..1280], ((w - 2*m - n*g) `mod` (n+1) == 0), n*g+2*m <= w, n*g <= w]

我试图在Java 8中创建一个函数,它将一个列表作为参数并返回HashMap一个结果.

我已经在Java 7中完成了它,但我想通过使用Java 8流来实现它:

这是Java 7中的代码:

public static HashMap<String, List<Eleve>> getMentions(List<Eleve> liste){

    HashMap<String, List<Eleve>> listeMentions = new HashMap<String, List<Eleve>>();

    List<Eleve> noMention = new ArrayList<Eleve>();
    List<Eleve> mentionAB = new ArrayList<Eleve>();
    List<Eleve> mentionB  = new ArrayList<Eleve>();
    List<Eleve> mentionTB = new ArrayList<Eleve>();


    for (Eleve eleve: liste) {
        if (eleve.getAverage()>=12 && eleve.getAverage()<14) {mentionAB.add(eleve);}
        else if(eleve.getAverage()>=14 && eleve.getAverage()<16) {mentionB.add(eleve);}
        else if (eleve.getAverage()>=16) {mentionTB.add(eleve);}
        else{noMention.add(eleve);}
    }

    listeMentions.put("No mention", noMention);
    listeMentions.put("Mention AB", mentionAB); 
    listeMentions.put("Mention B",  mentionB);
    listeMentions.put("Mention TB", mentionTB);

    return listeMentions;
}

我尝试了collect(Collectors.toMap) …

我在许多Java 8参考资料和示例中看到了以下代码:

List <Integer> l = Arrays.asList(7, 3, 9, 8, 6, 5, -1, -100);  

l.stream().filter(y -> y <l.get(0)).collect(Collectors.toList()).
      forEach(System.out::println);

但是,我可以使用以下方法获得相同的结果:

l.stream().filter(y -> y <l.get(0)).forEach(System.out::println);

那么,使用几乎普遍使用的collect(Collectors.toList())的神圣性是什么？

总之,以下代码意味着筛选第二个参数中的实体的第一个参数.如果在第二个参数中指定了"更改",则应该过滤较窄的结果.

当我运行它时,我得到一个错误'IllegalStateException:stream已被操作或关闭.

有没有办法可以重用相同的流？
我见过人们实现像Supplier这样的东西,但我认为这不适合这种情况.或者,我只是不熟悉它以了解我如何使用供应商.

/**
     * Filters through DocumentAuditEntityListing to find existence of the entities
     * ActionEnum, ActionContextEnum, LevelEnum, & StatusEnum.
     *
     * @param audits A list of audits to search
     * @param toFind The audit entities to find
     * @return If entities found, return DocumentAudit, else null
     */
    public DocumentAudit verifyAudit(DocumentAuditEntityListing audits, DocumentAudit toFind) {
        //Filter for proper entities
        Stream stream = audits.getEntities().stream().filter(doc -> (
                doc.getAction().equals(toFind.getAction())) &&
                doc.getActionContext().equals(toFind.getActionContext()) &&
                doc.getLevel().equals(toFind.getLevel()) &&
                doc.getStatus().equals(toFind.getStatus()));

        //If changes were specified, filter further.
        if …

Stream Guru的问题非常简单:

我有这个:

    List<MyBean> beans = new ArrayList<>();
    beans.add(new MyBean("tutu"));
    beans.add(new MyBean("toto"));
    beans.add(new MyBean("titi"));

比较:

 StringBuilder reduced
            = beans.parallelStream()
                    .map(MyBean::getName)
                    .reduce(new StringBuilder(), (builder, name) -> {
                        if (builder.length() > 0) {
                            builder.append(", ");
                        }

                        builder.append(name);
                        return builder;
                    }, (left, right) -> left.append(right));

和

 StringBuilder reduced
            = beans.parallelStream()
                    .map(MyBean::getName)
                    .reduce(new StringBuilder(), (builder, name) -> {
                        if (builder.length() > 0) {
                            builder.append(", ");
                        }

                        builder.append(name);
                        return builder;
                    }/* WITHOUT THIRD PARAM*/);

为什么,第二个解决方案没有编译...第三个参数是针对并行流...

你能解释为什么我无法编译第二个代码部分吗？

注意:我不一定在寻找下面描述的具体示例问题的解决方案.我真的很感兴趣为什么在Java 8中不可能开箱即用.

Java流是懒惰的.最后他们有一个终端操作.
我的解释是这个终端操作将通过流提取所有值.没有任何中间操作可以做到这一点.为什么没有中间操作通过流引入任意数量的元素？像这样的东西:

stream
    .mapMultiple(this::consumeMultipleElements) // or groupAndMap or combine or intermediateCollect or reverseFlatMap
    .collect(Collectors.toList());

当下游操作尝试使流一次前进时,中间操作可能尝试多次上行(或根本不上行).

我会看到几个用例:(
这些只是示例.所以你可以看到它确实可以处理这些用例,但它不是"流式传输方式",而且这些解决方案缺乏Streams所具有的理想的懒惰属性. )

• 将多个元素组合到一个新元素中,以传递到流的其余部分.(例如,成对(1,2,3,4,5,6) ? ((1,2),(3,4),(5,6)))

  // Something like this,
  // without needing to consume the entire stream upfront,
  // and also more generic. (The combiner should decide for itself how many elements to consume/combine per resulting element. Maybe the combiner is a Consumer<Iterator<E>> or a Consumer<Supplier<E>>)
  public <E, R> Stream<R> combine(Stream<E> stream, BiFunction<E, E, R> combiner) {
      List<E> completeList …

  Run Code Online (Sandbox Code Playgroud)