是否有用于复杂列表处理的Java API？[已关闭]

Question

编辑问题以包括所需的行为、特定的问题或错误，以及重现问题所需的最短代码。这将帮助其他人回答这个问题。

我有以下项目清单（订单事项）：

<A> <B> [ ] [\n] <C> [  ] [   ] [\n\r] <D> <A> [ ] [ xyz ] [ abc ] <X>

我想合并方括号表示的文本节点：

<A> <B> [ \n] <C> [     \n\r] <D> <A> [  xyz  abc ] <X>

我编写了一个带有标志和prevNode指针的for-each循环来完成这项任务，但感觉不太对劲：

• 对于一项可以在10秒钟内口头表达的任务来说，这太费劲了
• 如果没有注释，理解代码将需要一些脑力劳动和时间

我相信这就是Java 8流API的意义所在：编写代码的工作量越少，读取代码的工作量越小。

Java中是否有类似的机制来处理列表？

使现代化

由于没有现成的解决方案，我开发了一个非常简单的fluent API来解决这个任务。还原现在看起来就像这样：

List<Node> output = ListStream.of(input)
                .continuousRegion(node -> node instanceof TextNode)
                .reduceRegion((a, b) -> new TextNode(a.value + b.value))
                .toArrayList();

它完美地解决了许多任务，您只需对列表中的连续区域进行操作。我有很多这样的例子，为进一步的数据处理准备XML。

算法：

public List<Node> reduce(List<Node> list) {
        List<Node> result = new ArrayList<>();

        TextNode prevTextNode = null;
        for (Node node : list) {
            if (node instanceof TextNode) {
                TextNode textNode = (TextNode) node;

                if (prevTextNode == null) {
                    prevTextNode = textNode;
                } else {
                    prevTextNode = new TextNode(prevTextNode.value + textNode.value);
                }
            } else {
                if (prevTextNode != null) {
                    result.add(prevTextNode);
                    prevTextNode = null;
                }

                result.add(node);
            }
        }

        if (prevTextNode != null) {
            result.add(prevTextNode);
        }

        return result;
    }

所有代码（可编译）：

import com.sun.deploy.util.StringUtils;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import static org.junit.Assert.assertEquals;

public class ListReductionExample {
    class Node {
        final String value;

        Node(String value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "<" + value + ">";
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Node)) return false;

            Node node = (Node) o;

            return value != null ? value.equals(node.value) : node.value == null;
        }

        @Override
        public int hashCode() {
            return value != null ? value.hashCode() : 0;
        }
    }

    class TextNode extends Node {
        TextNode(String value) {
            super(value);
        }

        @Override
        public String toString() {
            return "[" + value + "]";
        }

    }

    public List<Node> reduce(List<Node> list) {
        List<Node> result = new ArrayList<>();

        TextNode prevTextNode = null;
        for (Node node : list) {
            if (node instanceof TextNode) {
                TextNode textNode = (TextNode) node;

                if (prevTextNode == null) {
                    prevTextNode = textNode;
                } else {
                    prevTextNode = new TextNode(prevTextNode.value + textNode.value);
                }
            } else {
                if (prevTextNode != null) {
                    result.add(prevTextNode);
                    prevTextNode = null;
                }

                result.add(node);
            }
        }

        if (prevTextNode != null) {
            result.add(prevTextNode);
        }

        return result;
    }

    public void printList(List<Node> list) {
        List<String> listOfStrings = list.stream().map(Node::toString).collect(Collectors.toList());

        System.out.println(StringUtils.join(listOfStrings, " "));
    }

    @Test
    public void test() {
        // <A> <B> [ ] [N] <C> [  ] [   ] [NR] <D> <A> [ ] [ xyz ] [ abc ] <X>
        List<Node> input = new ArrayList<>();
        input.add(new Node("A"));
        input.add(new Node("B"));
        input.add(new TextNode(" "));
        input.add(new TextNode("N"));
        input.add(new Node("C"));
        input.add(new TextNode("  "));
        input.add(new TextNode("   "));
        input.add(new TextNode("NR"));
        input.add(new Node("D"));
        input.add(new Node("A"));
        input.add(new TextNode(" "));
        input.add(new TextNode(" xyz "));
        input.add(new TextNode(" abc "));
        input.add(new Node("X"));

        printList(input);

        // <A> <B> [ N] <C> [     NR] <D> <A> [  xyz  abc ] <X>
        List<Node> expectedOutput = new ArrayList<>();
        expectedOutput.add(new Node("A"));
        expectedOutput.add(new Node("B"));
        expectedOutput.add(new TextNode(" N"));
        expectedOutput.add(new Node("C"));
        expectedOutput.add(new TextNode("     NR"));
        expectedOutput.add(new Node("D"));
        expectedOutput.add(new Node("A"));
        expectedOutput.add(new TextNode("  xyz  abc "));
        expectedOutput.add(new Node("X"));

        printList(expectedOutput);

        assertEquals(expectedOutput, reduce(input));
    }
}

Answer 1

我有一种强烈的感觉，您不是在谈论Collection API中的列表，而是在谈论DOM节点。在这种情况下，您正在做不必要的工作。看

<代码>节点。normalize（）：

将此节点下的子树的整个深度中的所有文本节点（包括属性节点）置于“正常”形式，其中只有结构（例如元素、注释、处理指令、CDATA节和实体引用）分隔文本节点，即既没有相邻的文本节点，也没有空的文本节点。

因此，没有相邻的文本节点意味着连接以前相邻的文本节点。因此，您所要做的就是在parant节点上调用normalize（）。

Answer 2

没有这样的特性可以只减少流的一部分。所有试图在流API上构建此类功能的解决方案都比循环复杂得多。要改进循环变量，可以做的是去掉null值和相关的条件。一般逻辑如下：

public static <T> List<T> joinElements(
                          List<T> list, BiPredicate<T,T> p, BinaryOperator<T> join) {

    if(list.isEmpty()) return Collections.emptyList();
    T element=list.get(0);
    int num=list.size();
    if(num==1) return Collections.singletonList(element);
    List<T> result=new ArrayList<>(num);
    for(int ix=1; ix<num; ix++) {
        T next=list.get(ix);
        if(p.test(element, next)) {
            element=join.apply(element, next);
        }
        else {
            result.add(element);
            element=next;
        }
    }
    result.add(element);
    return result;
}

如果怀疑调用方提供了非随机访问列表（程序员应该避免），可以使用

public static <T> List<T> joinElements(
                          List<T> list, BiPredicate<T,T> p, BinaryOperator<T> join) {

    Iterator<T> it=list.iterator();
    if(!it.hasNext()) return Collections.emptyList();
    T element=it.next();
    if(!it.hasNext()) return Collections.singletonList(element);
    List<T> result=new ArrayList<>();
    do {
        T next=it.next();
        if(p.test(element, next)) {
            element=join.apply(element, next);
        }
        else {
            result.add(element);
            element=next;
        }
    } while(it.hasNext());
    result.add(element);
    return result;
}

这可以像这样使用

List<String> result = joinElements(list,
    (a,b) -> isTextNode(a) && isTextNode(b), (a,b) -> new TextNode(a.value+b.value));

相比之下，基于Stream的解决方案可以使用Collector。由于此类任务没有内置的收集器，我们必须定义一个，它基本上与基于循环的解决方案相同，功能仅分布在多个函数上，由执行迭代的Stream评估：

List<String> result=list.stream().collect(ArrayList::new,
    (l,n) -> l.add(!l.isEmpty() && isTextNode(l.get(l.size()-1)) && isTextNode(n)?
                new TextNode(l.remove(l.size()-1).value+n.value): n),
    (l1,l2) -> {
        if(!l2.isEmpty() && !l1.isEmpty()
           && isTextNode(l1.get(l1.size()-1)) && isTextNode(l2.get(0))) {
                l2.set(0, new TextNode(l1.remove(l1.size()-1).value+l2.get(0).value));
        }
        l1.addAll(l2);
    });

决定这是否是对循环变体的改进...