java - मैं वर्णानुक्रम में एक सूची कैसे क्रमबद्ध कर सकता हूं?




list sorting (9)

मेरे पास एक List<String> ऑब्जेक्ट है जिसमें देश के नाम शामिल हैं। मैं इस सूची को वर्णानुक्रम से कैसे क्रमबद्ध कर सकता हूं?


Collections.sort के साथ समाधान

यदि आपको उस सूची का उपयोग करने के लिए मजबूर किया जाता है, या यदि आपके कार्यक्रम की संरचना है

  • सूची बनाएं
  • कुछ देश के नाम जोड़ें
  • उन्हें एक बार सॉर्ट करें
  • उस सूची को दोबारा कभी न बदलें

तो थिलोस जवाब यह करने का सबसे अच्छा तरीका होगा। यदि आप टॉम हौटिन - टॉकलाइन से सलाह के साथ गठबंधन करते हैं, तो आपको मिलता है:

java.util.Collections.sort(listOfCountryNames, Collator.getInstance());

एक वृक्षारोपण के साथ समाधान

यदि आप निर्णय लेने के लिए स्वतंत्र हैं, और यदि आपका एप्लिकेशन अधिक जटिल हो सकता है, तो आप इसके बजाय ट्रीसेट का उपयोग करने के लिए अपना कोड बदल सकते हैं। इस प्रकार का संग्रह आपकी प्रविष्टियों को तब दर्ज करता है जब वे डाले जाते हैं। सॉर्ट करने की आवश्यकता नहीं है ()।

Collection<String> countryNames = 
    new TreeSet<String>(Collator.getInstance());
countryNames.add("UK");
countryNames.add("Germany");
countryNames.add("Australia");
// Tada... sorted.

साइड नोट क्यों मैं ट्रीसेट पसंद करते हैं

इसमें कुछ सूक्ष्म, लेकिन महत्वपूर्ण फायदे हैं:

  • यह बस छोटा है। हालांकि, केवल एक पंक्ति छोटी है।
  • इस बारे में चिंता न करें कि यह सूची वास्तव में अभी हल हो गई है क्योंकि एक वृक्षारोपण हमेशा हल किया जाता है, इससे कोई फर्क नहीं पड़ता कि आप क्या करते हैं।
  • आपके पास डुप्लिकेट प्रविष्टियां नहीं हो सकती हैं। आपकी स्थिति के आधार पर यह एक प्रो या एक कॉन हो सकता है। यदि आपको डुप्लीकेट की आवश्यकता है, तो अपनी सूची में चिपके रहें।
  • एक अनुभवी प्रोग्रामर TreeSet<String> countyNames और तुरंत जानता है: यह डुप्लीकेट के बिना स्ट्रिंग्स का एक क्रमबद्ध संग्रह है, और मैं यह सुनिश्चित कर सकता हूं कि यह हर पल में सच है । एक छोटी घोषणा में बहुत अधिक जानकारी।
  • कुछ मामलों में असली प्रदर्शन जीत। यदि आप किसी सूची का उपयोग करते हैं, और अक्सर मूल्य डालें, और सूची उन प्रविष्टियों के बीच पढ़ी जा सकती है, तो आपको प्रत्येक सम्मिलन के बाद सूची को सॉर्ट करना होगा। सेट वही करता है, लेकिन यह बहुत तेज़ करता है।

सही कार्य के लिए सही संग्रह का उपयोग करना संक्षिप्त और बग फ्री कोड लिखना महत्वपूर्ण है। यह इस मामले में प्रदर्शनकारी नहीं है, क्योंकि आप केवल एक पंक्ति को बचाते हैं। लेकिन मैंने यह गिनना बंद कर दिया है कि मैं किसी सूची का उपयोग करके किसी को कितनी बार देखता हूं जब वे यह सुनिश्चित करना चाहते हैं कि कोई डुप्लिकेट न हो, और फिर उस कार्यक्षमता को स्वयं बनाएं। या इससे भी बदतर, दो सूचियों का उपयोग करते समय आपको वास्तव में मानचित्र की आवश्यकता होती है।

मुझे गलत मत समझो: Collections.sort का उपयोग करना कोई त्रुटि या दोष नहीं है। लेकिन कई मामले हैं जब ट्रीसेट बहुत साफ है।


अवरोही वर्णमाला:

List<String> list;
...
Collections.sort(list);
Collections.reverse(list);

आप मेरे द्वारा बनाई गई विधि का उपयोग करने का प्रयास कर सकते हैं।

String key - वह आदेश होगा जो आप चाहते हैं और इस मामले में वर्णानुक्रम में। बस "एबीसी ..." डालें।

String list[] - वह सूची जिसे आप कुंजी का उपयोग करके क्रम में रखना चाहते हैं।

int index - 0 के रूप में सेट, कुंजी के लिए ऑफसेट सेट करेगा।

    public static String[] order(String key, String list[], int index) {
    ArrayList<String> order_List = new ArrayList<String>();
    ArrayList<String> temp_Order_List = null;
    char[] key_char = key.toCharArray();
    for (int offset = 0; offset < key_char.length; offset++) {
        if (key_char.length >= offset + index) {
            String str = (index > 1 ? list[0].substring(0, index - 1) : "")
                    + new String(key_char, offset, 1);
            for (int i = 0; i < list.length; i++) {
                temp_Order_List = new ArrayList<String>();
                for (int k = 0; k < list.length; k++) {
                    if (!order_List.contains(list[k])
                            && !temp_Order_List.contains(list[k])) {
                        if (list[k].equalsIgnoreCase(str))
                            order_List.add(list[k]);
                        else if (list[k].toLowerCase().startsWith(str.toLowerCase())) {
                            temp_Order_List.add(list[k]);

                        }
                    }
                }
                if (temp_Order_List.size() > 0) {
                    if (temp_Order_List.size() > 1) {
                        String[] add = order(key,
                                temp_Order_List.toArray(new String[temp_Order_List
                                        .size()]), index + 1);
                        for (String s : add) {
                            order_List.add(s);
                        }
                    } else {
                        order_List.add(temp_Order_List.get(0));
                    }
                }
            }
        }
    }
    return order_List.toArray(new String[order_List.size()]);
}

जब तक आप केवल एक उच्चारण मुक्त अंग्रेजी में तारों को क्रमबद्ध नहीं कर रहे हैं, तो आप शायद एक Collator का उपयोग करना चाहते हैं। यह सही ढंग से विशिष्ट अंक को क्रमबद्ध करेगा, केस और अन्य भाषा-विशिष्ट सामग्री को अनदेखा कर सकता है:

Collections.sort(countries, Collator.getInstance(new Locale(languageCode)));

आप कोलाटर की ताकत सेट कर सकते हैं, जावाडोक देखें।

स्लोवाक के लिए यहां एक उदाहरण दिया गया है:

List<String> countries = Arrays.asList("Slovensko", "Švédsko", "Turecko");

Collections.sort(countries);
System.out.println(countries); // outputs [Slovensko, Turecko, Švédsko]

Collections.sort(countries, Collator.getInstance(new Locale("sk")));
System.out.println(countries); // outputs [Slovensko, Švédsko, Turecko]

जावा 8 में ही: -

//Assecnding order
        listOfCountryNames.stream().sorted().forEach((x) -> System.out.println(x));

//Decending order
        listOfCountryNames.stream().sorted((o1, o2) -> o2.compareTo(o1)).forEach((x) -> System.out.println(x));

देर आए दुरुस्त आए! यहां बताया गया है कि हम इसे कैसे कर सकते हैं-

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

class SoftDrink {
    String name;
    String color;
    int volume; 

    SoftDrink (String name, String color, int volume) {
        this.name = name;
        this.color = color;
        this.volume = volume;
    }
}

public class ListItemComparision {
    public static void main (String...arg) {
        List<SoftDrink> softDrinkList = new ArrayList<SoftDrink>() ;
        softDrinkList .add(new SoftDrink("Faygo", "ColorOne", 4));
        softDrinkList .add(new SoftDrink("Fanta",  "ColorTwo", 3));
        softDrinkList .add(new SoftDrink("Frooti", "ColorThree", 2));       
        softDrinkList .add(new SoftDrink("Freshie", "ColorFour", 1));

        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((SoftDrink)softDrinkOne).name
                        .compareTo(((SoftDrink)softDrinkTwo).name);
            }
        }); 
        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.name + " - " + sd.color + " - " + sd.volume);
        }
        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //comparision for primitive int uses compareTo of the wrapper Integer
                return(new Integer(((SoftDrink)softDrinkOne).volume))
                        .compareTo(((SoftDrink)softDrinkTwo).volume);
            }
        });

        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.volume + " - " + sd.color + " - " + sd.name);
        }   
    }
}

यहां आप जो खोज रहे हैं वह यहां है

listOfCountryNames.sort(String::compareToIgnoreCase)

Collections.sort() का उपयोग करके, हम एक सूची को सॉर्ट कर सकते हैं।

public class EmployeeList {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<String> empNames= new ArrayList<String>();

        empNames.add("sudheer");
        empNames.add("kumar");
        empNames.add("surendra");
        empNames.add("kb");

        if(!empNames.isEmpty()){

            for(String emp:empNames){

                System.out.println(emp);
            }

            Collections.sort(empNames);

            System.out.println(empNames);
        }
    }
}

उत्पादन:

sudheer
kumar
surendra
kb
[kb, kumar, sudheer, surendra]

//Here is sorted List alphabetically with syncronized
package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;
/**
* 
* @author manoj.kumar
*/
public class SynchronizedArrayList {
static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());
@SuppressWarnings("unchecked")
public static void main(String[] args) {

List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
synchronizedList.add(new Employee("Aditya"));
synchronizedList.add(new Employee("Siddharth"));
synchronizedList.add(new Employee("Manoj"));
Collections.sort(synchronizedList, new Comparator() {
public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
//use instanceof to verify the references are indeed of the type in question
return ((Employee)synchronizedListOne).name
.compareTo(((Employee)synchronizedListTwo).name);
}
}); 
/*for( Employee sd : synchronizedList) {
log.info("Sorted Synchronized Array List..."+sd.name);
}*/

// when iterating over a synchronized list, we need to synchronize access to the synchronized list
synchronized (synchronizedList) {
Iterator<Employee> iterator = synchronizedList.iterator();
while (iterator.hasNext()) {
log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
}
}

}
}
class Employee {
String name;
Employee (String name) {
this.name = name;

}
}





alphabetical