मैं एक ArrayList <ArrayList <String>> को कैसे क्रमबद्ध कर सकता हूं?

Question

तो मैं एक कार्यक्रम के लिए एक ब्रेडथ-फर्स्ट सर्च फ़ंक्शन पर काम कर रहा हूं, जिसके लिए मैं स्कूल के लिए काम कर रहा हूं, और जब मैं किसी दिए गए नोड के लिए आउटगोइंग किनारों से गुजरता हूं, तो मैं अपने संभावित किनारों के माध्यम से कैसे जा रहा हूं

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

लेकिन क्या मैं वास्तव में चाहते हैं यह है::, यह कुछ इस तरह दिखता

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

कहाँ एक जोड़ी के पहले सूचकांक नोड का नाम है कि करने के लिए, और किनारे अंक दूसरी अनुक्रमणिका किनारे के लिए लेबल है। अनिवार्य रूप से मैं इन किनारों को वर्णानुक्रम से पहले जाना चाहता हूं, पहले नोड नाम से, फिर लेबल नाम से, लेकिन मुझे यकीन नहीं है कि यह कैसे करें, क्योंकि Collections.sort() 2 डी ArrayList के लिए काम नहीं करता है। इस तरह हल करने के लिए एक अच्छी विधि पर कोई संकेतक/विचार? सबको धन्यवाद!

संपादित करें: मैं JRE 1.7 उपयोग कर रहा हूँ इस असाइनमेंट के लिए, नहीं 1,8

Answer 1

यहाँ पूरा काम कर कोड है। जावा एसडीके 8 में लैम्ब्डा अभिव्यक्ति के साथ काम कर रहा है।

जैसा कि आप देखेंगे, मैंने एक साधारण वर्ग और एक तुलनित्र जोड़ा है। यह सरल और शक्तिशाली है।

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 जवाब पूरी तरह से ठीक है। आपने जावा के संस्करण का उल्लेख नहीं किया है, लेकिन मैं स्थिर Comparator विधियों के साथ जाऊंगा।

समाधान कथात्मक होगा और आप अधिक नियंत्रण और एक संक्षिप्त रास्ते में स्पष्टता दे देंगे:

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

आप देता है::

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

आप उलट क्रम चाहते हैं

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) 
       .reversed() 
       .thenComparing(Edge::getLabel); 

उत्पादन होता है: [[डी, 1], [डी, 2], [सी, 2], [ए, 1]]