标签: java-stream

我尝试使用Streams API将以下Scala行转换为Java 8:

// Scala
util.Random.shuffle((1 to 24).toList)

要在Java中编写等效项,我创建了一系列整数:

IntStream.range(1, 25)

我怀疑toList在流API中找到了一个方法,但IntStream只知道奇怪的方法:

collect(
  Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,R> combiner)

如何使用Java 8 Streams API对列表进行混洗？

它们之间有什么相似之处和不同之处,看起来Java Parallel Stream有一些RXJava中可用的元素,是吗？

我想实现一个Stream<T>.

我不想只使用implements Stream<T>,因为我必须实施大量的方法.

这可以避免吗？

更具体的,我怎么能流t1,t2以及t3例如:

class Foo<T> {
    T t1, t2, t3;

    Foo(T t1, T t2, T t3) {
        this.t1 = t1;
        this.t2 = t2;
        this.t3 = t3;
    }
}

我有一群学生.首先,我想用标记对它们进行分组.然后我想进一步将这些集合分组到同名学生中.

   Map<Integer,Map<String,List<String>>> groupping = students.stream()
                                                        .collect(Collectors.groupingBy(Student::getMarks, 
                                                                Collectors.mapping(Student::getName,Collectors.toList())));

我收到一个错误说,

非静态方法不能从静态上下文中引用.

是.我非常清楚,如果没有实例,我就无法引用非静态方法.但是对于所有这些流操作,我真的很困惑.

而不是如何解决这个问题; 我真的想知道这里发生了什么.您的任何投入都表示赞赏!

因为如果我写下面的分组是完全有效的;

    Map<Integer,List<Student>> m = students.stream().
            collect(Collectors.groupingBy(Student::getMarks));

这是我的Student.java类(如果你需要的话)

public class Student {

    private String name;
    private int marks;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMarks() {
        return marks;
    }

    public void setMarks(int marks) {
        this.marks = marks;
    }

    public Student(String name, int marks) {

        this.name = name;
        this.marks = marks;
    }

    @Override
    public String toString() { …

为什么不stream.count()退货int？

我明白,我可以很容易地转换long成int铸造,

return (int) players.stream().filter(Player::isActive).count();

但是为什么 java会stream.count()返回long而不是int？

有没有办法创建IntStream一系列的整数？

就像我想要将值1到1000流,我可以调用一些IntStream静态工厂来传输该范围？

IntStream.forRange(1, 1000).forEach(//do something...

我已经测试了Java 8 lambdas和stream上的max()函数,看起来如果执行max(),即使多个对象比较为0,它也会返回绑定候选者中的任意元素进一步考虑.

对于这样的最大预期行为是否有明显的技巧或功能,以便返回所有最大值？我没有在API中看到任何内容,但我确信它必须存在比手动比较更好的东西.

例如:

//myComparator is an IntegerComparator
Stream.of(1,3,5,3,2,3,5).max(myComparator).forEach(System.out::println);
//Would print 5,5 in any order.

我有以下for循环,它遍历一个字符串列表并存储每个单词的第一个字符StringBuilder.我想知道如何将其转换为lambda表达式

StringBuilder chars = new StringBuilder();
for (String l : list) {
    chars.append(l.charAt(0));
}  

所以如果我有一个Name对象并且有一个ArrayListtype Name(names),并且我想确定我的名字列表是否包含给定的Name对象(n),我可以用两种方式做到:

boolean exists = names.contains(n);

要么

boolean exists - names.stream().anyMatch(x -> x.equals(n));

我正在考虑这两个是否会表现相同,然后考虑如果分配n会发生什么null？

对于contains,据我所知,如果参数是null,则true在列表包含时返回null.我将如何实现这一点anyMatch- 是否可以通过使用Objects.equals(x, n)？

如果可行,那么哪种方法更有效 - 是否anyMatch可以利用懒惰和并行性？

我希望能够处理从必须在页面中访问的源读取的Java流.作为第一种方法,我实现了一个分页迭代器,它只是在当前页面用完项目时请求页面,然后用于StreamSupport.stream(iterator, false)获取迭代器上的流句柄.

当我发现我的页面获取非常昂贵时,我想通过并行流访问页面.在这一点上,我发现由于java直接从迭代器提供的spliterator实现,我的天真方法提供的并行性是不存在的.因为我实际上对我想要遍历的元素了解了很多(我知道在请求第一页后总结果数,并且源支持偏移和限制)我认为应该可以实现我自己的分裂器实现真正的并发(在页面元素和查询页面上完成的工作).

我已经能够很容易地实现"在元素上完成的工作"并发性,但在我最初的实现中,页面的查询只能由最顶层的分裂器完成,因此不会从分工中受益由fork-join实现提供.

如何编写实现这两个目标的分裂器？

作为参考,我将提供我到目前为止所做的事情(我知道它没有适当地划分查询).

   public final class PagingSourceSpliterator<T> implements Spliterator<T> {

    public static final long DEFAULT_PAGE_SIZE = 100;

    private Page<T> result;
    private Iterator<T> results;
    private boolean needsReset = false;
    private final PageProducer<T> generator;
    private long offset = 0L;
    private long limit = DEFAULT_PAGE_SIZE;


    public PagingSourceSpliterator(PageProducer<T> generator) {
        this.generator = generator;
    }

    public PagingSourceSpliterator(long pageSize, PageProducer<T> generator) {
        this.generator = generator;
        this.limit = pageSize;
    }


    @Override
    public boolean tryAdvance(Consumer<? super T> action) {

        if (hasAnotherElement()) {
            if …