జావా సేకరణల క్రమబద్ధీకరణ()

డేటాతో వ్యవహరించే డెవలపర్‌లుగా మనకు అవసరమైన అత్యంత సాధారణ ఫంక్షన్‌లలో ఒకటి క్రమబద్ధీకరించడం--మా డేటాను క్రమబద్ధీకరించడం ద్వారా, మేము మా అల్గారిథమ్‌లను చాలా వేగంగా అమలు చేయడానికి ఆప్టిమైజ్ చేయవచ్చు మరియు దానికి అవసరమైన డేటాను కొంత సమయం లో కనుగొనవచ్చు. లేకపోతే పడుతుంది. నేటి పాఠంలో, మేము జావా కలెక్షన్స్ సార్ట్() గురించి మాట్లాడుతాము. త్వరిత ఆలోచన ప్రయోగంగా: మీరు విశ్వవిద్యాలయం యొక్క రోస్టర్ ద్వారా పేరు కోసం వెతుకుతున్నారని ఊహించుకోండి. ఈ పాఠశాలలో పదివేల మంది విద్యార్థులు ఉండవచ్చు. మీకు ఇచ్చిన రోస్టర్ అక్షర క్రమంలో లేకుంటే, మీరు ప్రతి ఒక్క పేజీని తిప్పికొట్టాలి మరియు మీరు వెతుకుతున్న పేరును కనుగొనే వరకు మీరు ఎక్కడా ఒక్క పేరును దాటవేయలేదని నిర్ధారించుకోవడానికి చాలా జాగ్రత్తగా చూడాలి. మరోవైపు, రోస్టర్ ఆల్ఫాబెటైజ్ చేయబడితే, మీరు మీ శోధనలో తక్కువ కఠినంగా ఉండటమే కాదు, కానీ మీరు అదే మొదటి అక్షరంతో రోస్టర్‌లోని విభాగానికి సులభంగా వెళ్లవచ్చు మరియు మీరు వెతుకుతున్న వ్యక్తిపైకి వచ్చే వరకు పెద్ద ఎత్తులో పేజీల చుట్టూ దూకడం కొనసాగించవచ్చు. మీరు ఎంత ఎక్కువ డేటాతో పని చేస్తున్నారో, మీరు దానిని సాధ్యమైనంత సమర్థవంతంగా మరియు సమర్ధవంతంగా ఉపయోగిస్తున్నారు. ఈ కథనంలో, సేకరణల క్రమబద్ధీకరణ పద్ధతిని ఉపయోగించి జావాలో (అరేలిస్ట్‌తో సహా) ఏదైనా జాబితా అమలును ఎలా క్రమబద్ధీకరించాలో చూద్దాం.

జావా కలెక్షన్స్ క్రమబద్ధీకరణ పద్ధతిని ఉపయోగించి జావాలో అర్రేలిస్ట్‌ను ఎలా క్రమబద్ధీకరించాలి

Java Collections.sort method గురించి మాట్లాడుకుందాం. java.util ప్యాకేజీ అనేక ఉపయోగకరమైన యుటిలిటీలను మరియు ప్యాకేజీలను కలిగి ఉంది, వీటిని తరచుగా డెవలపర్‌లు ఉపయోగించారు, ఇందులో అర్రేలిస్ట్ కూడా ఉంటుంది. మీరు ఈ క్రింది సాధారణ ప్రోగ్రామ్‌ని కలిగి ఉన్నారని అనుకుందాం:

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)

కానీ పోలిక అంటే ఏమిటి? సరే, కంపారిటర్ అనేది కేవలం రెండు ఇన్‌పుట్‌లను పోల్చి, ఏ ఇన్‌పుట్ మొదట వస్తుందో సూచించే సంఖ్యను అందించే ఫంక్షన్. మీరు ఆదిమ డేటా రకాల శ్రేణి జాబితాను క్రమబద్ధీకరిస్తున్నట్లయితే, జావా సేకరణలు ఇప్పటికే మీకు రివర్స్‌ఆర్డర్() కంపారిటర్‌ను అందిస్తాయి. దీనిని ఇలా పిలవవచ్చు:

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

ఇప్పుడు, రంగులు రివర్స్-ప్లేస్‌లో క్రమబద్ధీకరించబడ్డాయి, తద్వారా మీరు దానిని ప్రింట్ చేస్తే, మీరు క్రింది అవుట్‌పుట్ పొందుతారు:

[Red, Orange, Green, Blue]

జావాలో నాన్-ప్రిమిటివ్ డేటా రకాలను క్రమబద్ధీకరించడానికి సేకరణలను ఎలా ఉపయోగించాలి

ఇప్పటి వరకు, Collections.sort() పద్ధతిని ఉపయోగించి జావాలోని స్ట్రింగ్స్ లేదా ints యొక్క అర్రేలిస్ట్‌లను క్రమబద్ధీకరించడం ఒక లైన్ కోడ్ వలె సులభం అని మీరు చూసారు. కానీ తరచుగా, మీ అర్రేలిస్ట్‌లు నాన్-ప్రిమిటివ్ డేటా రకాలను నిల్వ చేస్తాయి. మీరు మరింత సంక్లిష్టమైన లక్షణాలను కలిగి ఉన్న డేటాతో పని చేస్తున్నప్పుడు, మీరు ఈ వస్తువులను సూచించడానికి తరగతులను వ్రాయాలనుకుంటున్నారు మరియు వాటి లక్షణాలను ఉపయోగించి వాటిని ఒకదానితో ఒకటి ఎలా పోల్చాలి. దీనికి ఉదాహరణను అన్వేషించడానికి, రంగుల జాబితాను క్రమబద్ధీకరించే ఉదాహరణను మళ్లీ సందర్శిద్దాం, కానీ ఈసారి, స్ట్రింగ్‌లను క్రమబద్ధీకరించడానికి బదులుగా, మేము రంగు వస్తువులను క్రమబద్ధీకరిస్తాము. మా ప్రాథమిక రంగు తరగతి ఇలా ఉండవచ్చు:

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

రంగు యొక్క compareTo పద్ధతి కేవలం స్ట్రింగ్ యొక్క compareTo పద్ధతిని పిలుస్తుందని గమనించండి; క్రమబద్ధీకరణ అక్షర క్రమంలో జరుగుతుంది. మనం ఎరుపు విలువను ఆరోహణ క్రమంలో క్రమబద్ధీకరించాలనుకుంటే, ఉదాహరణకు, రిటర్న్ స్టేట్‌మెంట్‌ను రిటర్న్ this.r - crతో భర్తీ చేయవచ్చు; (మనం ఆకుపచ్చ విలువను అవరోహణ క్రమంలో క్రమబద్ధీకరించాలనుకుంటే, అది తిరిగి cg అవుతుంది - this.g;). ఇప్పుడు, మేము కాల్ చేస్తే

Collections.sort(colors);

కేవలం స్ట్రింగ్‌ల కంటే రంగుల శ్రేణి జాబితాలో, ఇది పని చేస్తుంది ఎందుకంటే కలర్ ఆబ్జెక్ట్‌లను ఎలా పోల్చాలో కలెక్షన్‌లు అర్థం చేసుకుంటాయి. మీరు మీ ఆబ్జెక్ట్‌ని కంపేరబుల్<Object>ని అమలు చేయకూడదనుకుంటే, మీరు ప్రత్యామ్నాయంగా మీ తరగతికి కంపారిటర్‌ని వ్రాయవచ్చు మరియు దానిని 2-పారామీటర్ Collections.sort() పద్ధతికి పంపవచ్చు. ఒక కంపారిటర్ పబ్లిక్ ఇంట్ కంపేర్ (ఆబ్జెక్ట్ వన్, ఆబ్జెక్ట్ టూ) పద్ధతిని ఓవర్‌రైడ్ చేస్తుంది మరియు క్రమబద్ధీకరించేటప్పుడు వస్తువులను పోల్చడానికి Collections.sort() పద్ధతి దీనిని ఉపయోగిస్తుంది. 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)});

మీరు ఊహించినట్లుగా, (a, b) లాంబ్డా ఫంక్షన్‌ల పారామితులను సూచిస్తుంది (పోల్చవలసిన రెండు వస్తువులు). కిందిది లాంబ్డా ఫంక్షన్ నిర్వచనం అని -> సూచిస్తుంది. దాని గురించి! మీరు ఇప్పుడు సేకరణల ప్యాకేజీని ఉపయోగించి జావాలో అర్రేలిస్ట్‌లను క్రమబద్ధీకరించే అత్యంత ప్రజాదరణ పొందిన పద్ధతులను చూశారు.