Как я могу отсортировать ArrayList <ArrayList <String>>?

Question

Итак, я работаю над функцией поиска по ширине и ширине для программы, над которой я работаю в школе, и когда я просматриваю исходящие ребра для данного узла, в силу того, как я просматриваю свои возможные края , это выглядит примерно так:

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

Но что я действительно хочу это:

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

Если первый индекс пары имя узла, что краевые точки к и второй индекс - это метка для ребра. По сути, я хочу пройти эти ребра по алфавиту, сначала по имени узла, затем по имени метки, но я не уверен, как это сделать, поскольку Collections.sort() не работает для 2D ArrayList. Любые указатели/идеи по хорошему методу сортировки этого? Всем спасибо!

EDIT: Я использую JRE 1.7 для этого задания, а не 1,8

Answer 1

здесь полный рабочий код. Работа с выражением лямбда в java SDK8.

Как вы увидите, я добавил простой класс и компаратор. Это просто и мощно.

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, но я бы пошел со статическими методами 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], [С, 2], [А, 1]]