శ్రేణులు — సహాయక తరగతి

"అమిగో, ప్రోగ్రామింగ్‌లో శ్రేణులు ఎంత ఉపయోగకరంగా ఉన్నాయో మీరు గ్రహించారని నేను ఆశిస్తున్నాను?"

"చాలా ఖచ్చితంగా, రిషీ! నేను ఇప్పటికే ఒకటి కంటే ఎక్కువ పనులను పరిష్కరించాను."

"మీ పనులకు పునరావృత చర్యలు ఉన్నాయా? మీరు పదే పదే చేసిన రకం."

"నేను మిమ్మల్ని సరిగ్గా అర్థం చేసుకున్నట్లయితే, మీరు వేర్వేరు పనులలో ఒకే విధమైన చర్యలను సూచిస్తున్నారా? ఉదాహరణకు, శ్రేణిలోని కంటెంట్‌లను ప్రదర్శించడానికి లూప్‌ని ఉపయోగించి ప్రతిచోటా — నేను అలా చేయడంలో చాలా అలసిపోయాను!"

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

"మరియు నిజమైన ప్రోగ్రామర్‌లకు చాలా ముఖ్యమైన నియమం ఉంది: మీరే పునరావృతం చేయవద్దు. నిరుపయోగంగా పని చేయడం తప్పు అని మీరు అంగీకరిస్తారు - మీరు దాని కోసం చెల్లించబడరు. ప్రభావవంతమైన పని బాగా చెల్లించబడుతుంది, నన్ను నమ్మండి. యాదృచ్ఛికంగా, కొత్త వ్యక్తి పెద్ద మొత్తంలో పునరావృతమయ్యే కోడ్ ద్వారా కోడ్ వెంటనే గుర్తించబడుతుంది.

"జావా సృష్టికర్తలు దీని గురించి ఆలోచించారు మరియు ప్రత్యేక Arraysతరగతిని (దీని పూర్తి పేరు java.util.Arrays) సృష్టించారు, ఇందులో అత్యంత ప్రజాదరణ పొందిన శ్రేణి-సంబంధిత చర్యలను ఉంచారు."

"హ్మ్... చాలా ఇంటరెస్టింగ్‌గా ఉంది. ఐతే దానిలో సరిగ్గా ఏమి ఉంది?

"ఇది ప్రతి సందర్భానికి చాలా పద్ధతులను కలిగి ఉంది, కానీ మొదట మేము వాటిలో 10 మాత్రమే పరిశీలిస్తాము - సరళమైనది మరియు చాలా తరచుగా ఉపయోగించబడుతుంది.

Arrays.toString()

"మేము చూడబోయే మొదటి పద్ధతి Arrays.toString(). అయితే ముందుగా, కొద్దిగా నేపథ్యం.

"జావాలోని ప్రతి శ్రేణికి ఒక toString()పద్ధతి ఉంటుంది, ఇది 'శ్రేణి యొక్క పాఠ్య ప్రాతినిధ్యం'ని అందిస్తుంది. మీరు ఈ క్రింది స్టేట్‌మెంట్‌ను ఉపయోగించి శ్రేణి యొక్క వచన ప్రాతినిధ్యాన్ని పొందవచ్చు:

String str = name.toString();

" nameఅరే వేరియబుల్ పేరు ఎక్కడ ఉంది మరియు strశ్రేణి యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని నిల్వ చేసే వేరియబుల్ పేరు. అమిగో, మీరు పద్ధతిని ఉపయోగించి స్క్రీన్‌పై శ్రేణిని ముద్రించడానికి ప్రయత్నించారా ?System.out.println(name)

నేను అంగీకరిస్తున్నాను, అది జరిగింది. నేను కొంత అసభ్యతని చూశాను. నేను హాని కలిగించే మార్గం నుండి దూరంగా ఉండాలని మరియు లూప్‌లను ఉపయోగించడం కొనసాగించాలని నిర్ణయించుకున్నాను.

"చాలా మటుకు మీరు ఇలాంటిదే చూసారు:

I@37afeb11

"మొదటి అక్షరం Iఅంటే ఇది ఒక intశ్రేణి అని మరియు తర్వాత గుర్తులు@ మెమరీలో ఒకే వస్తువు యొక్క చిరునామా. మీరు దీన్ని మెమరీలో శ్రేణి చిరునామాగా భావించవచ్చు. ఒక వైపు, ఇది ఖచ్చితంగా సమాచారంలో నిల్వ చేయబడుతుంది. శ్రేణి వేరియబుల్, కానీ మరోవైపు, మీరు వేరే ఏదో ఊహించారు, కాదా?"

"సరిగ్గా! నేను శ్రేణిలోని విలువలను చూడాలని ప్లాన్ చేస్తున్నాను. ఇది నేను ఊహించిన చివరి విషయం."

"అందుకే వారు ఈ Arrays.toString()పద్ధతిని రూపొందించారు - శ్రేణి యొక్క విలువలను ప్రదర్శించడానికి. మేము దానిని ఇలా పిలుస్తాము:

String str = Arrays.toString(name);

ఉదాహరణలు:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

int[] array = {};
String str = Arrays.toString(array);

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

Arrays.deepToString()

"అయితే, toString()రెండు డైమెన్షనల్ శ్రేణుల విషయానికి వస్తే ఈ పద్ధతి సరిపోదు. మరో మాటలో చెప్పాలంటే, మీరు కాల్ చేయడానికి ప్రయత్నిస్తే Arrays.toString(), మీకు తెలిసిన దాన్ని చూస్తారు:

[I@37afeb11, I@37afeb21, I@37afeb31]

"ఇదంతా ఎందుకంటే రెండు డైమెన్షనల్ అర్రే స్టోర్ సెల్‌లు ఒక డైమెన్షనల్ శ్రేణులను సూచిస్తాయి. మరియు ఒక డైమెన్షనల్ శ్రేణులు స్ట్రింగ్‌గా ఎలా మార్చబడతాయి? సరిగ్గా మీరు పైన చూసినట్లుగా.

"అప్పుడు ఏమి చేయాలి? మనం ద్విమితీయ శ్రేణిని ఎలా సరిగ్గా ప్రదర్శిస్తాము?"

"జావా సృష్టికర్తలు దీనిని కూడా ఊహించారు. దీని కోసం, Arraysతరగతికి మరొక ప్రత్యేక పద్ధతి ఉంది — deepToString(). కాల్ చేయడం ఇలా కనిపిస్తుంది:

String str = Arrays.deepToString(name);

"ఈ పద్ధతి రెండు-డైమెన్షనల్, వన్-డైమెన్షనల్, త్రిమితీయ లేదా సాధారణంగా ఏదైనా డైమెన్షన్‌లో ఉండే శ్రేణులను పాస్ చేయవచ్చు మరియు ఇది ఎల్లప్పుడూ శ్రేణి యొక్క మూలకాలను ప్రదర్శిస్తుంది.

ఉదాహరణలు:

int[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

Arrays.equals()

"స్క్రీన్‌పై శ్రేణులను ఎలా ప్రదర్శించాలో మేము కనుగొన్నాము. శ్రేణులను పోల్చడం గురించి ఏమిటి? స్ట్రింగ్‌లను పోల్చడానికి మనం ఏ పద్ధతులను ఉపయోగించవచ్చో మీకు గుర్తుందా?"

"నేను సాధారణంగా equalsపద్ధతిని ఉపయోగిస్తాను!

"అవును, equals, మరియు కూడా equalsIgnoreCase(ఇది పెద్ద అక్షరం మరియు చిన్న అక్షరంతో సంబంధం లేకుండా స్ట్రింగ్‌లను పోలుస్తుంది).

"శుభవార్త: మీరు శ్రేణుల కోసం కూడా పద్ధతిని ఉపయోగించవచ్చు equals. చెడ్డ వార్తలు: ఇది శ్రేణుల కంటెంట్‌లను పోల్చదు. equalsశ్రేణుల పద్ధతి ఆపరేటర్ చేసిన పనిని చేస్తుంది ==- ఇది సూచనలను సరిపోల్చుతుంది.

ఉదాహరణలు:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

"కాబట్టి మనం ఏమి చేయాలి? వాటి కంటెంట్‌ల ఆధారంగా శ్రేణులను ఎలా సరిపోల్చాలి?"

"మళ్ళీ Arraysతరగతి మన రక్షణకు వస్తుంది. మరింత ప్రత్యేకంగా, దాని Arrays.equals()పద్ధతి. మేము దీనిని ఇలా పిలుస్తాము:

Arrays.equals(name1, name2)

true" అరేలు సమాన పొడవు మరియు వాటి మూలకాలు సమానంగా ఉంటే పద్ధతి తిరిగి వస్తుంది . లేకుంటే, అది తిరిగి వస్తుంది false.

ఉదాహరణలు:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

Arrays.deepEquals()

"మరియు, మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, Arrays.equalsరెండు డైమెన్షనల్ శ్రేణుల కోసం ఈ పద్ధతి సరిగ్గా పని చేయదు: ఇది రెండు డైమెన్షనల్ శ్రేణులను ఒక డైమెన్షనల్ శ్రేణి వలె పరిగణిస్తుంది, దీని మూలకాలు ఒక డైమెన్షనల్ శ్రేణుల చిరునామాలు.

"అందువలన, బహుమితీయ శ్రేణులను సరిగ్గా సరిపోల్చడానికి ( n = 1, 2, 3,... ), వారు పద్ధతిని రూపొందించారు Arrays.deepEquals(). దీనిని కాల్ చేయడం ఇలా కనిపిస్తుంది:

Arrays.deepEquals(name1, name2)

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

ఉదాహరణలు:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};

Arrays.deepEquals(x1, x2);

"ధన్యవాదాలు, రిషీ! ఈ పాఠం భవిష్యత్తులో నా జీవితాన్ని సులభతరం చేయడానికి మరియు సంతోషంగా ఉండటానికి నాకు అవసరమైనది. ఇప్పుడు నేను అర్రేస్ క్లాస్ యొక్క పద్ధతులను ఉపయోగిస్తాను మరియు నా ప్రోగ్రామ్‌లను మరింత వేగంగా వ్రాస్తాను.

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