జావాలో శ్రేణులు

నిల్వ గదిలో క్యాబినెట్లను ఊహించుకోండి. వాటిలో ప్రతి దాని స్వంత సంఖ్యను కలిగి ఉంటుంది మరియు వాటిలో ప్రతి ఒక్కటి కొన్ని బ్యాగేజీ వస్తువును నిల్వ చేస్తుంది. లేదా ప్రతి రకమైన వైన్‌కి నంబర్‌లు ఉన్న వైన్ జాబితా మరియు మీరు మీ డ్రింక్ నంబర్‌ను ఇవ్వడం ద్వారా ఆర్డర్ చేయండి. లేదా "ఆడమ్స్" మొదటి స్థానంలో మరియు "జిమ్మెర్" చివరి స్థానంలో ఉన్న విద్యార్థుల జాబితా. లేదా విమానంలో ప్రయాణీకుల జాబితా, వీరిలో ప్రతి ఒక్కరికి ఒక నంబర్ సీటు కేటాయించబడుతుంది. జావాలో, శ్రేణులు తరచుగా అటువంటి నిర్మాణాలతో పని చేయడానికి ఉపయోగించబడతాయి, అనగా సజాతీయ డేటా సెట్లు.

అర్రే అంటే ఏమిటి?

శ్రేణి అనేది ఒకే రకమైన మూలకాలను నిల్వ చేసే డేటా నిర్మాణం. మీరు దీన్ని సంఖ్యా కణాల సమితిగా భావించవచ్చు. మీరు ప్రతి సెల్‌లో కొంత డేటాను ఉంచవచ్చు (ఒక సెల్‌కి ఒక డేటా మూలకం). నిర్దిష్ట సెల్ దాని సంఖ్యను ఉపయోగించి యాక్సెస్ చేయబడుతుంది. శ్రేణిలోని మూలకం యొక్క సంఖ్యను సూచిక అని కూడా అంటారు . జావాలో, ఒక శ్రేణి సజాతీయంగా ఉంటుంది, అనగా దాని అన్ని సెల్‌లు ఒకే రకమైన మూలకాలను కలిగి ఉంటాయి. అందువల్ల, పూర్ణాంకాల శ్రేణిలో పూర్ణాంకాలు ( పూర్ణాంక ) మాత్రమే ఉంటాయి, స్ట్రింగ్‌ల శ్రేణి - స్ట్రింగ్‌లు మాత్రమే ఉంటాయి మరియు మేము సృష్టించిన డాగ్ క్లాస్‌లోని ఉదాహరణల శ్రేణిలో కుక్క వస్తువులు మాత్రమే ఉంటాయి . మరో మాటలో చెప్పాలంటే, శ్రేణిలోని మొదటి సెల్‌లో పూర్ణాంకాన్ని, రెండవదానిలో స్ట్రింగ్‌ను మరియు మూడవదానిలో కుక్కను ఉంచడానికి జావా అనుమతించదు .

శ్రేణిని ప్రకటిస్తోంది

మీరు శ్రేణిని ఎలా ప్రకటిస్తారు?

ఏదైనా వేరియబుల్ లాగా, జావాలో శ్రేణిని ప్రకటించాలి. ఇది రెండు మార్గాలలో ఒకదానిలో చేయవచ్చు. అవి సమానమైనవి, కానీ మొదటి మార్గం జావా శైలితో మరింత స్థిరంగా ఉంటుంది. రెండవది C భాష యొక్క వారసత్వం: చాలా మంది C ప్రోగ్రామర్లు జావాకు మారారు మరియు వారి సౌలభ్యం కోసం ఒక ప్రత్యామ్నాయ పద్ధతిని ఉంచారు. పట్టిక జావాలో శ్రేణిని ప్రకటించే రెండు మార్గాలను చూపుతుంది: రెండు సందర్భాల్లో, డేటాటైప్ అనేది శ్రేణిలోని వేరియబుల్స్ రకం. ఉదాహరణలలో, మేము రెండు శ్రేణులను ప్రకటించాము. ఒకటి int లను నిల్వ చేస్తుంది మరియు మరొకటి - వస్తువు వస్తువులు. అందువలన, శ్రేణి డిక్లరేషన్ పేరు మరియు రకాన్ని కలిగి ఉంటుంది (అరే యొక్క మూలకాల రకం). ArrayName అనేది శ్రేణి పేరు.

శ్రేణిని సృష్టిస్తోంది

మీరు శ్రేణిని ఎలా సృష్టిస్తారు?

ఏదైనా ఇతర వస్తువు వలె, మీరు కొత్త ఆపరేటర్‌ని ఉపయోగించి జావా శ్రేణిని సృష్టించవచ్చు, అనగా దాని కోసం మెమరీలో ఒక స్థలాన్ని రిజర్వ్ చేయండి . ఇది ఎలా జరుగుతుంది:

new typeOfArray[length]; 

ఇక్కడ typeOfArray అనేది శ్రేణి రకం మరియు పొడవు దాని పొడవు (అంటే కణాల సంఖ్య) మొత్తం సంఖ్య ( int)గా వ్యక్తీకరించబడింది. కానీ ఇక్కడ మేము శ్రేణి కోసం మెమరీని మాత్రమే కేటాయించామని గమనించండి — మేము డిక్లేర్డ్ చేసిన శ్రేణిని ఇంతకు ముందు ప్రకటించిన వేరియబుల్‌తో అనుబంధించలేదు. సాధారణంగా, ఒక శ్రేణి మొదట డిక్లేర్ చేయబడుతుంది మరియు తక్షణమే చేయబడుతుంది, ఉదాహరణకు:

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

ఇక్కడ మేము myArray అని పిలువబడే పూర్ణాంకాల శ్రేణిని సృష్టించాము , ఇది 10 సెల్‌లను కలిగి ఉంటుందని కంపైలర్‌కు తెలియజేస్తుంది (వీటిలో ప్రతి ఒక్కటి పూర్ణాంకం కలిగి ఉంటుంది). అయినప్పటికీ, శ్రేణిని ప్రకటించబడిన వెంటనే దానిని సృష్టించడానికి క్రింది సంక్షిప్త వాక్యనిర్మాణాన్ని ఉపయోగించడం చాలా సాధారణం:

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

దయచేసి గమనించండి:కొత్త ఆపరేటర్‌ని ఉపయోగించి శ్రేణి సృష్టించబడిన తర్వాత , దాని సెల్‌లు డిఫాల్ట్ విలువలను కలిగి ఉంటాయి. సంఖ్యా రకాల కోసం (మా ఉదాహరణలో వలె), డిఫాల్ట్ విలువ 0, బూలియన్ రకానికి, ఇది తప్పు , మరియు సూచన రకాల కోసం, ఇది శూన్యం . అందువలన, ఈ ప్రకటనను అమలు చేసిన తర్వాత

int[] myArray = new int[10];

మేము పది పూర్ణాంకాల శ్రేణిని పొందుతాము మరియు ప్రోగ్రామ్ విలువలను మార్చడానికి ఏదైనా చేసే వరకు, ప్రతి సెల్ 0ని కలిగి ఉంటుంది.

జావాలో అర్రే పొడవు

మేము పైన చెప్పినట్లుగా, శ్రేణి యొక్క పొడవు అనేది శ్రేణిని ఉంచడానికి రూపొందించబడిన మూలకాల సంఖ్య. శ్రేణిని సృష్టించిన తర్వాత దాని పొడవు మార్చబడదు. దయచేసి గమనించండిఆ శ్రేణి మూలకాలు జావాలో సున్నా నుండి ప్రారంభించబడతాయి. ఈ విధంగా, మనకు 10 మూలకాల శ్రేణి ఉంటే, అప్పుడు మొదటి మూలకం యొక్క సూచిక 0 మరియు చివరిది యొక్క సూచిక 9. మీరు పొడవు వేరియబుల్ ఉపయోగించి శ్రేణి పొడవును పొందవచ్చు . ఉదాహరణకి:

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

అవుట్‌పుట్:

10

శ్రేణిని ప్రారంభించడం మరియు దాని మూలకాలను యాక్సెస్ చేయడం

జావాలో శ్రేణిని ఎలా సృష్టించాలో ఇప్పుడు మనకు తెలుసు. ప్రక్రియ మాకు ఖాళీ శ్రేణిని కాదు, డిఫాల్ట్ విలువలతో నిండిన శ్రేణిని పొందుతుంది. ఉదాహరణకు, పూర్ణాంక శ్రేణికి, ఇది 0, మరియు మనకు ఏదైనా రిఫరెన్స్ రకం శ్రేణి ఉంటే, ప్రతి సెల్‌లోని డిఫాల్ట్ శూన్యం . మేము శ్రేణి మూలకాన్ని (ఉదాహరణకు, దాని విలువను సెట్ చేయడానికి, స్క్రీన్‌పై ప్రదర్శించడానికి లేదా దానితో కొంత ఆపరేషన్ చేయడానికి) దాని సూచిక ద్వారా యాక్సెస్ చేస్తాము. అర్రే ప్రారంభీకరణ అనేది నిర్దిష్ట విలువలతో (డిఫాల్ట్ కాకుండా) శ్రేణిని పూరించే ప్రక్రియ. ఉదాహరణ: 4 సీజన్‌ల కోసం స్ట్రింగ్ శ్రేణిని సృష్టించి, దానిని సీజన్‌ల పేర్లతో నింపండి.

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

ఇప్పుడు మా శ్రేణిలోని నాలుగు కణాలకు సీజన్ల పేర్లు వ్రాయబడ్డాయి. మేము డిక్లరేషన్ మరియు ఇనిషియలైజేషన్‌ని కలిపి, శ్రేణిని వేరే విధంగా ప్రారంభించవచ్చు:

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

ఇంకా ఏమిటంటే, కొత్త ఆపరేటర్‌ని విస్మరించవచ్చు:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

మీరు జావాలో స్క్రీన్‌పై శ్రేణిని ఎలా ప్రదర్శిస్తారు?

మీరు లూప్‌ని ఉపయోగించి స్క్రీన్‌పై (అంటే కన్సోల్‌లో) శ్రేణి మూలకాలను ప్రదర్శించవచ్చు . శ్రేణిని ప్రదర్శించడానికి మరొక చిన్న మార్గం " శ్రేణులతో పని చేయడానికి ఉపయోగకరమైన పద్ధతులు " అనే పేరాలో చర్చించబడుతుంది . ఈ సమయంలో, లూప్‌ని ఉపయోగించి శ్రేణి ప్రదర్శించబడే ఈ ఉదాహరణను పరిశీలించండి:

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

ప్రోగ్రామ్ కింది వాటిని ప్రదర్శిస్తుంది:

Winter 
Spring 
Summer 
Autumn

జావాలో ఒక డైమెన్షనల్ మరియు మల్టీ డైమెన్షనల్ శ్రేణులు

అయితే మనం సంఖ్యలు, స్ట్రింగ్‌లు లేదా ఇతర వస్తువుల శ్రేణిని కాకుండా శ్రేణుల శ్రేణిని సృష్టించాలనుకుంటే? దీన్ని చేయడానికి జావా మిమ్మల్ని అనుమతిస్తుంది. మనకు ఇప్పటికే తెలిసిన శ్రేణి ( int[] myArray = new int[8] ) ఒక డైమెన్షనల్ శ్రేణిగా పిలువబడుతుంది. కానీ శ్రేణుల శ్రేణిని ద్విమితీయ శ్రేణి అంటారు. ఇది వరుస సంఖ్య మరియు నిలువు వరుస సంఖ్యను కలిగి ఉన్న పట్టిక లాంటిది. లేదా, మీరు లీనియర్ ఆల్జీబ్రా యొక్క ప్రాథమికాలను నేర్చుకున్నట్లయితే, మీరు దానిని మాతృకగా భావించవచ్చు. మనకు అలాంటి శ్రేణులు ఎందుకు అవసరం? బాగా, మాత్రికలు మరియు పట్టికలను ప్రోగ్రామ్ చేయడానికి, అలాగే ఇదే విధమైన నిర్మాణాన్ని కలిగి ఉన్న ఇతర వస్తువులు. ఉదాహరణకు, చదరంగం బోర్డ్‌ను 8x8 శ్రేణి ద్వారా సూచించవచ్చు. బహుమితీయ శ్రేణి ప్రకటించబడింది మరియు ఈ క్రింది విధంగా సృష్టించబడుతుంది:

Int[][] myTwoDimentionalArray = new int[8][8];

ఈ శ్రేణి సరిగ్గా 64 మూలకాలను కలిగి ఉంది: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1] ఇంకా myTwoDimentionalArray[1][7] Aray వరకు . కాబట్టి మనం చదరంగం బోర్డును సూచించడానికి దీనిని ఉపయోగిస్తే, A1 అనేది myTwoDimentionalArray[0][0] కి అనుగుణంగా ఉంటుంది మరియు E2 అనేది myTwoDimentionalArray[4][1] . అయితే దీన్ని మనం ఎంత దూరం నెట్టగలం? జావాలో, మీరు శ్రేణుల శ్రేణిని పేర్కొనవచ్చు... శ్రేణుల శ్రేణి మరియు మొదలైనవాటిని పేర్కొనవచ్చు. వాస్తవానికి, త్రిమితీయ మరియు అధిక-డైమెన్షనల్ శ్రేణులు చాలా అరుదుగా ఉపయోగించబడతాయి. ఉదాహరణకు, రూబిక్స్ క్యూబ్‌ను ప్రోగ్రామ్ చేయడానికి మీరు త్రిమితీయ శ్రేణిని ఉపయోగించవచ్చు.

శ్రేణులతో పని చేయడానికి ఉపయోగకరమైన పద్ధతులు

జావా శ్రేణులతో పని చేయడానికి java.util.Arrays తరగతిని కలిగి ఉంది. సాధారణంగా, శ్రేణులపై నిర్వహించబడే అత్యంత సాధారణ కార్యకలాపాలు ప్రారంభీకరణ (మూలకాలతో నింపడం), మూలకాన్ని తిరిగి పొందడం (సూచిక ద్వారా), క్రమబద్ధీకరించడం మరియు శోధించడం. శ్రేణులను శోధించడం మరియు క్రమబద్ధీకరించడం అనేది మరొక రోజుకు సంబంధించిన అంశాలు. ఒకవైపు, అనేక శోధనలు మరియు క్రమబద్ధీకరణ అల్గారిథమ్‌లను మీరే వ్రాయడం మంచి పద్ధతి. మరోవైపు, అన్ని ఉత్తమ అల్గోరిథంలు ఇప్పటికే అమలు చేయబడ్డాయి మరియు ప్రామాణిక జావా లైబ్రరీలలో చేర్చబడ్డాయి మరియు మీరు వాటిని చట్టబద్ధంగా ఉపయోగించవచ్చు. ఈ తరగతిలో మూడు ఉపయోగకరమైన పద్ధతులు ఇక్కడ ఉన్నాయి.

శ్రేణిని క్రమబద్ధీకరించడం

void sort(int[] myArray, int fromIndex, int toIndex) పద్ధతి పూర్ణాంక శ్రేణి లేదా సబ్‌అరేను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది.

శ్రేణిలో మూలకం కోసం శోధిస్తోంది

int binarySearch(int[] myArray, int fromIndex, int toIndex, int కీ) . ఈ పద్ధతి ఇండెక్స్ నుండి ఇండెక్స్ వరకు క్రమబద్ధీకరించబడిన myArray శ్రేణి లేదా subarray లో కీలక మూలకం కోసం చూస్తుంది . అంశం కనుగొనబడితే, అది దాని సూచికను అందిస్తుంది. లేకపోతే, అది (-ఇండెక్స్ నుండి)-1ని అందిస్తుంది .

శ్రేణిని స్ట్రింగ్‌గా మారుస్తోంది

String toString(int[] myArray) పద్ధతి శ్రేణిని స్ట్రింగ్‌గా మారుస్తుంది. జావాలో, శ్రేణులు స్ట్రింగ్() కు భర్తీ చేయవు . దీనర్థం మీరు " స్క్రీన్‌పై ఒక శ్రేణిని ప్రదర్శించు " అనే పేరాలో ఉన్న విధంగా ఒకేసారి ఒక మూలకం కాకుండా మొత్తం శ్రేణిని ఒకేసారి (System.out.println(myArray)) ప్రదర్శించడానికి ప్రయత్నిస్తే , మీరు పొందుతారు తరగతి పేరు మరియు శ్రేణి యొక్క హెక్సాడెసిమల్ హాష్ ( Object.toString() ద్వారా నిర్వచించబడింది ). మీరు ఒక అనుభవశూన్యుడు అయితే, toString పద్ధతి గురించిన వివరణ మీకు అర్థం కాకపోవచ్చు . ప్రారంభంలో, మీరు అవసరం లేదు, కానీ ఈ పద్ధతిని ఉపయోగించడం శ్రేణిని ప్రదర్శించడాన్ని సులభతరం చేస్తుంది. లూప్‌ని ఉపయోగించకుండా శ్రేణిని సులభంగా ప్రదర్శించడానికి జావా మిమ్మల్ని అనుమతిస్తుంది. దిగువ ఉదాహరణ దీనిని ప్రదర్శిస్తుంది.

సార్ట్, బైనరీ సెర్చ్ మరియు టోస్ట్రింగ్ ఉపయోగించి ఒక ఉదాహరణ

పూర్ణాంకాల శ్రేణిని సృష్టించి, దానిని toString ఉపయోగించి ప్రదర్శించి, క్రమబద్ధీకరణ పద్ధతిని ఉపయోగించి క్రమబద్ధీకరించి , ఆపై దానిలో కొంత సంఖ్యను కనుగొనండి.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

అవుట్‌పుట్:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

మొదటి స్ట్రింగ్ toString ఉపయోగించకుండా శ్రేణిని ప్రదర్శించే ప్రయత్నం . రెండవది toString ఉపయోగించి ప్రదర్శించబడే శ్రేణి . మూడవది క్రమబద్ధీకరించబడిన శ్రేణి. నాల్గవది క్రమబద్ధీకరించబడిన శ్రేణిలో (5) మనం శోధించిన సంఖ్య యొక్క సూచిక (మనం సున్నా నుండి లెక్కించబడతామని గుర్తుంచుకోండి, కాబట్టి శ్రేణి యొక్క నాల్గవ మూలకం యొక్క సూచిక 3). ఐదవ స్ట్రింగ్‌లో, మనకు -1 కనిపిస్తుంది. ఇది చెల్లని శ్రేణి సూచిక. మేము శోధించిన సంఖ్య (ఈ సందర్భంలో, 0) శ్రేణిలో లేదని ఇది సూచిస్తుంది.

క్లుప్తంగా శ్రేణులు

• శ్రేణి యొక్క ముఖ్యమైన లక్షణాలు: దానిలో ఉంచబడిన డేటా రకం, దాని పేరు మరియు దాని పొడవు.
  శ్రేణి సృష్టించబడినప్పుడు చివరి లక్షణం నిర్ణయించబడుతుంది (అరే కోసం మెమరీని కేటాయించినప్పుడు). శ్రేణిని ప్రకటించినప్పుడు మొదటి రెండు లక్షణాలు నిర్ణయించబడతాయి.

• శ్రేణి పరిమాణం (కణాల సంఖ్య) తప్పనిసరిగా పూర్ణాంకం అయి ఉండాలి

• శ్రేణిని సృష్టించిన తర్వాత దాని పొడవును మార్చడం అసాధ్యం.

• శ్రేణి మూలకాన్ని దాని సూచిక ద్వారా యాక్సెస్ చేయవచ్చు.

• శ్రేణులలోని మూలకాలు, జావాలోని అన్నింటిలాగే, సున్నా నుండి ప్రారంభించబడతాయి.

• శ్రేణి సృష్టించబడిన తర్వాత, అది డిఫాల్ట్ విలువలతో నింపబడుతుంది.

• జావాలోని శ్రేణులు C++లోని శ్రేణికి సమానంగా ఉండవు. అవి దాదాపు డైనమిక్ శ్రేణులకు పాయింటర్ల వలె ఉంటాయి.

శ్రేణుల గురించి ఉపయోగకరమైన పదార్థాలు

శ్రేణుల గురించి మరింత తెలుసుకోవాలనుకుంటున్నారా? దిగువ కథనాలను చూడండి. ఈ అంశంపై చాలా ఆసక్తికరమైన మరియు ఉపయోగకరమైన అంశాలు ఉన్నాయి.