जावा संग्रह सॉर्ट ()

डेटा से निपटने वाले डेवलपर्स के रूप में हमें सबसे आम कार्यों में से एक की आवश्यकता होती है - हमारे डेटा को सॉर्ट करने में सक्षम होने के कारण, हम अपने एल्गोरिदम को बहुत तेज़ी से चलाने के लिए अनुकूलित कर सकते हैं, और उस समय के एक अंश में डेटा ढूंढ सकते हैं जिसकी उसे आवश्यकता है। अन्यथा ले जाएगा। आज के पाठ में, हम जावा कलेक्शंस सॉर्ट () के बारे में बात करेंगे। एक त्वरित विचार प्रयोग के रूप में: कल्पना करें कि आप विश्वविद्यालय के रोस्टर के माध्यम से एक नाम खोज रहे हैं। इस स्कूल में हजारों छात्र हो सकते हैं। यदि आपको दिया गया रोस्टर वर्णानुक्रम में नहीं था, तो आपको हर एक पृष्ठ को पलटना होगा और यह सुनिश्चित करने के लिए बहुत ध्यान से देखना होगा कि आपने कहीं भी एक भी नाम नहीं छोड़ा है, जब तक कि आप अंततः वह नाम नहीं खोज लेते जिसे आप ढूंढ रहे हैं। दूसरी ओर, यदि रोस्टर वर्णानुक्रम में था, तो न केवल आपको अपनी खोज में कम कठोर होना पड़ेगा, लेकिन आप आसानी से उसी पहले अक्षर के साथ रोस्टर में अनुभाग पर जा सकते हैं, और जब तक आप जिस व्यक्ति को ढूंढ रहे थे, उस तक पहुंचने तक बड़ी छलांग में पृष्ठों के चारों ओर कूदना जारी रख सकते हैं। आप जितने अधिक डेटा के साथ काम कर रहे हैं, उतना ही महत्वपूर्ण यह है कि आप इसका यथासंभव प्रभावी और कुशलता से उपयोग कर रहे हैं। इस लेख में, हम संग्रह सॉर्ट विधि का उपयोग करके जावा (ArrayList सहित) में किसी भी सूची कार्यान्वयन को सॉर्ट करने के बारे में जानेंगे।

जावा कलेक्शंस सॉर्ट मेथड का उपयोग करके जावा में एक ऐरेलिस्ट को कैसे सॉर्ट करें

चलिए Java Collections.sort मेथड के बारे में बात करते हैं। Java.util पैकेज में कई उपयोगी उपयोगिताएँ और पैकेज शामिल हैं जो अक्सर डेवलपर्स द्वारा उपयोग किए जाते हैं, जिसमें ArrayList भी शामिल है। मान लीजिए कि आपके पास निम्न सरल प्रोग्राम है:

import java.util.*;
import java.io.*;
class Main{
     public static void main(String[] args){
          List<String> colors = new ArrayList<String>();
          colors.add("Red    ");
          colors.add("Orange");
          colors.add("Green");
          colors.add("Blue");
    }
}

आप रंगों की सूची को प्रिंट करने में सक्षम होना चाहते हैं, लेकिन वर्णानुक्रम में। आप यह कैसे कर सकते हैं? Java.util.Collections का उपयोग करना, छँटाई करना वन-लाइनर जितना आसान है:

Collections.sort(colors);

ता-दा! आपकी रंग सूची अब यथास्थान क्रमित कर दी गई है। यदि आप सूची का प्रिंट आउट लेना चाहते हैं, तो:

System.out.println(colors);

तब आपको निम्न आउटपुट मिलेगा:

[Blue, Green, Orange, Red]

वह कितना आसान था ?! उस मामले के लिए इंटीजर, फ्लोट्स या किसी अन्य सरल डेटा प्रकार की सूची को आरोही क्रम में सॉर्ट करने के लिए Collections.sort() का उपयोग करना उतना ही आसान होगा। लेकिन क्या होगा यदि आप अवरोही क्रम में क्रमबद्ध करना चाहते हैं? ऐसे मामले निश्चित रूप से हैं जहां यह समझ में आता है - कल्पना करें कि आपके पास एक निश्चित कक्षा के लिए टेस्ट स्कोर की एक सूची थी, और आप यह पता लगाना चाहते थे कि शीर्ष स्कोरिंग छात्र कौन हैं। सूची को अवरोही क्रम (सबसे पहले उच्चतम स्कोर) में क्रमबद्ध करने के लिए और अधिक समझदारी होगी, ताकि आप जिन उत्तरों की तलाश कर रहे हैं वे शीर्ष पर हों। शुक्र है, Collections.sort() एक वैकल्पिक दूसरे पैरामीटर के साथ ओवरराइट किया गया है, जो आपको ऐसा करने की अनुमति देता है:

sort(List l, Comparator c)

लेकिन एक तुलनित्र क्या है? खैर, एक तुलनित्र केवल एक फ़ंक्शन है जो दो इनपुट की तुलना करता है और एक संख्या देता है जो दर्शाता है कि कौन सा इनपुट पहले आता है। यदि आप आदिम डेटा प्रकारों के एक ArrayList को सॉर्ट कर रहे हैं, तो जावा कलेक्शंस आपको पहले से ही एक रिवर्सऑर्डर () तुलनित्र प्रदान करता है। इसे इस प्रकार कहा जा सकता है:

Collections.sort(colors, Collections.reverseOrder());

अब, रंगों को इन-प्लेस रिवर्स सॉर्ट किया गया है ताकि यदि आप इसे प्रिंट करते हैं, तो आपको निम्न आउटपुट प्राप्त होगा:

[Red, Orange, Green, Blue]

जावा में गैर-आदिम डेटा प्रकारों को सॉर्ट करने के लिए संग्रह का उपयोग कैसे करें

अब तक, आपने देखा है कि Java में Collections.sort() मेथड का उपयोग करके स्ट्रिंग्स या इनट्स की ArrayLists को सॉर्ट करना कोड की एक लाइन जितना आसान है। लेकिन कई बार, आपके ArrayLists गैर-आदिम डेटा प्रकारों को संग्रहित करेंगे। जब आप अधिक जटिल विशेषताओं वाले डेटा के साथ काम कर रहे हैं, तो आप इन वस्तुओं का प्रतिनिधित्व करने के लिए कक्षाएं लिखना चाहेंगे और उनकी विशेषताओं का उपयोग करके उनकी एक दूसरे से तुलना कैसे की जाएगी। इसका एक उदाहरण तलाशने के लिए, रंगों की सूची को क्रमबद्ध करने के उदाहरण पर दोबारा गौर करें, लेकिन इस बार, स्ट्रिंग्स को क्रमबद्ध करने के बजाय, हम कलर ऑब्जेक्ट्स को सॉर्ट करेंगे। हमारा मूल रंग वर्ग कुछ इस तरह दिख सकता है:

public class Color{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(String name, int red, int green, int blue){
   	this.name = name;
    	this.r = red;
   	this.g = green;
   	this.b = blue;
	}
}

हमारे कलर क्लास को कलेक्शंस.सॉर्ट () के साथ संगत बनाने के लिए, ताकि कलेक्शंस समझ सकें कि कलर ऑब्जेक्ट्स की तुलना और सॉर्ट कैसे करें, हमें दो छोटे संशोधन करने की जरूरत है:

1. रंग को एक तुलनीय वस्तु बनाएं (तुलनीय उपकरण जोड़ें <ऑब्जेक्ट>)
2. कक्षा में तुलना विधि को ओवरराइड करें (सार्वजनिक int तुलना को ओवरराइड करें (ऑब्जेक्ट ओ))

इन संशोधनों के साथ, हमारी कक्षा अब इस तरह दिखती है:

public class Color implements Comparable<Object>{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(int red int green, int blue, String name){
    	this.r = red;
   	this.g = green;
   	this.b = blue;
   	this.name = name;
	}

	@Override
	public int compareTo(Object o) {
    	Color c = (Color) o;
    	return this.name.compareTo(c.name);
	}
}

ध्यान दें कि रंग की तुलना करने की विधि केवल स्ट्रिंग की तुलना करने की विधि को कॉल करती है; छँटाई वर्णानुक्रम में की जाएगी। यदि हम आरोही क्रम में लाल मान द्वारा क्रमबद्ध करना चाहते हैं, उदाहरण के लिए, हम रिटर्न स्टेटमेंट को वापसी के साथ बदल सकते हैं। r - cr; (यदि हम अवरोही क्रम में हरे मूल्य के आधार पर छाँटना चाहते हैं, तो यह वापसी cg - this.g;) होगी। अब अगर हम फोन करते हैं

Collections.sort(colors);

केवल स्ट्रिंग्स के बजाय रंगों की एक ऐरेलिस्ट पर, यह काम करेगा क्योंकि संग्रह समझता है कि रंग वस्तुओं की तुलना कैसे करें। यदि आप अपनी वस्तु को तुलनीय <ऑब्जेक्ट> लागू नहीं करना चाहते हैं, तो आप वैकल्पिक रूप से अपनी कक्षा के लिए एक तुलनित्र लिख सकते हैं, और उसे 2-पैरामीटर संग्रह.सॉर्ट () विधि में पास कर सकते हैं। एक तुलनित्र एक विधि सार्वजनिक int तुलना (ऑब्जेक्ट एक, ऑब्जेक्ट दो) को ओवरराइड करता है, और संग्रह.सॉर्ट () विधि सॉर्ट करते समय वस्तुओं की तुलना करने के लिए इसका उपयोग करती है। SortByName और SortByRed तुलनित्रों का एक उदाहरण नीचे लागू किया गया है:

class SortByName implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.name.compareTo(b.name);
	}
}

class SortByRGB implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.r - b.r;
	}
}

इससे अब आप कॉल कर सकते हैं

Collections.sort(colors, new SortByName());

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

Collections.sort(colors, (a, b)-> {
          return a.name.compareTo(b.name)});

जैसा कि आपने अनुमान लगाया होगा, (ए, बी) लैम्ब्डा फ़ंक्शंस के पैरामीटर का प्रतिनिधित्व करता है (दो वस्तुओं की तुलना की जानी चाहिए)। -> दर्शाता है कि लैम्ब्डा फ़ंक्शन परिभाषा क्या है। यह इसके बारे में! अब आपने संग्रह पैकेज का उपयोग करके जावा में ArrayLists को सॉर्ट करने का सबसे लोकप्रिय तरीका देखा है।