在Java8中显示分块项目列表

Question

使用以下代码：

public class Main {

    public static void main(String[] args) {
        final List<Integer> items = 
             IntStream.rangeClosed(0, 23).boxed().collect(Collectors.toList());

        final String s = items
            .stream()
            .map(Object::toString)
            .collect(Collectors.joining(","))
            .toString()
            .concat(".");

        System.out.println(s);
    }
}

我得到：

0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23。

我想做的是每 10 个项目中断一次行，以便获得：

0,1,2,3,4,5,6,7,8,9,

10,11,12,13,14,15,16,17,18,19,

20,21,22,23.

我在谷歌搜索后尝试了很多事情，但都没有成功！你能帮助我吗？

谢谢

奥利维尔。

Answer 1

以下是对注释Publector中已链接的内容的改编：

    private static Collector<String, ?, String> partitioning(int size) {
    class Acc {
        int count = 0;

        List<List<String>> list = new ArrayList<>();

        void add(String elem) {
            int index = count++ / size;
            if (index == list.size()) {
                list.add(new ArrayList<>());
            }
            list.get(index).add(elem);
        }

        Acc merge(Acc right) {

            List<String> lastLeftList = list.get(list.size() - 1);
            List<String> firstRightList = right.list.get(0);
            int lastLeftSize = lastLeftList.size();
            int firstRightSize = firstRightList.size();

            // they are both size, simply addAll will work
            if (lastLeftSize + firstRightSize == 2 * size) {
                System.out.println("Perfect!");
                list.addAll(right.list);
                return this;
            }

            // last and first from each chunk are merged "perfectly"
            if (lastLeftSize + firstRightSize == size) {
                System.out.println("Almost perfect");
                int x = 0;
                while (x < firstRightSize) {
                    lastLeftList.add(firstRightList.remove(x));
                    --firstRightSize;
                }
                right.list.remove(0);
                list.addAll(right.list);
                return this;
            }

            right.list.stream().flatMap(List::stream).forEach(this::add);
            return this;
        }

        public String finisher() {
            return list.stream().map(x -> x.stream().collect(Collectors.joining(",")))
                    .collect(Collectors.collectingAndThen(Collectors.joining(",\n"), x -> x + "."));
        }

    }
    return Collector.of(Acc::new, Acc::add, Acc::merge, Acc::finisher);
}

用法将是：

String result = IntStream.rangeClosed(0, 24)
            .mapToObj(String::valueOf)
            .collect(partitioning(10));

Answer 2

如果你想做的只是处理这些升序数字，你可以这样做

String s = IntStream.rangeClosed(0, 23).boxed()
    .collect(Collectors.groupingBy(i -> i/10, LinkedHashMap::new,
            Collectors.mapping(Object::toString, Collectors.joining(","))))
    .values().stream()
    .collect(Collectors.joining(",\n", "", "."));

该解决方案也可以适应于任意随机访问列表，例如

List<Integer> items = IntStream.rangeClosed(0, 23).boxed().collect(Collectors.toList());

String s = IntStream.range(0, items.size()).boxed()
    .collect(Collectors.groupingBy(i -> i/10, LinkedHashMap::new,
            Collectors.mapping(ix -> items.get(ix).toString(), Collectors.joining(","))))
    .values().stream()
    .collect(Collectors.joining(",\n", "", "."));

然而，对于任意流没有简单而优雅的解决方案，这一限制适用于依赖于元素位置的所有类型的任务。

Answer 3

如果您愿意使用第三方库，则可以使用 Eclipse Collections Collectors2.chunk（int） 执行以下操作。

String s = IntStream.rangeClosed(0, 23)
        .boxed()
        .collect(Collectors2.chunk(10))
        .collectWith(MutableList::makeString, ",")
        .makeString("", ",\n", ".");

Collectors2.chunk（10） 的结果将是一个 MutableList

如果只使用Eclipse集合API，这个问题可以简化如下:

String s = Interval.zeroTo(23)
        .chunk(10)
        .collectWith(RichIterable::makeString, ",")
        .makeString("", ",\n", ".");

注意:我是Eclipse集合的提交者。