విషయము
- 1. చిరిగిపోయిన శ్రేణిని ప్రకటించడం
- జాబితా 1
- 2. శ్రేణి సూచనలను అమర్చుట
- జాబితా 2
- 3. చిరిగిపోయిన శ్రేణిని జనాభా చేయడం
- జాబితా 3
- 4. చిరిగిపోయిన అర్రే ఎలిమెంట్‌ను ఎంచుకోవడం
- జాబితా 4
- 5. చిరిగిపోయిన శ్రేణి యొక్క అన్ని మూలకాలను డైనమిక్‌గా మళ్ళించడం
- జాబితా 5
నేను సాఫ్ట్‌వేర్ ఇంజనీర్‌ని. నేను సి ++, ఎంఎఫ్‌సి, మరియు .నెట్ టెక్నాలజీలతో 15 సంవత్సరాలుగా పని చేస్తున్నాను. నాకు వీడియో గేమ్స్, పుస్తకాలు చదవడం చాలా ఇష్టం.
జావాలో, "చిరిగిపోయిన శ్రేణి" అనేది "శ్రేణి శ్రేణి". దీని అర్ధం శ్రేణి యొక్క ప్రతి మూలకం ఒకే రకమైన మరొక శ్రేణికి సూచనగా ఒక శ్రేణిని సృష్టించవచ్చు. ఉదాహరణకు, 3 x 2 యొక్క రెండు డైమెన్షనల్ శ్రేణి మూడు వరుసలు మరియు రెండు నిలువు వరుసలను సూచిస్తుంది (అనగా ప్రతి అడ్డు వరుసకు రెండు నిలువు వరుసలు ఉంటాయి). మేము దీనిని “దీర్ఘచతురస్రాకార శ్రేణి” అని పిలుస్తాము. చిరిగిపోయిన శ్రేణి విషయంలో, నిలువు వరుసల సంఖ్య పరిష్కరించబడదు.
"బెల్లం శ్రేణి" మరియు "చిరిగిపోయిన శ్రేణి" మరియు "క్రమరహిత డైమెన్షనల్ అర్రే" అన్నీ ఒకే విధంగా ఉన్నాయని గమనించండి.
1. చిరిగిపోయిన శ్రేణిని ప్రకటించడం
దిగువ కోడ్ (లిస్టింగ్ 1) చిరిగిపోయిన శ్రేణిని ప్రకటిస్తుంది:
జాబితా 1
// స్నిప్పెట్ 01: 2D సక్రమంగా లేని అర్రే డబుల్ ప్రకటించండి [] [] ir_array = కొత్త డబుల్ [3] [];
ఇక్కడ, ir_array చిరిగిపోయిన శ్రేణి మరియు కుడి వైపున ఉన్న పరిమాణం [3] [] ఒక కోణాన్ని స్థిరంగా మరియు మరొక కోణాన్ని తెలియనిదిగా నిర్దేశిస్తుంది. ఇక్కడ, పై కోడ్‌లో మనం ir_array ని డబుల్ అర్రే యొక్క ఒక డైమెన్షనల్ అర్రే అని పిలుస్తాము. ఇలా “మల్టీ డైమెన్షనల్ రాగ్డ్ అర్రే” ను సృష్టించవచ్చు.
2. శ్రేణి సూచనలను అమర్చుట
ఇప్పుడు, టైప్ డబుల్ యొక్క మూడు శ్రేణుల కోసం స్థలాన్ని కేటాయించడానికి మరియు మొదటి కోణంలో దాని సూచనను సెట్ చేయడానికి ఇది సమయం. దిగువ కోడ్ (లిస్టింగ్ 2) చిరిగిపోయిన కోణాన్ని సెటప్ చేయడాన్ని చూపిస్తుంది:
జాబితా 2
// స్నిప్పెట్ 02: ఇప్పుడు మూడు శ్రేణులను ప్రకటించండి ir_array [0] = కొత్త డబుల్ [5]; ir_array [1] = కొత్త డబుల్ [3]; ir_array [2] = కొత్త డబుల్ [2];
ఇక్కడ, మేము డబుల్ నిల్వ చేయడానికి మూడు శ్రేణులను సృష్టించాము మరియు శ్రేణి పరిమాణం 5,3,2. ప్రతి శ్రేణి శ్రేణి ir_array లో పేర్చబడి ఉంటుంది. ఉదాహరణకు, పరిమాణం 5 యొక్క మొదటి డబుల్ శ్రేణి ir_array యొక్క మొదటి స్లాట్‌లో నిల్వ చేయబడుతుంది మరియు అదే విధంగా పరిమాణం 3 యొక్క రెండవ శ్రేణి ir_array యొక్క రెండవ స్లాట్‌లో నిల్వ చేయబడుతుంది.
పై కోడ్‌లో, మేము మా చిరిగిపోయిన శ్రేణిని ఏర్పాటు చేసాము. మూడు స్లాట్లు (దీనిని అడ్డు వరుసగా చెప్పండి) మూడు వరుసలను ఏర్పరుస్తుంది మరియు ప్రతి అడ్డు వరుస ఒక శ్రేణిని సూచిస్తుంది. ఉదాహరణకు, ir_array [2] మూడవ వరుస మరియు పరిమాణం 2 యొక్క శ్రేణిని సూచిస్తుంది, ఇది దాని కోసం నిలువు వరుసలను సూచిస్తుంది. సరే, ఇప్పుడు ఈ శ్రేణిని జనసాంద్రత చేద్దాం.
3. చిరిగిపోయిన శ్రేణిని జనాభా చేయడం
చిరిగిపోయిన శ్రేణిని విస్తరించే క్రింది కోడ్‌ను చూడండి:
జాబితా 3
// స్నిప్పెట్ 03: (int i = 0; i 5; i ++) {ir_array [0] [i] = (i + 1) * 10; } for (int i = 0; i 3; i ++) {ir_array [1] [i] = (i + 1) * 5; } for (int i = 0; i 2; i ++) {ir_array [2] [i] = (i + 1) * 2; }
పై కోడ్‌లో, డబుల్ యొక్క మొదటి శ్రేణి విలువతో నిండి ఉంటుంది, ఇది 10 గుణకాలు మరియు ఐదు మూలకం విలువలు 10,20,30,40,50. రెండవ శ్రేణి డబుల్ విలువలతో నిండి ఉంటుంది, ఇది 5 యొక్క గుణకం. మూడవ శ్రేణి విలువతో నిండి ఉంటుంది, ఇది 2 గుణకం. శ్రేణిని జనాభా చేసిన తరువాత, శ్రేణి క్రింద చూపిన విధంగా కనిపిస్తుంది:
4. చిరిగిపోయిన అర్రే ఎలిమెంట్‌ను ఎంచుకోవడం
చిరిగిపోయిన శ్రేణి సిద్ధమైన తర్వాత, మూలకాల విలువను సాధారణ శ్రేణి వలె ఎంచుకోవచ్చు. ఇక్కడ మా ఉదాహరణలో, మేము రెండు కొలతలతో చిరిగిపోయిన శ్రేణిని ఏర్పాటు చేసాము, కాబట్టి ఈ శ్రేణి నుండి ఒక మూలకాన్ని ఎంచుకోవడానికి, మేము దాని వరుస మరియు కాలమ్ ద్వారా సెల్‌ను గుర్తించాలి. ఉదాహరణకు, ir_array [0] [4] ను పరిశీలిద్దాం మరియు ఇక్కడ ir_array [0] పొడవు 5 తో మొదటి డబుల్ శ్రేణిని చెబుతుంది మరియు రెండవ పరిమాణం [4] ఐదవ మూలకాన్ని గుర్తించమని చెబుతుంది. ఇప్పుడు ఈ క్రింది కోడ్‌ను పరిశీలించండి (లిస్టింగ్ 4):
జాబితా 4
// స్నిప్పెట్ 04: ఇప్పుడు మనం యాదృచ్చికంగా కొంత విలువను తీసుకుందాం // మరియు దానిని ప్రింట్ చేద్దాం. System.out.println ("ir_array [0] [4] =" + ir_array [0] [4]); System.out.println ("ir_array [1] [2] =" + ir_array [1] [2]); System.out.println ("ir_array [2] [1] =" + ir_array [2] [1]);
పై కోడ్ ఉదాహరణలో, మేము బెల్లం శ్రేణి నుండి మూడు అంశాలను ఎంచుకున్నాము మరియు దానిని కన్సోల్ అవుట్పుట్ విండోలో ప్రదర్శించాము. ఎంచుకున్న అంశాలు క్రింది చిత్రంలో చూపించబడ్డాయి:
5. చిరిగిపోయిన శ్రేణి యొక్క అన్ని మూలకాలను డైనమిక్‌గా మళ్ళించడం
బెల్లం చేసిన శ్రేణిని డైనమిక్‌గా మళ్ళించడానికి శ్రేణి యొక్క పొడవు ఆస్తి ఉపయోగపడుతుంది. ఇక్కడ ఈ క్రింది కోడ్‌లో ir_array “డబుల్ అర్రే యొక్క అర్రే” ను సూచిస్తుంది మరియు దాని పొడవు తీసుకొని మొదట మళ్ళించబడుతుంది. మేము ఒక సూచికను ఇర్-అర్రేకు సరఫరా చేసినప్పుడు, అది డబుల్ శ్రేణిని సూచిస్తుంది, ఆ సూచికలో మేము డబుల్ శ్రేణి యొక్క సూచనను నిల్వ చేస్తాము. మేము పొడవు ఆస్తిని చదివినప్పుడు (ఉదాహరణకు, ir_array [0]. పొడవు,) ఇది డబుల్ అర్రే యొక్క పొడవును ఇస్తుంది, ఇది సమూహ లూప్‌గా మళ్ళించబడుతుంది.
దిగువ కోడ్ స్నిప్పెట్‌లో, మేము అన్ని శ్రేణి మూలకాల ద్వారా మళ్ళించాము మరియు ఫలితాన్ని కన్సోల్ అవుట్పుట్ విండోకు ముద్రించాము:
జాబితా 5
// స్నిప్పెట్ 05: బెల్లం అర్రే సిస్టమ్.ఇట్.ప్రింట్ల్న్ ("") ద్వారా మళ్ళించండి; System.out.println ("జాగెడ్ అర్రే ద్వారా మళ్ళించడం"); (int arrayofArrayIndex = 0; arrayofArrayIndex ir_array.length; arrayofArrayIndex ++) {for (int ArrayOfDoubleIndex = 0; ArrayOfDoubleIndex ir_array [arrayofArrayIndex] .length; ArrayOfDoubleIndexe ; . System.out.println (""); }
పూర్తి ఉదాహరణ మరియు దాని అవుట్పుట్ క్రింద ఇవ్వబడింది:
ప్యాకేజీ com.JavaHub; పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {// స్నిప్పెట్ 01: 2 డి సక్రమంగా అర్రే డబుల్ ప్రకటించండి [] [] ir_array = కొత్త డబుల్ [3] []; // స్నిప్పెట్ 02: ఇప్పుడు మూడు శ్రేణులను ప్రకటించండి ir_array [0] = కొత్త డబుల్ [5]; ir_array [1] = కొత్త డబుల్ [3]; ir_array [2] = కొత్త డబుల్ [2]; // స్నిప్పెట్ 03: (int i = 0; i 5; i ++) {ir_array [0] [i] = (i + 1) * 10; } for (int i = 0; i 3; i ++) {ir_array [1] [i] = (i + 1) * 5; } for (int i = 0; i 2; i ++) {ir_array [2] [i] = (i + 1) * 2; Sn // స్నిప్పెట్ 04: ఇప్పుడు మనం యాదృచ్చికంగా కొంత విలువను తీసుకుందాం // మరియు దానిని ప్రింట్ చేద్దాం. System.out.println ("ir_array [0] [4] =" + ir_array [0] [4]); System.out.println ("ir_array [1] [2] =" + ir_array [1] [2]); System.out.println ("ir_array [2] [1] =" + ir_array [2] [1]); // స్నిప్పెట్ 05: బెల్లం అర్రే సిస్టమ్.ఇట్.ప్రింట్ల్న్ ("") ద్వారా మళ్ళించండి; System.out.println ("జాగెడ్ అర్రే ద్వారా మళ్ళించడం"); (int arrayofArrayIndex = 0; arrayofArrayIndex ir_array.length; arrayofArrayIndex ++) {for (int ArrayOfDoubleIndex = 0; ArrayOfDoubleIndex ir_array [arrayofArrayIndex] .length; ArrayOfDoubleIndexe ; . System.out.println (""); }}} ఈ వ్యాసం రచయిత యొక్క ఉత్తమమైన జ్ఞానానికి ఖచ్చితమైనది మరియు నిజం. కంటెంట్ సమాచార లేదా వినోద ప్రయోజనాల కోసం మాత్రమే మరియు వ్యాపారం, ఆర్థిక, చట్టపరమైన లేదా సాంకేతిక విషయాలలో వ్యక్తిగత సలహా లేదా వృత్తిపరమైన సలహాలకు ప్రత్యామ్నాయం కాదు.
