जावा में ऐरे के ऐरेलिस्ट को क्रमबद्ध करें

Question

जावा में ArrayList<String[]> सॉर्ट करने का सबसे अच्छा तरीका क्या है?

कहाँ String [] है ...

String[] = new String[] { "abc", "abc", "abc", "abc", "abc", "abc", "abc" }; 

अब मैं (इंडेक्स को 1 पर) स्ट्रिंग की [] 2 मूल्य द्वारा पूरे ArrayList क्रमबद्ध करना चाहते हैं। मुझे प्रत्येक स्ट्रिंग [] और फिर उसके बच्चे को इंडेक्स 1. के माध्यम से लूप करने की आवश्यकता है।

कोई विचार?

संपादित

---

मैं और अधिक विवरण की है। मुझे वास्तव में कुछ एक्सएमएल फ़ाइल से स्कूल मिल रहे हैं और एक्सएमएल में प्रत्येक नोड में 7 विशेषताएं हैं। अब मैं स्ट्रिंग का एक ऐरेलिस्ट बना रहा हूं [] जो एक्सएमएल और स्ट्रिंग से उन स्कूल नोड्स को पकड़ रहा है [] सरणी स्वयं विशेष नोड के गुण रख रही है।

अब, जिस तरह से मैं इसे सॉर्ट करना चाहता हूं, उसे स्कूल के राज्य के अनुसार क्रमबद्ध करना चाहिए जो एक्सएमएल में दूसरी विशेषता है और स्ट्रिंग [1] में स्ट्रिंग [] में प्रविष्टि 1] है।

मुझे प्रत्येक स्कूल के पहले (जावा में एक्सएम, स्ट्रिंग [] में नोड) के माध्यम से लूप करने की आवश्यकता है और फिर मुझे राज्य को फ़िल्टर करना होगा (एक्सएमएल में स्टेट एट्रिब्यूट, जावा में स्ट्रिंग [1])।

क्या यह अभी स्पष्ट है?

Answer 1

Collections.sort, the one that takes a custom Comparator के साथ शुरू। इसके लिए आपको एक कस्टम Comparator लिखना होगा।

उदाहरण के लिए

, यह मानते हुए के रूप में उनके compareTo विधि में परिभाषित आप स्ट्रिंग्स के प्राकृतिक आदेश पर भरोसा करना चाहते हैं:

public static void main(String[] args) throws Exception { 
     ArrayList<String[]> listOfStringArrays = new ArrayList<String[]>(); 
     listOfStringArrays.add(new String[] {"x","y","z"}); 
     listOfStringArrays.add(new String[] {"a","b","c"}); 
     listOfStringArrays.add(new String[] {"m","n","o"}); 
     Collections.sort(listOfStringArrays,new Comparator<String[]>() { 
      public int compare(String[] strings, String[] otherStrings) { 
       return strings[1].compareTo(otherStrings[1]); 
      } 
     }); 
     for (String[] sa : listOfStringArrays) { 
      System.out.println(Arrays.toString(sa)); 
     } 
     /* prints out 
      [a, b, c] 
      [m, n, o] 
      [x, y, z] 
     */ 

    } 

Answer 2

आप Comparator लिखते हैं जो कि सही बच्चे द्वारा दो String[] की तुलना करता है, और फिर आप इसे Collections.sort(List<T> list, Comparator<? super T> c) पर भेज देते हैं।

Answer 3

उपयोग TreeSet या ट्री-मैप http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html

Answer 4

आप बनाने के एक Comparator<String[]> तो जैसे:

new Comparator<String[]>() { 
    public int compare(String[] first, String[] second) { 
    return first[1].compareTo(second[1]); 
    } 
} 

तो करने के लिए इसे पारित Collections.sort()।

यदि आप दूसरे तत्व वास्तव में सरणी में मौजूद हैं तो आप कुछ जांच करना चाहेंगे। यदि मानक स्ट्रिंग तुलना पर्याप्त नहीं है तो आप कस्टम तुलना भी कर सकते हैं।

Answer 5

आपके संपादन के आधार पर: आपका स्ट्रिंग [] आपके गुणों को रखने के लिए एक स्कूल ऑब्जेक्ट होना चाहिए। अपने स्कूल ऑब्जेक्ट को लागू करने योग्य बनाएं और इससे Collections.sort() के साथ आसान सॉर्टिंग की अनुमति मिल जाएगी।

Answer 6

जावा 8 के साथ यह बेहद आसान है।बस लिखें:

list.sort(Comparator.comparing(a -> a[1])); 

उदाहरण के लिए, निम्न कोड:

List<String[]> list = Arrays.asList(
    new String[] { "abc", "abc", "abc", "abc", "abc", "abc", "abc" }, 
    new String[] { "xyz", "xyz", "xyz", "xyz", "xyz", "xyz", "xyz" }, 
    new String[] { "fgh", "fgh", "fgh", "fgh", "fgh", "fgh", "fgh" }); 

list.sort(Comparator.comparing(a -> a[1])); 
list.stream().map(Arrays::toString).forEach(System.out::println); 

वांछित परिणाम निकलेगा:

[abc, abc, abc, abc, abc, abc, abc] 
[fgh, fgh, fgh, fgh, fgh, fgh, fgh] 
[xyz, xyz, xyz, xyz, xyz, xyz, xyz]