是否可以使用.flatMap()或.collect()均匀地多个集合

Question

例如，有集合[1,2,3,4,5]、[6,7,8]、[9,0]。通过Java8StreamAPI避免循环与迭代器交织这些集合以获得以下结果的任何方法-- [1,6,9,2,7,0,3,8,4,5]

Answer 1

我不确定用Stream是否有一种更简单的方法，但是您可以使用所有列表的索引上的流来处理这个问题：

static <T> List<T> interleave(List<List<T>> lists) {
    int maxSize = lists.stream().mapToInt(List::size).max().orElse(0);
    return IntStream.range(0, maxSize)
                    .boxed()
                    .flatMap(i -> lists.stream().filter(l -> i < l.size()).map(l -> l.get(i)))
                    .collect(Collectors.toList());
}

这将获得给定列表中最大列表的大小。对于每个索引，它将其与该索引中每个列表的元素形成的流(如果存在该元素)进行平面映射。

然后你就可以用它

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(1,2,3,4,5);
    List<Integer> list2 = Arrays.asList(6,7,8);
    List<Integer> list3 = Arrays.asList(9,0);
    System.out.println(interleave(Arrays.asList(list1, list2, list3))); // [1, 6, 9, 2, 7, 0, 3, 8, 4, 5]
}

使用质子包库，您可以使用interleave方法执行以下操作：

List<Stream<Integer>> lists = Arrays.asList(list1.stream(), list2.stream(), list3.stream());
List<Integer> result = StreamUtils.interleave(Selectors.roundRobin(), lists).collect(Collectors.toList());
System.out.println(result);

Answer 2

但不是一个很好的解决方案。只是一次尝试

    List<String> listA = Arrays.asList("a1","a2","a3","a4");
    List<String> listB = Arrays.asList("b1","b2","b3","b4");
    List<String> listC = Arrays.asList("c1","c2","c3","c4");
    List<String> combined = Stream.of(listA, listB, listC).flatMap(Collection::stream).collect(Collectors.toList());
    AtomicInteger index = new AtomicInteger();
    List<String> list1 = combined
            .stream().filter(x -> index.incrementAndGet() % 4 ==1).collect(Collectors.toList());
    index.set(0);
    List<String> list2 = combined
    .stream().filter(x -> index.incrementAndGet() % 4 ==2).collect(Collectors.toList());
    index.set(0);
    List<String> list3 = combined
    .stream().filter(x -> index.incrementAndGet() % 4 ==3).collect(Collectors.toList());
    index.set(0);
    List<String> list0 = combined
            .stream().filter(x -> index.incrementAndGet() % 4 ==0).collect(Collectors.toList());
    List<String> desiredOutput = Stream.of(list1, list2, list3,list0).flatMap(Collection::stream).collect(Collectors.toList());
    System.out.println(String.join(",", desiredOutput));

Answer 3

我喜欢Tunaki的回答，并且一直在研究这个问题：

static <T> List<T> interleave(List<? extends Collection<T>> lists) {
    int maxSize = lists.stream().mapToInt(Collection::size).max().orElse(0);
    List<Iterator<T>> iterators = lists.stream().map(l -> l.stream().iterator()).collect(Collectors.toList());
    return IntStream.range(0, maxSize)
            .boxed()
            .flatMap(i -> iterators.stream().filter(it -> it.hasNext()).map(it -> it.next()))
            .collect(Collectors.toList());
}

我想看看我们是否也能把最初的列表作为流来处理，结果证明我们可以。作为一个副作用，我们避免了列表中的get(i) (如果这真的是一个很长的LinkedList，我们希望避免它)。我没有找到一种方法，不知道的最大长度的原始名单。