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);
ఉదాహరణలు:
|
వేరియబుల్ str స్ట్రింగ్ను కలిగి ఉంటుంది:
|
|
వేరియబుల్ str స్ట్రింగ్ను కలిగి ఉంటుంది:
|
|
వేరియబుల్ str స్ట్రింగ్ను కలిగి ఉంటుంది:
|
3.Arrays.deepToString()
కానీ మీరు ద్విమితీయ శ్రేణిని స్ట్రింగ్ (దీనిని ప్రదర్శించడానికి) using the Arrays.toString()
పద్ధతికి మార్చడానికి ప్రయత్నిస్తే, మీకు తెలిసిన ఏదో ఒకటి కనిపిస్తుంది:
[I@37afeb11, I@37afeb21, I@37afeb31]
రెండు డైమెన్షనల్ అర్రే యొక్క సెల్లు ఒక డైమెన్షనల్ శ్రేణులను సూచిస్తాయి కాబట్టి ఇదంతా జరిగింది. మరియు ఒక డైమెన్షనల్ శ్రేణులు స్ట్రింగ్గా ఎలా మార్చబడతాయి? మీరు పైన చూసినట్లుగానే.
ఏమి చేయవచ్చు? ద్విమితీయ శ్రేణిని మనం ఎలా సరిగ్గా ప్రదర్శిస్తాము?
ఈ క్రమంలో, Arrays
తరగతికి మరొక ప్రత్యేక పద్ధతి ఉంది - deepToString()
. కాల్ చేయడం ఇలా కనిపిస్తుంది:
String str = Arrays.deepToString(name);
ఈ పద్ధతి రెండు-డైమెన్షనల్, వన్-డైమెన్షనల్, త్రీ-డైమెన్షనల్ లేదా సాధారణంగా ఏదైనా డైమెన్షన్ అయిన శ్రేణులను పాస్ చేయవచ్చు మరియు ఇది ఎల్లప్పుడూ శ్రేణి యొక్క మూలకాలను ప్రదర్శిస్తుంది.
గమనిక: ఈ Arrays.deepToString()
పద్ధతి ఆదిమాంశాల యొక్క ఒక డైమెన్షనల్ శ్రేణులతో పని చేయదు (ఉదాహరణకు, int[]
).
ఉదాహరణలు:
|
వేరియబుల్ str స్ట్రింగ్ను కలిగి ఉంటుంది:
|
|
వేరియబుల్ str స్ట్రింగ్ను కలిగి ఉంటుంది:
|
|
వేరియబుల్ str స్ట్రింగ్ను కలిగి ఉంటుంది:
|
4.Arrays.equals()
స్క్రీన్పై శ్రేణులను ఎలా ప్రదర్శించాలో మేము కనుగొన్నాము, అయితే శ్రేణులను పోల్చడం గురించి ఏమిటి?
స్ట్రింగ్లను పోల్చడానికి, మనకు equals
మరియు equalsIgnoreCase
పద్ధతులు ఉన్నాయి, అయితే శ్రేణులు ఏ పద్ధతులను కలిగి ఉన్నాయి?
శుభవార్త ఏమిటంటే శ్రేణులకు ఒక equals
పద్ధతి ఉంటుంది. చెడ్డ వార్త ఏమిటంటే ఇది శ్రేణుల కంటెంట్లను పోల్చదు. శ్రేణుల పద్ధతి ఆపరేటర్ equals
వలె అదే పనిని చేస్తుంది ==
- ఇది సూచనలను పోలుస్తుంది. ఉదాహరణలు:
ఉదాహరణలు:
|
false (సూచనలు సమానంగా లేవు) |
|
equals యొక్క పద్ధతి రెండు arrays శ్రేణుల సూచనలను సరిపోల్చుతుంది. false (సూచనలు సమానంగా లేవు) |
ఏమి చేయవచ్చు? మేము శ్రేణులను వాటి కంటెంట్ల ఆధారంగా ఎలా పోల్చాలి?
మరియు మళ్ళీ Arrays
మన రక్షణకు వస్తుంది, లేదా మరింత ప్రత్యేకంగా, దాని Arrays.equals()
పద్ధతి. మేము దీనిని ఇలా పిలుస్తాము:
Arrays.equals(name1, name2)
true
శ్రేణులు సమాన పొడవు మరియు వాటి మూలకాలు సమానంగా ఉంటే పద్ధతి తిరిగి వస్తుంది . లేకపోతే, అది తిరిగి వస్తుంది false
.
ఉదాహరణలు:
|
equals యొక్క పద్ధతి రెండు arrays శ్రేణుల సూచనలను సరిపోల్చుతుంది. false (సూచనలు సమానంగా లేవు) |
|
true (విషయాలు సమానంగా ఉంటాయి) |
|
false (శ్రేణుల కంటెంట్లు భిన్నంగా ఉంటాయి) |
5.Arrays.deepEquals()
మరియు, మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, Arrays.equals
రెండు డైమెన్షనల్ శ్రేణుల కోసం ఈ పద్ధతి సరిగ్గా పని చేయదు: ఇది రెండు డైమెన్షనల్ శ్రేణులను ఒక డైమెన్షనల్ శ్రేణి వలె పరిగణిస్తుంది, దీని మూలకాలు ఒక డైమెన్షనల్ శ్రేణుల చిరునామాలు.
అందువల్ల, మల్టీడైమెన్షనల్ శ్రేణులను సరిగ్గా సరిపోల్చడానికి ( n = 1, 2, 3,...
), అవి పద్ధతితో ముందుకు వచ్చాయి Arrays.deepEquals()
. కాల్ చేయడం ఇలా కనిపిస్తుంది:
Arrays.deepEquals(name1, name2)
పద్ధతి తిరిగి వస్తుందిtrue
శ్రేణులు సమాన పొడవు మరియు వాటి మూలకాలు సమానంగా ఉంటే. లేకపోతే, అది తిరిగి వస్తుందిfalse
. శ్రేణిలోని మూలకాలు కూడా శ్రేణులైతే, Arrays.deepEquals()
వాటిని పోల్చడానికి పద్ధతి ఉపయోగించబడుతుంది మరియు మొదలైనవి.
ఉదాహరణలు:
|
equals యొక్క పద్ధతి రెండు arrays శ్రేణుల సూచనలను సరిపోల్చుతుంది. false (సూచనలు సమానంగా లేవు) |
|
పద్ధతి Arrays.equals సరిపోల్చండి మరియు సూచనలను నిల్వ చేసే ఒక డైమెన్షనల్ శ్రేణుల వలె ఉంటుంది. అవి వేర్వేరు సూచనలను కలిగి ఉంటాయి. (శ్రేణుల కంటెంట్లు సమానంగా లేవు) x1 x2 false |
|
true (విషయాలు సమానంగా ఉంటాయి) |
GO TO FULL VERSION