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

1.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);

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

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

2.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);

"[1, 2, 3, 4, 5]"

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

3.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);

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

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

4.Arrays.sort()

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

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

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

"[-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);

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

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

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

5.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);

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

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

శ్రేణిలో మూలకం కనుగొనబడకపోతే, సూచిక ప్రతికూలంగా ఉంటుంది.

Arrays6. క్లాస్‌పై ఒరాకిల్ డాక్యుమెంటేషన్‌కి లింక్

Arraysమీకు చాలా ఆసక్తి ఉంటే, మీరు అధికారిక డాక్యుమెంటేషన్ href="https://docs.oracle.com/en/java/javase/14/docs/api/java.baseలో క్లాస్ మరియు దాని అన్ని పద్ధతుల గురించి ప్రతిదీ చదవవచ్చు. /java/util/Arrays.html">ఒరాకిల్ వెబ్‌సైట్‌లో.

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

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