java - 如何在 Java 中从右侧减少有限的流(例如 ArrayList)？

Question

我想使用 reduce 将列表转换为自行实现的链表。我设法以相反的顺序做到了这一点:

import java.util.Arrays;
import java.util.List;

public class Reverse {
    static class Node {
        int val;
        Node next;

        Node(int v, Node n) {
            val = v;
            next = n;
        }
    }

    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        Node result = numbers
                .stream()
                .reduce(null,
                        (node, val) -> new Node(val, node),
                        (n1, n2) -> new Node(-1, null));

        while(result != null) {
            System.out.println(result.val);
            result = result.next;
        }
    }
}

输出是

6
5
4
3
2
1

我认为要以正确的顺序获得结果，我可能必须在其他语言中使用类似 foldRight 或 reduceRight 的东西。如果保证流是有限的，java 是否提供类似的东西？

Answer 1

您可以提供身份并将其用作起点:

public class Test {

    public static void main(String[] args) throws Exception {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        Node result = new Node();

        numbers.stream()
           .reduce(result,
                  (node, val) -> {node.next= new Node(val, null); return node.next;},
                  (n1, n2) -> new Node(-1, null));

        result = result.next;
        while(result != null) {
            System.out.println(result.val);
            result = result.next;
        }
    }
}
class Node {
    int val;
    Node next;

    Node(){}
    Node(int v, Node n) {
        val = v;
        next = n;
    }
}

输出:

1
2
3
4
5
6