అధునాతన శ్రేణి నిర్వహణ

1. Stringశ్రేణి

నేను మీకు శ్రేణుల గురించి సంక్షిప్త అవలోకనాన్ని అందించాలనుకుంటున్నాను String.

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

Scanner console = new Scanner(System.in);
String[] array = new String[10];
for (int i = 0; i < 10; i++)
{
   array[i] = console.nextLine();
}
for (int i = 9; i >= 0; i--)
{
   System.out.println(array[i]);
}

కోడ్ మారలేదు! శ్రేణిని సృష్టించేటప్పుడు మాత్రమే మేము intభర్తీ చేయాల్సి ఉంటుంది . Stringబాగా, మరియు కీబోర్డ్ నుండి స్ట్రింగ్ చదివేటప్పుడు, మేము nextInt()పద్ధతిని కూడా తో భర్తీ చేసాము nextLine().

2. Stringమెమరీలో శ్రేణి

మరియు మరొక ఉపయోగకరమైన వాస్తవం. 3 చిత్రాలను పరిశీలిద్దాం:

చిత్రం 1. ఒక Stringవస్తువు మెమరీలో ఎలా అమర్చబడింది:

ఈ చిత్రం మునుపటి పాఠాల నుండి తీసుకోబడింది.

స్ట్రింగ్ యొక్క వచనం నేరుగా వేరియబుల్‌లో నిల్వ చేయబడదని దయచేసి గమనించండి: దాని కోసం ప్రత్యేక మెమరీ బ్లాక్ కేటాయించబడింది. ఒక Stringవేరియబుల్ టెక్స్ట్‌ను నిల్వ చేసే ఆబ్జెక్ట్‌కు చిరునామా (సూచన)ని నిల్వ చేస్తుంది.

చిత్రం 2. మెమరీలో పూర్ణాంక శ్రేణి ఎలా అమర్చబడింది:

ఈ చిత్రం కూడా సుపరిచితమే.

చిత్రం 3. మెమరీలో స్ట్రింగ్ అర్రే ఎలా అమర్చబడింది:

ఎడమ వైపున మనకు అర్రే వేరియబుల్ కనిపిస్తుంది, దాని రకం String[](ఇది అర్రే ఆబ్జెక్ట్ యొక్క చిరునామాను నిల్వ చేస్తుంది).

మధ్యలో, మనకు Stringఅర్రే వస్తువు ఉంది.

మరియు కుడి వైపున కొంత వచనాన్ని నిల్వ చేసే స్ట్రింగ్ వస్తువులు ఉన్నాయి.

శ్రేణి యొక్క సెల్‌లు Stringస్ట్రింగ్‌లను స్వయంగా నిల్వ చేయవు (స్ట్రింగ్ ఆబ్జెక్ట్‌ల టెక్స్ట్). బదులుగా, వారు వారి చిరునామాలను (వాటికి సూచనలు) నిల్వ చేస్తారు. అదే విధంగా Stringవేరియబుల్స్ స్ట్రింగ్ ఆబ్జెక్ట్‌ల చిరునామాలను (టెక్స్ట్ నిల్వ చేయబడిన చోట) నిల్వ చేస్తుంది.

మీరు శ్రేణి కణాలను పోల్చినప్పుడు దీనిని పరిగణనలోకి తీసుకోండి :

String[] array = new String[10];

array[1] = "Hello";
array[2] = array[1];
array[3] = new String("Hello");
// Compare
array[1] == array[2];
array[1] == array[3];
array[1].equals(array[3]);
array[1].equalsIgnoreCase(array[3]);

3. జావాలో వేగవంతమైన శ్రేణి ప్రారంభించడం

శ్రేణులు చాలా ఉపయోగకరంగా ఉన్నాయి, కాబట్టి జావా సృష్టికర్తలు వాటితో సాధ్యమైనంత సౌకర్యవంతంగా పని చేయడానికి ప్రయత్నించారు.

వారు చేసిన మొదటి పని శ్రేణి ప్రారంభాన్ని సులభతరం చేయడం, మీరు శ్రేణి యొక్క ప్రారంభ విలువలను సరఫరా చేసే ప్రక్రియ.

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

int[] months = new int[12];
months[0] = 31; // January
months[1] = 28; // February
months[2] = 31; // March
months[3] = 30; // April
months[4] = 31; // May
months[5] = 30; // June
months[6] = 31; // July
months[7] = 31; // August
months[8] = 30; // September
months[9] = 31; // October
months[10] = 30; // November
months[11] = 31; // December

కానీ జావా సృష్టికర్తలకు ధన్యవాదాలు, దీన్ని మరింత సంక్షిప్తంగా వ్రాయడానికి ఒక మార్గం ఉంది:

// Lengths of months of the year
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

మీరు శ్రేణి యొక్క అన్ని విలువలను కామాలతో వేరు చేయవచ్చు!

అనుకూలమైనది, సరియైనదా? అయితే అంతే కాదు.

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

అంటే ఈ కోడ్ ఇంకా చిన్నదిగా వ్రాయవచ్చు:

// Lengths of months of the year
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

అందం యొక్క విషయం, కాదా? 🙂

దీనిని "ఫాస్ట్ అర్రే ఇనిషియలైజేషన్" అంటారు. మార్గం ద్వారా, ఇది కాకుండా ఇతర రకాల కోసం పని చేస్తుంది int...

// Names of months of the year
String[] months = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November ", "December"};