1. String
శ్రేణి
నేను మీకు శ్రేణుల గురించి సంక్షిప్త అవలోకనాన్ని అందించాలనుకుంటున్నాను String
.
మేము ఇంతకు ముందు చెప్పినట్లుగా, ఒక శ్రేణి ఏ రకమైనది కావచ్చు. దీని అర్థం మీరు s యొక్క శ్రేణిని సృష్టించవచ్చు String
. మేము "కీబోర్డ్ నుండి 10 పంక్తులను చదివి వాటిని రివర్స్ ఆర్డర్లో ప్రదర్శించే" ప్రోగ్రామ్ను వ్రాయాలనుకుంటే, కోడ్ ఎలా ఉంటుందో ఇక్కడ ఉంది:
|
ఒక Scanner వస్తువును సృష్టించండి 0 నుండి 9 వరకు 10-మూలకాల శ్రేణి ఆబ్జెక్ట్ లూప్ను సృష్టించండి కీబోర్డ్ నుండి స్ట్రింగ్ను చదవండి మరియు దానిని 9 నుండి 0 వరకు శ్రేణి లూప్ యొక్క తదుపరి సెల్లో సేవ్ చేయండి శ్రేణిలో తదుపరి సెల్ను ప్రదర్శించండి |
కోడ్ మారలేదు! శ్రేణిని సృష్టించేటప్పుడు మాత్రమే మేము int
భర్తీ చేయాల్సి ఉంటుంది . String
బాగా, మరియు కీబోర్డ్ నుండి స్ట్రింగ్ చదివేటప్పుడు, మేము nextInt()
పద్ధతిని కూడా తో భర్తీ చేసాము nextLine()
.
2. String
మెమరీలో శ్రేణి
మరియు మరొక ఉపయోగకరమైన వాస్తవం. 3 చిత్రాలను పరిశీలిద్దాం:
చిత్రం 1. ఒక String
వస్తువు మెమరీలో ఎలా అమర్చబడింది:
ఈ చిత్రం మునుపటి పాఠాల నుండి తీసుకోబడింది.
స్ట్రింగ్ యొక్క వచనం నేరుగా వేరియబుల్లో నిల్వ చేయబడదని దయచేసి గమనించండి: దాని కోసం ప్రత్యేక మెమరీ బ్లాక్ కేటాయించబడింది. ఒక String
వేరియబుల్ టెక్స్ట్ను నిల్వ చేసే ఆబ్జెక్ట్కు చిరునామా (సూచన)ని నిల్వ చేస్తుంది.
చిత్రం 2. మెమరీలో పూర్ణాంక శ్రేణి ఎలా అమర్చబడింది:
ఈ చిత్రం కూడా సుపరిచితమే.
చిత్రం 3. మెమరీలో స్ట్రింగ్ అర్రే ఎలా అమర్చబడింది:
ఎడమ వైపున మనకు అర్రే వేరియబుల్ కనిపిస్తుంది, దాని రకం String[]
(ఇది అర్రే ఆబ్జెక్ట్ యొక్క చిరునామాను నిల్వ చేస్తుంది).
మధ్యలో, మనకు String
అర్రే వస్తువు ఉంది.
మరియు కుడి వైపున కొంత వచనాన్ని నిల్వ చేసే స్ట్రింగ్ వస్తువులు ఉన్నాయి.
శ్రేణి యొక్క సెల్లు String
స్ట్రింగ్లను స్వయంగా నిల్వ చేయవు (స్ట్రింగ్ ఆబ్జెక్ట్ల టెక్స్ట్). బదులుగా, వారు వారి చిరునామాలను (వాటికి సూచనలు) నిల్వ చేస్తారు. అదే విధంగా String
వేరియబుల్స్ స్ట్రింగ్ ఆబ్జెక్ట్ల చిరునామాలను (టెక్స్ట్ నిల్వ చేయబడిన చోట) నిల్వ చేస్తుంది.
మీరు శ్రేణి కణాలను పోల్చినప్పుడు దీనిని పరిగణనలోకి తీసుకోండి :
|
10 స్ట్రింగ్ల శ్రేణిని సృష్టించండి శ్రేణిలో విలువలను ఉంచండి true (సూచనలు సమానంగా ఉంటాయి) false (సూచనలు సమానంగా లేవు)true (తీగలు సమానంగా ఉంటాయి) true (తీగలు ఇప్పటికీ సమానంగా ఉంటాయి) |
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"};
GO TO FULL VERSION