Map.xml 怎么对字符1.1 1.2 1.3 的序号排除

如果你想要在Map.xml中排除字符1.1、1.2、1.3，可以在Map.xml中定义一个过滤器（filter），然后在使用Map.xml的程序中将这个过滤器应用到需要排除字符的地方。具体实现方法如下：

1. 在Map.xml中定义一个过滤器，比如名为"exclude"的过滤器，可以使用正则表达式来指定需要排除的字符，比如排除1.1、1.2、1.3三个字符，可以使用以下正则表达式：

<filter name="exclude" expression="1\.[1-3]" />

2. 在使用Map.xml的程序中，在需要排除字符的地方，使用"exclude"过滤器来过滤掉指定的字符，比如：

XPathExpression expr = xpath.compile("/root/*[not(matches(name(), 'exclude'))]");
NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);

这段代码使用XPath表达式来选择不包含"exclude"过滤器指定字符的所有节点。这样就可以排除1.1、1.2、1.3三个字符了。

相关问题

Map.xml 怎么对字符1.1 1.2 1.3 的序号排序

如果你想在Map.xml中对字符1.1、1.2、1.3进行排序，可以在Map.xml中定义一个排序规则（sort），然后在使用Map.xml的程序中将这个排序规则应用到需要排序的地方。具体实现方法如下：

1. 在Map.xml中定义一个排序规则，比如名为"numeric"的规则，可以使用xsl:sort元素来指定排序方式，比如按字符前缀进行排序，可以使用以下xsl:sort元素：

<xsl:sort select="substring-before(name(), '.')" data-type="number" />

这个xsl:sort元素会按节点名称中"."前面的数字进行排序，从而实现对1.1、1.2、1.3进行排序。

2. 在使用Map.xml的程序中，在需要排序的地方，使用"numeric"排序规则来进行排序，比如：

XPathExpression expr = xpath.compile("/root/*");
NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
List<Node> list = new ArrayList<Node>();
for (int i = 0; i < nodes.getLength(); i++) {
    list.add(nodes.item(i));
}
Collections.sort(list, new Comparator<Node>() {
    public int compare(Node n1, Node n2) {
        return n1.getNodeName().compareTo(n2.getNodeName());
    }
});

这段代码使用XPath表达式选择所有节点，并将它们存储到一个List中，然后使用Collections.sort方法和一个自定义的Comparator来实现排序。在Comparator中，我们使用节点名称来进行比较，这样就可以使用"numeric"排序规则来对节点进行排序了。

java 对List<ScheckTemplatesItemSpecific> itemList和子集List<ScheckTemplatesContentSpecific> contentList多条数据，按1 、1.1 1.2 1.3 、2 2.1 2.2 重新排序

可以使用如下代码对 itemList 和 contentList 进行重新排序：

// 对 itemList 进行排序
Collections.sort(itemList, new Comparator<ScheckTemplatesItemSpecific>() {
    @Override
    public int compare(ScheckTemplatesItemSpecific o1, ScheckTemplatesItemSpecific o2) {
        return o1.getItemNumber().compareTo(o2.getItemNumber());
    }
});

// 对 contentList 进行排序
Collections.sort(contentList, new Comparator<ScheckTemplatesContentSpecific>() {
    @Override
    public int compare(ScheckTemplatesContentSpecific o1, ScheckTemplatesContentSpecific o2) {
        return o1.getContentNumber().compareTo(o2.getContentNumber());
    }
});

// 对 contentList 进行分组
Map<String, List<ScheckTemplatesContentSpecific>> contentMap = new HashMap<>();
for (ScheckTemplatesContentSpecific content : contentList) {
    String[] arr = content.getContentNumber().split("\\.");
    String key = arr[0];
    List<ScheckTemplatesContentSpecific> list = contentMap.get(key);
    if (list == null) {
        list = new ArrayList<>();
        contentMap.put(key, list);
    }
    list.add(content);
}

// 合并 itemList 和 contentList
List<Object> resultList = new ArrayList<>();
int i = 0;
for (ScheckTemplatesItemSpecific item : itemList) {
    resultList.add(item);
    String key = item.getItemNumber();
    List<ScheckTemplatesContentSpecific> list = contentMap.get(key);
    if (list != null) {
        Collections.sort(list, new Comparator<ScheckTemplatesContentSpecific>() {
            @Override
            public int compare(ScheckTemplatesContentSpecific o1, ScheckTemplatesContentSpecific o2) {
                return o1.getContentNumber().compareTo(o2.getContentNumber());
            }
        });
        resultList.addAll(list);
    }
}

这段代码首先对 itemList 和 contentList 分别按照编号进行排序，然后对 contentList 进行分组，将同一个父级编号的子集放在一起。最后，将 itemList 和对应的子集合并到一起，得到重新排序后的结果。