CodeGym /జావా కోర్సు /All lectures for TE purposes /శ్రేణుల తరగతి, భాగం 2

శ్రేణుల తరగతి, భాగం 2

All lectures for TE purposes

స్థాయి , పాఠం

అందుబాటులో ఉంది

"రిషీ, నేను అర్రేస్ క్లాస్‌లోని మిగిలిన పద్ధతుల గురించి తెలుసుకోవడానికి చాలా ఆత్రుతగా ఉన్నాను.

"అటువంటి నేర్చుకునే ఉత్సాహం మీ పాత గురువును సంతోషపెట్టదు! కానీ, మీరు నిజంగా ప్రతిదీ తెలుసుకోవాలనుకుంటే, గూగుల్ అనే దయగల తాంత్రికుడు మీకు పగలు మరియు రాత్రి సహాయం చేస్తాడు."

"ఊ..."

"జస్ట్ తమాషా చేస్తున్నాను. అయితే, నేను ప్రతిదీ బాగా వివరిస్తాను, కానీ ఏదైనా వస్తే - మంచి తాంత్రికుడిని గుర్తుంచుకోండి. నేను ఈ రోజు పాఠాన్ని పద్ధతితో ప్రారంభిస్తాను Arrays.fill.

"శ్రేణులతో పని చేస్తున్నప్పుడు, జావా ప్రోగ్రామర్లు చాలా తరచుగా అదే విలువతో శ్రేణిని పూరించాలి. మీరు లూప్‌ని వ్రాయవచ్చు మరియు లూప్‌లోని శ్రేణిలోని ప్రతి సెల్‌కి కొంత విలువను కేటాయించవచ్చు:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

"లేదా వీటన్నింటికీ బదులుగా, మీరు Arrays.fill()పద్ధతిని కాల్ చేయవచ్చు, ఇది సరిగ్గా అదే పని చేస్తుంది: ఇది పాస్ చేసిన శ్రేణిని పాస్ చేసిన విలువతో నింపుతుంది. ఇది ఎలా కనిపిస్తుందో ఇక్కడ ఉంది:

Arrays.fill(name, value)

మరియు పై ఉదాహరణలోని కోడ్‌ను కొంచెం కాంపాక్ట్ మరియు స్పష్టంగా చేయవచ్చు:

int[] x = new int[100];
Arrays.fill(x, 999);

"అందం!"

Arrays.fill()"మీరు మొత్తం శ్రేణిని పూరించడానికి కూడా పద్ధతిని ఉపయోగించవచ్చు , కానీ దానిలో కొంత భాగాన్ని కొంత విలువతో పూరించవచ్చు:

Arrays.fill(name, first, last, value)

" పూర్తి చేయవలసిన మొదటి మరియు చివరి సెల్‌ల సూచికలు మొదటి మరియు చివరివి .

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

ఉదాహరణ:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

మేము సెల్‌లను x[3], x[4], x[5]మరియు x[6]విలువతో నింపుతున్నాము 999. శ్రేణి యొక్క సెల్‌లు సున్నా నుండి ప్రారంభించబడతాయి!

వేరియబుల్ strవిలువను కలిగి ఉంటుంది
"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

" Arrays.fill()పద్ధతి ఒక డైమెన్షనల్ శ్రేణులతో మాత్రమే పని చేస్తుంది. మీరు పద్ధతికి ద్విమితీయ శ్రేణిని పాస్ చేస్తే, అది అన్ని తదుపరి పరిణామాలతో ఒక డైమెన్షనల్‌గా పరిగణించబడుతుంది.

`Arrays.copyOf()`

"అమిగో, శ్రేణిని సృష్టించిన తర్వాత దాని పరిమాణాన్ని ఎలా మార్చాలో దయచేసి నాకు చెప్పండి?"

"అమ్మో... ఇది ఒక ట్రిక్ క్వశ్చన్, అవునా? నేను ఇకపై అంత అనుభవం లేనివాడిని కాదు. సరైన సమాధానం మీరు చేయలేరు! మీరు శ్రేణిని సృష్టించిన తర్వాత దాని పరిమాణం మార్చలేరు."

"అయితే నీకు నిజంగా కావాలంటే?"

"ఇది ఇప్పటికీ అసాధ్యం!

"వాస్తవానికి, మీరు నిజంగా కోరుకుంటే, మీరు చేయవచ్చు! ప్రోగ్రామింగ్ ట్రిక్ సహాయంతో:

ముందుగా, మీరు కోరుకున్న పొడవు యొక్క కొత్త శ్రేణిని సృష్టించండి
అప్పుడు మీరు మొదటి శ్రేణి నుండి అన్ని మూలకాలను దానిలోకి కాపీ చేస్తారు.

"పద్ధతి చేసే రెండు పనులు ఇవి Arrays.copyOf(). ఇలా పిలవడం ఇలా కనిపిస్తుంది:

Type[] name2 = Arrays.copyOf(name, length);

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

" కొత్త శ్రేణి యొక్క పొడవు ఇప్పటికే ఉన్న దాని పొడవు కంటే తక్కువగా ఉంటే ఏమి చేయాలి ?

"గొప్ప ప్రశ్న, అమిగో! మూలకాలు సరిపోకపోతే, అదనపు విలువలు విస్మరించబడతాయి."

"మరియు, దీనికి విరుద్ధంగా, అదనపు కణాలు ఉంటే, వాటి ప్రారంభ విలువలు ఏమిటి?

"కొత్త శ్రేణి యొక్క పొడవు పాత దాని పొడవు కంటే ఎక్కువగా ఉంటే, కణాలు సున్నాలతో నిండి ఉంటాయి.

ఉదాహరణ:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

వేరియబుల్ str2విలువను కలిగి ఉంటుంది వేరియబుల్ విలువను కలిగి ఉంటుంది
"[1, 2, 3, 4, 5]"

str3
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

`Arrays.copyOfRange()`

"మరియు మీరు పొడవు 10 యొక్క శ్రేణి నుండి పొడవు 5 యొక్క శ్రేణిని పొందాలనుకుంటే, కానీ మీరు మొదటి 5 కంటే చివరి 5 మూలకాలను కలిగి ఉండాలంటే ఏమి చేయాలి? ఈ సందర్భంలో, మీకు తరగతి యొక్క మరొక పద్ధతి అవసరం. Arraysఇది Arrays.copyOfRange()కాల్ చేయడం ఇలా కనిపిస్తుంది:

Type[] name2 = Arrays.copyOfRange(name, first, last);

"ఈ పద్ధతి కొత్త శ్రేణిని కూడా సృష్టిస్తుంది, కానీ అసలు శ్రేణిలోని ఏకపక్ష స్థలం నుండి మూలకాలతో నింపుతుంది. మొదటి మరియు చివరి మూలకాల సూచికలు కొత్త శ్రేణిలో ఉంచాల్సినవి. మీరు నాకు చెప్పగలరా చివరి మూలకం ఈ పరిధిలో చేర్చబడిందా?"

"హా! నా గొప్ప గురువు చెప్పినట్లు, ' జావా యొక్క మంచి (లేదా చెడు) పాత సంప్రదాయానికి అనుగుణంగా, చివరి మూలకం పరిధిలో చేర్చబడలేదని గుర్తుంచుకోండి ."

“ఏమిగో, నువ్వు మా కళ్ల ముందే పెరుగుతున్నావు.

ఉదాహరణ:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

వేరియబుల్ str2విలువను కలిగి ఉంటుంది వేరియబుల్ విలువను కలిగి ఉంటుంది
"[16, 17, 18, 19, 20]"

str3
"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

`Arrays.sort()`

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

శ్రేణిని క్రమబద్ధీకరించడం
శ్రేణి యొక్క కనిష్ట (లేదా గరిష్ట) మూలకాన్ని కనుగొనడం
శ్రేణిలోని మూలకం యొక్క సూచికను నిర్ణయించడం (శ్రేణిలో ఒక మూలకాన్ని కనుగొనడం)

"మంచి పనితీరు గల సార్టింగ్ అల్గారిథమ్‌లు, వ్రాయడం అంత సులభం కాదని నేను తప్పక చెప్పాలి. మరింత ఖచ్చితంగా చెప్పాలంటే, ఇది ఒక ప్రామాణిక పని, మరియు విద్యార్థిగా, కొన్నిసార్లు సార్టింగ్ అల్గారిథమ్‌లు రాయడం ప్రాక్టీస్ చేయడం మీకు హాని కలిగించదు. కానీ పనిలో, ఇది చక్రాన్ని మళ్లీ ఆవిష్కరించడంలో మీ సమయాన్ని వృథా చేసుకోకుండా ఉండటం మంచిది. జావా సృష్టికర్తలు ఈ sort()పద్ధతిని తరగతిలో చేర్చారు Arrays. ఇది ఇలా కనిపిస్తుంది:

Arrays.sort(name);

ఈ పద్ధతి ఆమోదించబడిన శ్రేణిని ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది.

ఉదాహరణ:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

వేరియబుల్ strవిలువను కలిగి ఉంటుంది
"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

"అద్భుతం! నేను కేవలం ఒక పద్ధతిని పిలిచాను మరియు శ్రేణి క్రమబద్ధీకరించబడింది. అందం యొక్క విషయం!"

"అయితే, మీరు మొత్తం శ్రేణిని మాత్రమే కాకుండా, దానిలో కొంత భాగాన్ని కూడా క్రమబద్ధీకరించవచ్చు. ఇది ఇలా కనిపిస్తుంది:

Arrays.sort(name, first, last);

" క్రమం తాకవలసిన మొదటి మరియు చివరి సెల్‌ల సూచికలు మొదటి మరియు చివరివి . మరియు ...

"మీరు ఏమి చెప్పబోతున్నారో నాకు ఇప్పటికే తెలుసు! 'జావా యొక్క మంచి (లేదా చెడు) పాత సంప్రదాయానికి అనుగుణంగా, చివరి మూలకం పరిధిలో చేర్చబడలేదని గుర్తుంచుకోండి' .

ఉదాహరణ:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

వేరియబుల్ strవిలువను కలిగి ఉంటుంది
"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

"శ్రేణులను క్రమబద్ధీకరించడానికి, జావా వేగవంతమైన క్రమబద్ధీకరణ అల్గారిథమ్‌ను ఉపయోగిస్తుంది - క్విక్‌సార్ట్ . దీని గణన సంక్లిష్టత శ్రేణి పరిమాణంపై ఆధారపడి ఉంటుంది మరియు N లాగ్(N) సూత్రాన్ని ఉపయోగించి లెక్కించబడుతుంది.

"1000 మూలకాల శ్రేణిని క్రమబద్ధీకరించడం అనేది శ్రేణి మూలకాల యొక్క 10,000 పోలికలను కలిగి ఉంటుంది. ఒక మిలియన్ మూలకాల శ్రేణిని క్రమబద్ధీకరించడం దాదాపు 20 మిలియన్ పోలికలను కలిగి ఉంటుంది."

" మీరు మూలకాల సంఖ్యను పరిగణనలోకి తీసుకున్నప్పుడు చాలా పోలికలు లేవు!"

"నేను చెప్పేది సరిగ్గా అదే. QuickSort అల్గోరిథం చాలా ప్రభావవంతంగా ఉంటుంది.

`Arrays.binarySearch()`

"సరే, మరియు క్లాస్ యొక్క అత్యంత ఆసక్తికరమైన పద్ధతుల్లో చివరిది Arraysశ్రేణిలో ఇచ్చిన విలువ కోసం శోధించగలదు. ఇది సాధారణ శోధన కాదు - ఇది ప్రియమైన బైనరీ శోధన . ఇది ఇలా ఉంటుంది:

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

"అరే క్రమబద్ధీకరించబడినందున, దానిలో సగాన్ని ఒకే పోలికలో తొలగించడం సాధ్యమవుతుంది. తర్వాతి దశలో, మేము మరొక సగాన్ని విసిరివేస్తాము, మొదలైనవి."

"అద్భుతం! మేము చాలా త్వరగా లక్ష్యాన్ని చేరుకుంటాము!"

"సరిగ్గా. ఒక మిలియన్ (!) మూలకాల శ్రేణిలో, బైనరీ శోధన అల్గోరిథం కేవలం 20 పోలికలలో కావలసిన మూలకం యొక్క సూచికను కనుగొనగలదు. అల్గారిథమ్ యొక్క లోపం ఏమిటంటే శ్రేణిని మొదట క్రమబద్ధీకరించాలి మరియు క్రమబద్ధీకరించడానికి కూడా సమయం పడుతుంది.

కాల్ చేయడం ఇలా కనిపిస్తుంది:

int index = Arrays.binarySearch(name, value);

" nameఅరే పేరు ఎక్కడ ఉంది, ఇది ఇప్పటికే క్రమబద్ధీకరించబడి ఉండాలి (ఉదాహరణకు, పద్ధతిని ఉపయోగించి Arrays.sort()). మరియు valueమేము శ్రేణిలో వెతుకుతున్న మూలకం. పద్ధతి ద్వారా అందించబడిన ఫలితం కావలసిన శ్రేణి మూలకం యొక్క సూచిక. .

ఉదాహరణలు:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

x
{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

4
1(సూచికలు మరియు 0ఆమోదయోగ్యమైనవి 2)
8
-7

"అవసరమైన మూలకం శ్రేణిలో అనేకసార్లు కనిపిస్తే ఏమి చేయాలి ?"

"ఇది చెల్లుబాటు అయ్యే ప్రశ్న, అమిగో. ఈ సందర్భంలో, అల్గోరిథం వాటిలో ఒకదాని యొక్క సూచికను తిరిగి ఇస్తుంది (ఇది మొదటిది, లేదా దీనికి విరుద్ధంగా — ఈ నకిలీ మూలకాలలో చివరిది అని ఎటువంటి హామీ లేదు) ."

"శ్రేణిలో కావలసిన మూలకం లేకుంటే ఏమి చేయాలి?"

"ఈ సందర్భంలో, అల్గోరిథం ప్రతికూల సూచికను అందిస్తుంది .

డాక్యుమెంటేషన్

"అంతా స్పష్టంగా ఉంది, రిషీ! ఇది చాలా ఆసక్తికరంగా ఉంది."

"మీకు ఇది నిజంగా చాలా ఆసక్తికరంగా అనిపిస్తే, మీ తీరిక సమయంలో ఒరాకిల్ వెబ్‌సైట్‌లోని క్లాస్ యొక్క అధికారిక డాక్యుమెంటేషన్ Arraysమరియు దాని పద్ధతుల ద్వారా స్కిమ్ చేయండి .

Arrays.mismatch()"ఉదాహరణకు, మరియు పద్ధతులను మీరు నిశితంగా పరిశీలించవచ్చు Arrays.compare(). మీరు వాటిని బాగా ఉపయోగించుకోగలుగుతారు.

"మరియు పద్ధతుల సంఖ్యతో అయోమయం చెందకండి. ప్రతి పద్ధతిలో 5-10 వేరియంట్‌లు ఉంటాయి, అవి వాటి పరామితి రకాల్లో మాత్రమే విభిన్నంగా ఉంటాయి."

మునుపటి మునుపటి పాఠం

తరువాత తదుపరి పాఠం

వ్యాఖ్యలు

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION