Question

所以我正在为我正在上学的一个程序开展广度优先搜索功能，当我通过我的方式查看给定节点的传出边缘时;经过我可能的边缘，它看起来像这样：

[[A, 1], [D, 1], [C, 2], [D, 2]]

但我真正想要的是：

[[A, 1], [C, 2], [D, 1], [D, 2]]

其中一对的第一个索引是边指向的节点的名称，第二个索引是边的标签。基本上我想按字母顺序浏览这些边，首先按节点名称，然后按标签名称，但我不知道如何做到这一点，因为Collections.sort（）不适用于2D ArrayList。关于这个好方法的任何指针/想法？谢谢大家！

编辑：我使用JRE 1.7进行此分配，而不是1.8

Answer 1

这是完整的工作代码。 在java SDK8中使用lambda表达式。

正如您将看到的，我添加了一个简单的类和一个比较器。这很简单而且很强大。

package com.rizze.test.labs.sof;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.Test;

public class SOF {    

    public static class Link {
        public String name;
        public int id;

        public static Link build(String n, int i){
            Link l = new Link();
            l.name = n;
            l.id=i;
            return l;
        }

        public String toString(){
            return String.format("[%s , %d]", name,id);
        }           
    }       

    @Test
    public void test() {

        List<Link> links = new ArrayList<Link>();

        //SSETUP [[A, 1], [C, 2], [D, 1], [D, 2]]
        links.add(Link.build("D", 1));
        links.add(Link.build("A", 1));
        links.add(Link.build("D", 2));
        links.add(Link.build("C", 2));


        Collections.sort(links, new Comparator<Link>() {    
            @Override
            public int compare(Link p1, Link p2) {
                int ret = p1.name.compareTo(p2.name);
                if(ret == 0) {
                    ret= p1.id - p2.id;
                }
                return ret;             
            }               
        });
        System.out.println(links);          
    }    
}

//控制台输出

Before : [[D , 1], [A , 1], [D , 2], [C , 2]]
Sorted: [[A , 1], [C , 2], [D , 1], [D , 2]]

// GIST链接 https://gist.github.com/jeorfevre/cbcd7dac5d7fabde6a16db83bdfb7ef5

Answer 2

@jeorfevre的回答非常好。您没有提到Java的版本，但我会使用静态Analyze.update_context方法。

解决方案将是声明性的，并将以简洁的方式为您提供更多控制和清晰度：

Comparator

如果您想要颠倒顺序：

public class Test {
    public static class Edge {
        private String name;
        private int label;
        public Edge(String name, int id) {
            this.name = name;
            this.label = id;
        }
        public String toString() {
            return String.format("[%s , %d]", name, label);
        } 
        public String getName() { return name; } 
        public int getLabel() { return label; }
    }


    public static void main(String[] args) {
        List<Edge> edges = new ArrayList<>();
        edges.add(new Edge("D", 1));
        edges.add(new Edge("A", 1));
        edges.add(new Edge("D", 2));
        edges.add(new Edge("C", 2));

        Comparator<Edge> comparator = Comparator
                .comparing(Edge::getName)
                .thenComparing(Edge::getLabel);

        edges.sort(comparator);

        System.out.println(edges);
    }
}

给你：

            Comparator<Edge> comparator = Comparator
                .comparing(Edge::getName)
                .thenComparing(Edge::getLabel)
                .reversed();

和

[[D , 2], [D , 1], [C , 2], [A , 1]]

输出是： [[D，1]，[D，2]，[C，2]，[A，1]]

如何对ArrayList <arraylist <string>＆gt;？进行排序？

2 个答案: