जावा संग्रह क्रमवारी()

डेव्हलपर म्हणून डेटा हाताळताना आम्हाला आवश्यक असलेले सर्वात सामान्य कार्य म्हणजे क्रमवारी लावणे--आमच्या डेटाची क्रमवारी लावता येण्याद्वारे, आम्ही आमचे अल्गोरिदम अधिक जलद चालवण्यासाठी ऑप्टिमाइझ करू शकतो आणि त्यासाठी आवश्यक असलेला डेटा शोधू शकतो. अन्यथा घेईल. आजच्या धड्यात, आपण Java Collection sort() बद्दल बोलू. एक द्रुत विचार प्रयोग म्हणून: कल्पना करा की तुम्ही विद्यापीठाच्या रोस्टरद्वारे नाव शोधत आहात. या शाळेत हजारो विद्यार्थी असू शकतात. तुम्‍हाला दिलेले रोस्‍टर वर्णक्रमानुसार नसेल, तर तुम्‍हाला तुम्‍ही शोधत असलेले नाव सापडत नाही तोपर्यंत तुम्‍हाला प्रत्‍येक पृष्‍ठावर फ्लिप करण्‍याची आवश्‍यकता आहे आणि तुम्‍ही कोठेही एक नाव वगळले नाही याची खात्री करण्‍यासाठी अतिशय काळजीपूर्वक पहावे लागेल. दुसरीकडे, जर रोस्टर वर्णमालानुसार असेल, तर तुम्हाला तुमच्या शोधात कमी कठोर असण्याची गरज नाही, परंतु आपण त्याच पहिल्या अक्षरासह रोस्टरमधील विभागात सहजपणे उडी मारू शकता आणि आपण शोधत असलेल्या व्यक्तीवर पोहोचत नाही तोपर्यंत मोठ्या उड्या मारत पृष्ठांवर उडी मारणे सुरू ठेवा. तुम्ही जितका अधिक डेटा वापरत आहात, तितकेच तुम्ही ते शक्य तितक्या प्रभावीपणे आणि कार्यक्षमतेने वापरत आहात हे महत्त्वाचे आहे. या लेखात, आम्ही संग्रह क्रमवारी पद्धत वापरून Java (अॅरेलिस्टसह) कोणत्याही सूची अंमलबजावणीची क्रमवारी कशी लावायची ते पाहू.

Java संग्रह क्रमवारी पद्धत वापरून Java मध्ये 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() पर्यायी 2 रा पॅरामीटरने ओव्हरराईट केले आहे, जे तुम्हाला हे करण्याची परवानगी देते:

sort(List l, Comparator c)

पण तुलनाकर्ता काय आहे? बरं, तुलनाकर्ता हे फक्त एक फंक्शन आहे जे दोन इनपुट्सची तुलना करते आणि कोणता इनपुट प्रथम येतो हे दर्शवणारी संख्या मिळवते. जर तुम्ही आदिम डेटा प्रकारांची ArrayList क्रमवारी लावत असाल, तर Java Collection तुम्हाला आधीपासून एक reverseOrder() comparator प्रदान करते. याला असे म्हटले जाऊ शकते:

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

आता, रंगांची क्रमवारी उलटे जागी केली गेली आहे जेणेकरून तुम्ही ते मुद्रित केले तर तुम्हाला खालील आउटपुट मिळेल:

[Red, Orange, Green, Blue]

Java मध्ये नॉन-प्रिमिटिव्ह डेटा प्रकारांची क्रमवारी लावण्यासाठी संग्रह कसे वापरावे

आतापर्यंत, तुम्ही पाहिले आहे की Collections.sort() पद्धत वापरून Java मधील स्ट्रिंग्स किंवा इंट्सची 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;
	}
}

Collections.sort() सह आमचा कलर क्लास सुसंगत बनवण्यासाठी, कलर ऑब्जेक्ट्सची तुलना आणि क्रमवारी कशी करायची हे कलेक्शन्सना समजू शकेल, आम्हाला दोन लहान बदल करावे लागतील:

1. रंगाला तुलना करण्यायोग्य वस्तू बनवा (तुलना करण्यायोग्य अवजारे जोडा<ऑब्जेक्ट>)
2. वर्गातील compareTo पद्धत ओव्हरराइड करा (सार्वजनिक int compareTo(Object o) ओव्हरराइड करा)

या बदलांसह, आमचा वर्ग आता यासारखा दिसतो:

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);
	}
}

लक्षात घ्या की Color's compareTo पद्धत फक्त स्ट्रिंगच्या compareTo पद्धतीला कॉल करते; वर्गीकरण वर्णक्रमानुसार केले जाईल. जर आम्हाला चढत्या क्रमाने लाल मूल्यानुसार क्रमवारी लावायची असेल, उदाहरणार्थ, आम्ही रिटर्न स्टेटमेंट हे रिटर्न this.r - cr सह बदलू शकतो; (जर आम्हाला हिरव्या मूल्यानुसार उतरत्या क्रमाने क्रमवारी लावायची असेल, तर ते परतावे cg - this.g;). आता फोन केला तर

Collections.sort(colors);

फक्त स्ट्रिंग्स ऐवजी कलर्सच्या अॅरेलिस्टवर, ते कार्य करेल कारण कलेक्शन्सला कलर ऑब्जेक्ट्सची तुलना कशी करायची हे समजते. तुम्हाला तुमचा ऑब्जेक्ट Comparable<Object> लागू करायचा नसेल, तर तुम्ही पर्यायाने तुमच्या वर्गासाठी comparator लिहू शकता आणि 2-parameter Collections.sort() पद्धतीमध्ये पास करू शकता. एक तुलनाकर्ता पब्लिक इंट तुलना (ऑब्जेक्ट एक, ऑब्जेक्ट दोन) पद्धती ओव्हरराइड करतो आणि Collections.sort() पद्धत क्रमवारी लावताना ऑब्जेक्ट्सची तुलना करण्यासाठी याचा वापर करते. SortByName आणि SortByRed comparators चे उदाहरण खाली लागू केले आहे:

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());

कलर क्लासने प्रत्यक्षात तुलना करण्यायोग्य अंमलबजावणी केल्याशिवाय, आणि तरीही ते कार्य करेल. काहीवेळा, तुम्हाला हे लॅम्बडा फंक्शन्स वापरून इन-लाइन केलेले दिसेल. लॅम्बडा फंक्शन हे मूलत: एक निनावी फंक्शन आहे जे तुम्ही कोडच्या ओळीत परिभाषित करू शकता, जे त्याला कॉल करते. जेव्हा तुम्हाला फक्त एका विशिष्ट उदाहरणासाठी फंक्शन कॉल करणे आवश्यक असते आणि इतरत्र संपूर्ण स्वतंत्र फंक्शन परिभाषित करायचे नसते तेव्हा ते उपयुक्त असतात. Lambda फंक्शन वापरून SortByName तुलनाकर्ता इन-लाइन परिभाषित केला जाऊ शकतो, जसे:

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

जसे तुम्ही अंदाज लावला असेल, (a, b) लॅम्बडा फंक्शन्सचे पॅरामीटर्स (तुलना करायच्या दोन वस्तू) दर्शवते. -> याचा अर्थ लॅम्बडा फंक्शन व्याख्या आहे. त्याबद्दल आहे! आपण आता संग्रह पॅकेज वापरून Java मध्ये Arraylists क्रमवारी लावण्याच्या सर्वात लोकप्रिय पद्धती पाहिल्या आहेत.