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

1. Arraysతరగతి

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

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

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

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

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

"[1, 2, 3]"

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

"[]"

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

"[Hi, How's, life?]"

3.Arrays.deepToString()

కానీ మీరు ద్విమితీయ శ్రేణిని స్ట్రింగ్ (దీనిని ప్రదర్శించడానికి) using the Arrays.toString()పద్ధతికి మార్చడానికి ప్రయత్నిస్తే, మీకు తెలిసిన ఏదో ఒకటి కనిపిస్తుంది:

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

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

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

ఈ క్రమంలో, Arraysతరగతికి మరొక ప్రత్యేక పద్ధతి ఉంది - deepToString(). కాల్ చేయడం ఇలా కనిపిస్తుంది:

String str = Arrays.deepToString(name);

ఈ పద్ధతి రెండు-డైమెన్షనల్, వన్-డైమెన్షనల్, త్రీ-డైమెన్షనల్ లేదా సాధారణంగా ఏదైనా డైమెన్షన్ అయిన శ్రేణులను పాస్ చేయవచ్చు మరియు ఇది ఎల్లప్పుడూ శ్రేణి యొక్క మూలకాలను ప్రదర్శిస్తుంది.
గమనిక: ఈ Arrays.deepToString()పద్ధతి ఆదిమాంశాల యొక్క ఒక డైమెన్షనల్ శ్రేణులతో పని చేయదు (ఉదాహరణకు, int[]).

ఉదాహరణలు:

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

"[1, 2, 3]"

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

"[[1, 1], [2, 2], [3, 3]]"

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

"[[[1, 2, 3], [1]], [[]]]"

4.Arrays.equals()

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

స్ట్రింగ్‌లను పోల్చడానికి, మనకు equalsమరియు equalsIgnoreCaseపద్ధతులు ఉన్నాయి, అయితే శ్రేణులు ఏ పద్ధతులను కలిగి ఉన్నాయి?

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

ఉదాహరణలు:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = 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);

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