वर्णमाला क्रम में सॉर्टिंग छांटना (केस असंवेदनशील)

Question

मेरे पास एक स्ट्रिंग सरणी सूची है namesजिसमें लोगों के नाम हैं। मैं वर्णमाला को वर्णमाला क्रम में क्रमबद्ध करना चाहता हूं।

ArrayList<String> names = new ArrayList<String>();
names.add("seetha");
names.add("sudhin");
names.add("Swetha");
names.add("Neethu");
names.add("ananya");
names.add("Athira");
names.add("bala");
names.add("Tony");
names.add("Karthika");
names.add("Nithin");
names.add("Vinod");
names.add("jeena");
Collections.sort(names);
for(int i=0; i<names.size(); i++)
    System.out.println(names.get(i));

मैंने उपरोक्त तरीके से सूची को क्रमबद्ध करने का प्रयास किया। लेकिन यह क्रमबद्ध सरणी को इस प्रकार प्रदर्शित कर रहा है:

Athira
Karthika
..
..
ananya
bala
...

लेकिन मैं इसे मामले को संवेदनशील नहीं बनाना चाहता। मुझे इसका परिणाम चाहिए:

ananya
Athira
bala

Answer 1

कस्टम Comparatorको मदद करनी चाहिए

Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareToIgnoreCase(s2);
    }
});

या यदि आप जावा 8 का उपयोग कर रहे हैं:

list.sort(String::compareToIgnoreCase);

Comments

क्या आप बता सकते हैं कि स्ट्रिंग s1 और s2 क्या है? और यदि पूर्णांक मान लौटाता है तो तुलनात्मक परिणाम कैसे देख सकते हैं।

— ओरो-गर्ल

@seethalakshmi यह आपकी सूची से तार है। कृपया संग्रह के स्रोतों पर एक नज़र डालें। यदि आप उस पर अधिक विवरण प्राप्त करना चाहते हैं, तो विधि

— denis.solonenko

मैं logcat. सॉर्ट की गई सूची को प्रदर्शित करना चाहता हूं। मैं ऐसा कैसे कर सकता हूं?

— ओरो-गर्ल

यह ऑब्जेक्ट के रूप में दिखाई देगा, जब तक कि आप सूची को छंटाई के बाद लूप के साथ तोड़ न दें। for (TYPE newvariable : ARRAYTYPE arrayname) { Log.i("YOURAPPTAG", newvariable); }

— कार्ट छोड़ दी गई

@ डांटे अगर आप hthe के कार्यान्वयन पर एक नज़र डालते हैं String.CASE_INSENSITIVE_ORDER, तो आप देखेंगे कि ए less10 की तुलना में ए 10 से संघनित है क्योंकि लिनन छोटा है। बॉक्स से बाहर कोई "प्राकृतिक सॉर्ट" समर्थन नहीं है, आप stackoverflow.com/questions/1262239/…

— denis.solonenko

Answer 2

सबसे आसान काम है:

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

Comments

@ अर्जुन, उत्तर के लिए धन्यवाद। मैंने A1 थ्रू A10 से ArrayList के लिए भी आपके समाधान की कोशिश की है, लेकिन A10 ने डेनिस की तरह सही ढंग से सॉर्ट नहीं किया है। किसी तरह, A10 A1 के बाद जाता है। असल में, यह ए 1, ए 10, ए 2, ए 3 आदि की तरह है। ऐसा क्यों हुआ और मैं सूची को सही ढंग से कैसे सॉर्ट कर सकता हूं?

— डांटे

@ डांटे, कि सामान्य स्ट्रिंग छँटाई है। यदि आप चाहते हैं कि A2 A10 से पहले आए, तो आपको इसे A02, आदि में बदलना होगा

— djunod

प्लस 1. एंड्रॉइड में भी काम किया। धन्यवाद और बधाई।

— प्रतिमास

@ अर्जुन को U बहुत बहुत धन्यवाद :)

— कुमार

stackoverflow मुझे इस तरह के जवाब / स्निपेट्स को बचाने के लिए एक विकल्प प्रदान करना चाहिए ..

— HB।

Answer 3

इस कोड को आज़माएं

Collections.sort(yourarraylist, new SortBasedOnName());



import java.util.Comparator;
import com.RealHelp.objects.FBFriends_Obj;
import com.RealHelp.ui.importFBContacts;

public class SortBasedOnName implements Comparator
{
public int compare(Object o1, Object o2) 
{

    FBFriends_Obj dd1 = (FBFriends_Obj)o1;// where FBFriends_Obj is your object class
    FBFriends_Obj dd2 = (FBFriends_Obj)o2;
    return dd1.uname.compareToIgnoreCase(dd2.uname);//where uname is field name
}

}

Comments

बहुत बढ़िया जवाब! मुझे लगता है कि अगर आप 'इम्प्लीमेंट्स कंपैक्टर' को 'इम्प्लीमेंट्स कम्पैटिनेटर <FBFriends_Obj> में बदलते हैं और आप FBFriends_Obj की तुलना में ऑब्जेक्ट टाइप्स बदलते हैं तो आपको dd1 और dd2 की जरूरत नहीं है। आप O1 और o2 का उपयोग सीधे स्टेटमेंट में कर सकते हैं

— FrinkTheBrave

Answer 4

उपर्युक्त उत्तरों के आधार पर, मैं अपने कस्टम क्लास ऑब्जेक्ट्स की तुलना इस तरह से करने में कामयाब रहा:

ArrayList<Item> itemList = new ArrayList<>();
...
Collections.sort(itemList, new Comparator<Item>() {
            @Override
            public int compare(Item item, Item t1) {
                String s1 = item.getTitle();
                String s2 = t1.getTitle();
                return s1.compareToIgnoreCase(s2);
            }

        });

Answer 5

आपको कस्टम तुलनित्र का उपयोग करने की आवश्यकता है जो compareToIgnoreCaseतुलना नहीं करेगा ।

Comments

मैंने इस लिंक की कोशिश की। लेकिन im घ समाधान खोजने में सक्षम नहीं है। u u plz व्याख्या करें

— andro- लड़की

Answer 6

जावा 8 से शुरू आप उपयोग कर सकते हैं Stream:

List<String> sorted = Arrays.asList(
                          names.stream().sorted(
                              (s1, s2) -> s1.compareToIgnoreCase(s2)
                          ).toArray(String[]::new)
                      );

यह उससे एक धारा प्राप्त करता है ArrayList, फिर वह इसे सुलझाता है (मामले की अनदेखी)। उसके बाद, धारा को एक सरणी में बदल दिया जाता है जिसे एक में बदल दिया जाता है ArrayList।

यदि आप परिणाम का उपयोग करके प्रिंट करते हैं:

System.out.println(sorted);

आपको निम्न आउटपुट मिलते हैं:

[ananya, Athira, bala, jeena, Karthika, Neethu, Nithin, seetha, sudhin, Swetha, Tony, Vinod]

Answer 7

दुर्भाग्य से, अब तक के सभी जवाबों को ध्यान में नहीं रखा गया है जो छँटाई करने के "a"लिए बराबर नहीं माना जाना चाहिए "A"।

String[] array = {"b", "A", "C", "B", "a"};

// Approach 1
Arrays.sort(array);
// array is [A, B, C, a, b]

// Approach 2
Arrays.sort(array, String.CASE_INSENSITIVE_ORDER);
// array is [A, a, b, B, C]

// Approach 3
Arrays.sort(array, java.text.Collator.getInstance());
// array is [a, A, b, B, C]

दृष्टिकोण 1 में किसी भी निचले मामले के पत्रों को किसी भी ऊपरी मामले के अक्षरों से अधिक माना जाता है।

दृष्टिकोण 2 इसे बदतर बनाता है, क्योंकि CASE_INSENSITIVE_ORDER मानता है "a"और "A"बराबर (तुलना परिणाम है 0)। यह छंटाई को गैर-नियतात्मक बनाता है।

दृष्टिकोण 3 (एक java.text.Collator का उपयोग करके) IMHO इसे सही तरीके से करने का एकमात्र तरीका है, क्योंकि यह मानता है "a"और "A"बराबर नहीं है, लेकिन उन्हें वर्तमान (या किसी अन्य वांछित) लोकेल के अनुसार सही क्रम में रखता है।