Java 8 如何使用Java8特性获得预期的输出？

对于以下输入：

输入1=“0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.10”

INPUT2=“404671.00 | 0.00 | 0.00 | 417975.64 | 0.00 | 0.00 | 417353.81 | 0.00 | 0.00 | 418908.39 |”

INPUT3=“404671.00 | 0.00 | 0.00 | 417975.64 | 0.00 | 0.00 | 417353.81 | 0.00 | 0.00 | 418908.38 | 0.00 | 418908.39”

输入4=“20500000.00 | 20500000.00 | 20500000.00 | 20500000.00 | 20500000.00 | 20500000.00 | 20500000.00 | 20500000.00”

INPUT5=“20181221 | 20181227 | 20190128 | 20190227 | 20190327 | 20190429 | 20190528 | 20190627 | 20190729 | 20190827 | 20191028 | 20191127 | 20191227 | 20200127 1240200227”

输出应如下所示：

#否|输入5 |输入4 |输入2 |输入1 |输入3

• 1 | 20181221 | 20500000.00 | 404671.00 | 0.00 | 404671.00
• 2 | 20181227 | 20500000.00 | 0.00 | 0.00 | 0.00

以传统的（旧的）方式尝试。但是，实现应该使用Java8

public class FormatterDemo {
    public static String INPUT1 = "0.00|0.00|0.00|0.00|0.00|0.00|0.00||0.10";
    public static String INPUT2 = "404,671.00|0.00|0.00|417,975.64|0.00|0.00|417,353.81|0.00|0.00|418,338.38|0.00|0.00|418,908.39||";
    public static String INPUT3 = "404,671.00|0.00|0.00|417,975.64|0.00|0.00|417,353.81|0.00|0.00|418,338.38|0.00|0.00|418,908.39";
    public static String INPUT4 = "20,500,000.00|20,500,000.00|20,500,000.00|20,500,000.00|20,500,000.00|20,500,000.00|20,500,000.00|20,500,000.00|20,500,000.00";
    public static String INPUT5 = "20181221|20181227|20190128|20190227|20190327|20190429|20190528|20190627|20190729|20190827|20190927|20191028|20191127|20191227|20200127|20200227";
    public static String REGEX_PATTERN = "\\|";

    public static void main(String[] args) {

        String[] input1SplitStr = INPUT1.split(REGEX_PATTERN);
        String[] input2SplitStr = INPUT2.split(REGEX_PATTERN);
        String[] input3SplitStr = INPUT3.split(REGEX_PATTERN);
        String[] input4SplitStr = INPUT4.split(REGEX_PATTERN);
        String[] input5SplitStr = INPUT5.split(REGEX_PATTERN);

        int maxSizeValue = findMaxValue(input1SplitStr.length, input2SplitStr.length, input3SplitStr.length,
                input4SplitStr.length, input5SplitStr.length);

        for (int i = 1; i <= maxSizeValue; i++) {
            String input5Value = (i <= input5SplitStr.length && input5SplitStr[i - 1] != null)
                    ? input5SplitStr[i - 1]
                    : "";
            String input4Value = (i <= input4SplitStr.length && input4SplitStr[i - 1] != null)
                    ? input4SplitStr[i - 1]
                    : "";
            String input2Value = (i <= input2SplitStr.length && input2SplitStr[i - 1] != null)
                    ? input2SplitStr[i - 1]
                    : " ";
            String input1Value = (i <= input1SplitStr.length && input1SplitStr[i - 1] != null)
                    ? input1SplitStr[i - 1]
                    : " ";

            String input3Value = (i <= input3SplitStr.length && input3SplitStr[i - 1] != null)
                    ? input3SplitStr[i - 1]
                    : " ";

            System.out.println(i + "|" + input5Value + "|" + input4Value + "|" + input2Value + "|" + input1Value
                    + "|" + input3Value);
        }
    }

    private static int findMaxValue(int... lengths) {
        int maxLength = Integer.MIN_VALUE;
        for (int i : lengths) {
            if (i > maxLength) {
                maxLength = i;
            }
        }
        return maxLength;
    }
}

公共类格式化程序演示{
公共静态字符串输入1=“0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.10”；
公共静态字符串输入2=“404671.00 | 0.00 | 0.00 | 417975.64 | 0.00 | 0.00 | 417353.81 | 0.00 | 0.00 | 418908.38 | 0.00 | 418908 |”；
公共静态字符串输入3=“404671.00 | 0.00 | 0.00 | 417975.64 | 0.00 | 0.00 | 417353.81 | 0.00 | 0.00 | 418338 | 0.00 | 0.00 | 418908.39”；
公共静态字符串输入4=“20500000.00 | 20500000.00 | 20500000.00 | 20500000.00 | 20500000.00 | 20500000.00 | 20500000.00 | 20500000.00”；
公共静态字符串输入5=“20181221 | 20181227 | 20190128 | 20190227 | 20190327 | 20190429 | 20190528 | 20190627 | 20190727 | 20190927 | 20191028 | 20191127 | 20191227 | 20200127 1240200227”；
公共静态字符串REGEX_PATTERN=“\\\\\”；
公共静态void main（字符串[]args）{
字符串[]input1SplitStr=INPUT1.split（REGEX_模式）；
字符串[]input2SplitStr=INPUT2.split（REGEX_模式）；
字符串[]input3SplitStr=INPUT3.split（REGEX_模式）；
字符串[]input4SplitStr=INPUT4.split（REGEX_模式）；
字符串[]input5SplitStr=INPUT5.split（REGEX_模式）；
int maxSizeValue=findMaxValue（input1SplitStr.length、input2SplitStr.length、input3SplitStr.length、，
输入4splitstr.length，输入5splitstr.length）；
对于（int i=1；i我认为它可能是smth。就像这个：

List<String[]> data = Stream.of(INPUT5, INPUT4, INPUT3, INPUT2, INPUT1)
                            .map(in -> in.split(REGEX_PATTERN))
                            .collect(Collectors.toList());

IntSupplier getMaxLength = () -> data.stream().mapToInt(arr -> arr.length).max().orElse(0);
BiFunction<String[], Integer, String> valueAt = (arr, i) -> Optional.ofNullable(i < arr.length ? arr[i] : null).orElse("");

List<String> lines = IntStream.range(0, getMaxLength.getAsInt())
                              .mapToObj(i -> {
                                  Stream<String> s1 = Stream.of(String.valueOf(i + 1));
                                  Stream<String> s2 = data.stream().map(arr -> valueAt.apply(arr, i));
                                  return Stream.concat(s1, s2).collect(Collectors.joining("|"));
                              }).collect(Collectors.toList());

lines.forEach(System.out::println);

List data=Stream.of（INPUT5、INPUT4、INPUT3、INPUT2、INPUT1）
.map（in->in.split（正则表达式模式））
.collect（Collectors.toList（））；
IntSupplier getMaxLength=（）->data.stream（）.mapToInt（arr->arr.length.max（）.orElse（0）；
双函数valueAt=（arr，i）->可选的空值（i{
流s1=流of（字符串valueOf（i+1））；
流s2=data.Stream（）.map（arr->valueAt.apply（arr，i））；
返回流.concat（s1，s2）.collect（收集器.连接（“|”）；
}).collect（Collectors.toList（））；
lines.forEach（System.out:：println）；
我想可能是smth。就像这个：

List<String[]> data = Stream.of(INPUT5, INPUT4, INPUT3, INPUT2, INPUT1)
                            .map(in -> in.split(REGEX_PATTERN))
                            .collect(Collectors.toList());

IntSupplier getMaxLength = () -> data.stream().mapToInt(arr -> arr.length).max().orElse(0);
BiFunction<String[], Integer, String> valueAt = (arr, i) -> Optional.ofNullable(i < arr.length ? arr[i] : null).orElse("");

List<String> lines = IntStream.range(0, getMaxLength.getAsInt())
                              .mapToObj(i -> {
                                  Stream<String> s1 = Stream.of(String.valueOf(i + 1));
                                  Stream<String> s2 = data.stream().map(arr -> valueAt.apply(arr, i));
                                  return Stream.concat(s1, s2).collect(Collectors.joining("|"));
                              }).collect(Collectors.toList());

lines.forEach(System.out::println);

List data=Stream.of（INPUT5、INPUT4、INPUT3、INPUT2、INPUT1）
.map（in->in.split（正则表达式模式））
.collect（Collectors.toList（））；
IntSupplier getMaxLength=（）->data.stream（）.mapToInt（arr->arr.length.max（）.orElse（0）；
双函数valueAt=（arr，i）->可选的空值（i{
流s1=流of（字符串valueOf（i+1））；
流s2=data.Stream（）.map（arr->valueAt.apply（arr，i））；
返回流.concat（s1，s2）.collect（收集器.连接（“|”）；
}).collect（Collectors.toList（））；
lines.forEach（System.out:：println）；