Question

对不起，我找不到更好的标题： - ）

我有一个树形结构，这是我的“节点”类：

public class Categoria implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotNull
    private String name;

    @OneToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)
    @JoinColumn(name = "parent_id")
    private List<Categoria> children = new LinkedList<Categoria>();

    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(
        name = "parent_id",
        insertable=false,
        updatable=false
    )
    private Categoria parent;

    @Transient
    private Integer depth;

    private Integer orderNumber;

... getters, setters, ....
}

不关心Hibernate / JPA注释，它们没有问题，只想到一个理想的pojo世界。

我做了一个递归方法，它构建了一个相邻节点的“普通”列表。所以，想象一下这棵树：

grandfather

 |_ father

    |_ son1

    |_ son2

 |_ uncle

grandmother

 |_ mother

我们将得到一个像这样的结果列表（数字是“深度”）： - 祖父（1） - 父亲（2） - son1（3） - son2（3） - 叔叔（2） - 祖母（1） - 母亲（2）

一切都很好。

现在我想让我的用户编辑节点排序（在相同的深度节点之间），我的意思是：如果我想在上面列表中的“son1”之前“son2”怎么办？

所以我想添加一个“orderNumber”属性：所有orderNumbers最初都是0。然后我的用户将son1的orderNumber设置为99，将son2的orderNumber设置为88。

问题是：如何重新排列结果列表以根据orderNumber进行排序？

但是等等....我只想对“子列表”进行排序，以便儿子排序绝对与“父亲”和“叔叔”排序无关！

感谢您帮助我们。

编辑：你们都缺少一件事。我没有很好地解释自己。这是一个例子：

祖父（深度：1，订单号：1）
父亲（深度：2，订单号：1）
son1（深度：3，订单号：1）
son2（深度：3，订单号：2）
叔叔（深度：2，顺序号码：2）
祖母（深度：1，订单号：2）
母亲（深度：2，订单号：1）

现在我想交换son1和son2，结果列表将是：

祖父（深度：1，订单号：1）
父亲（深度：2，订单号：1）
son2（深度：3，订单号：1）
son1（深度：3，订单号：2）
叔叔（深度：2，顺序号码：2）
祖母（深度：1，订单号：2）
母亲（深度：2，订单号：1）

如何为此目的实现sort / compareTo？

Answer 1

让Categoria实施Comparable。创建一个自定义compareTo实现，您可以按深度排序，并根据您的其他OrderNumber属性决定。这适用于任何可排序的集合。

但是根据您使用该树结构解决的问题，可能更适合为树实现自定义迭代器而不是递归创建“列表快照”？

Answer 2

您可以使用Collections.sort（）和适当的比较器对子列表进行显式排序。

如果在创建列表时已知排序，则可以使用带有比较器而不是LinkedList的有序集合（如TreeSet）。因此，插入时将对项目进行排序。

Answer 3

我会让您的类实现Comparable，在compareTo方法中，我会使用字段depth和orderNumber来计算订单。完成此操作后，您可以使用Collectoins.sort（）对列表进行排序。

示例代码：

public class Categoria implements Serializable, Comparable<Categoria> {

    private static final long serialVersionUID = 1L;

    // ... omitting other fields/annotations/getters/setters

    private Integer depth;

    private Integer orderNumber;

    @Override
    public int compareTo(Categoria other) {
        if (depth < other.depth)
            return -1;
        if (depth > other.depth)
            return 1;
        // if we get here the two objects have the same depth, so we compare 
        // based on orderNumber
        if (orderNumber < other.orderNumber)
            return -1;
        if (orderNumber > other.orderNumber)
            return 1;
        return 0;
    }

}

Answer 4

我需要：

private List<Categoria> getAlberoCategorie(Categoria root, int profondita) {
        List<Categoria> tmpList = new ArrayList<Categoria>();
        root.setProfondita(profondita);
        if ( root.getParent() != null ) {
            Hibernate.initialize(root.getTraduzioni());
            tmpList.add(root);
        }       

        List<Categoria> children = root.getChildren();
        Collections.sort(children, new Comparator<Categoria>() {
            @Override
            public int compare(Categoria o1, Categoria o2) {
                return o1.getOrdinamento().compareTo(o2.getOrdinamento());
            }
        });

        if (!children.isEmpty()) {
            profondita++;
            for (Categoria figlia : children) {
                List<Categoria> discendenza = getAlberoCategorie(figlia,profondita);                
                tmpList.addAll(discendenza);
            }
        }       
        return tmpList;
    }

无论如何，谢谢大家！

用于排序＆＃34;普通列表树结构的算法＆＃34;

4 个答案: