ది ' Arrays.fill() ” పద్ధతి మాన్యువల్ అసైన్‌మెంట్‌లు లేకుండా అందించబడిన విలువలతో శ్రేణిని ప్రారంభించేందుకు/పూర్తి చేయడానికి సరళమైన మరియు సంక్షిప్త మార్గాన్ని అందిస్తుంది. ఇది పనితీరు కోసం ఆప్టిమైజ్ చేయబడింది మరియు పెద్ద శ్రేణులను త్వరగా పూరించగలదు, ఇది అర్రే ఫిల్లింగ్‌కు సమర్థవంతమైన ఎంపికగా మారుతుంది. ఇది జావా కోడ్ రీడబిలిటీని మెరుగుపరుస్తుంది మరియు మెరుగైన కోడ్ నిర్వహణ లక్షణాలను అందిస్తుంది.
ఈ కథనం Arrays.fill() పద్ధతిని ఉపయోగించుకునే ప్రక్రియను ప్రదర్శిస్తుంది.
జావాలో Arrays.fill() పద్ధతిని ఎలా ఉపయోగించాలి?
ది ' Arrays.fill() '' వంటి డిఫాల్ట్ విలువలతో సంఖ్యా శ్రేణులను ప్రారంభించేందుకు పద్ధతిని ఉపయోగించవచ్చు 1 'లేదా' 0 ”. ఇది అక్షర శ్రేణులను ప్రత్యేకమైన లేదా పేర్కొన్న ఒకే అక్షరంతో నింపడం ద్వారా వాటిని క్లియర్ చేయగలదు. ఇది పరీక్ష కోసం శ్రేణుల ప్రక్రియలో మరియు నిర్దిష్ట RGB విలువలతో పిక్సెల్ శ్రేణులను ప్రారంభించేందుకు లేదా క్లియర్ చేయడానికి ఇమేజ్ ప్రాసెసింగ్ అప్లికేషన్‌లలో సహాయపడుతుంది.
వన్-డైమెన్షనల్, టూ-డైమెన్షనల్ మరియు త్రీ డైమెన్షనల్ వంటి శ్రేణి యొక్క బహుళ వైవిధ్యాలు ఉన్నాయి. వాటన్నింటిలో డేటాను చొప్పించడానికి, దిగువ ఉదాహరణను సందర్శించండి, దీనిలో “ Arrays.fill() 'పద్ధతి ఉపయోగించబడుతుంది:
ఉదాహరణ 1: 1-డైమెన్షనల్ అర్రేని ప్రారంభించడానికి “Arrays.fill()” పద్ధతిని ఉపయోగించడం
ది ' Arrays.fill() 1-డైమెన్షనల్ శ్రేణిని ఒకే సంఖ్యలతో పూరించడానికి ” పద్ధతిని ఉపయోగించవచ్చు. ప్రోగ్రామర్లు 'Arrays.fill()' పద్ధతిని ఉపయోగించి ఒక నిర్దిష్ట పరిధిలో మూలకాలను మాత్రమే పూరించడం ద్వారా అదనపు మైలును చేరుకోవచ్చు:
java.util.Arraysని దిగుమతి చేయండి;పబ్లిక్ క్లాస్ OneDFillExam {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) // ప్రధాన సృష్టి ( ) పద్ధతి
{
int arr [ ] = { 1 , 3 , 5 , 6 , 7 } ;
System.out.println ( '1D అర్రే:' + Arrays.toString ( అరె ) ) ;
శ్రేణులు.పూర్తి ( అరె, 7 ) ;
System.out.println ( '1D అర్రే:' + Arrays.toString ( అరె ) ) ;
శ్రేణులు.పూర్తి ( అరె, 1 , 3 , 8 ) ;
System.out.println ( '1D అర్రే:' + Arrays.toString ( అరె ) ) ;
}
}
పై కోడ్ యొక్క వివరణ:
- ముందుగా, '' పేరుతో తరగతిని సృష్టించండి OneDFillExam 'మరియు' ప్రకటించండి ప్రధాన () ” పద్ధతి.
- తరువాత, డమ్మీ పూర్ణాంక-రకం వేరియబుల్స్‌తో శ్రేణిని ప్రారంభించండి మరియు దృశ్యమాన వ్యత్యాసాన్ని సృష్టించడానికి కన్సోల్‌లో దాన్ని ప్రింట్ చేయండి.
- అప్పుడు, 'ని ఉపయోగించండి పూరించండి () ” పద్ధతి మరియు పూరించబోయే శ్రేణి పేరును పాస్ చేయండి. ఆపై, కన్సోల్‌లో నవీకరించబడిన శ్రేణిని ప్రదర్శించండి.
- ఆ తరువాత, 'ని ఉపయోగించండి పూరించండి () ” నాలుగు పారామితులతో కూడిన పద్ధతి. మొదటిది పూరించబోయే శ్రేణి పేరు, మరియు రెండవది మరియు మూడవది పూరించబోయే ఇండెక్స్ పరిధిని తెలియజేస్తుంది. మరియు చివరిది శ్రేణి లోపల నిండిన సంఖ్య.
- ముగింపులో, 'ని ఉపయోగించి స్ట్రింగ్‌గా మార్చడం ద్వారా కన్సోల్‌లో నవీకరించబడిన శ్రేణిని ప్రదర్శించండి. toString() ” పద్ధతి.
అమలు ముగిసిన తర్వాత, అవుట్‌పుట్ దిగువన చూపబడుతుంది:
పై స్నాప్‌షాట్ జావాలో “Arrays.fill()” పద్ధతిని ఉపయోగించి 1-డైమెన్షనల్ అర్రే నింపబడిందని చూపిస్తుంది.
ఉదాహరణ 2: 2-డైమెన్షనల్ అర్రేని ప్రారంభించడానికి “Arrays.fill()” పద్ధతిని ఉపయోగించడం
2-డైమెన్షనల్ అర్రే లోపల డేటాను చొప్పించడానికి, ' Arrays.fill() 'పద్ధతి క్రింద చూపిన విధంగా ఉపయోగించబడుతుంది:
java.util.Arraysని దిగుమతి చేయండి;పబ్లిక్ క్లాస్ TwoDimArrFillExam {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
int [ ] [ ] arr = కొత్త int [ 4 ] [ 4 ] ;
కోసం ( int [ ] రోయింగ్: అర్ఆర్ ) {
శ్రేణులు.పూర్తి ( రోయింగ్, పదిహేను ) ;
}
System.out.println ( '2-డైమెన్షనల్ అర్రే:' ) ;
కోసం ( int [ ] రోయింగ్: అర్ఆర్ ) {
System.out.println ( Arrays.toString ( రోయింగ్ ) ) ;
}
}
}
పై కోడ్ యొక్క వివరణ:
- మొదట, రెండు డైమెన్షనల్ ఖాళీ శ్రేణి సృష్టించబడుతుంది, ఇందులో ' 4 'వరుసలు మరియు' 4 ” నిలువు వరుసలు.
- ఆ తరువాత, ' ప్రతి 'లూప్ సృష్టించబడింది, దీనిలో' పూరించండి () 'సంఖ్యా డేటాను నమోదు చేయడానికి పద్ధతి ఉపయోగించబడుతుంది.
- చివరికి, ' ప్రతి కన్సోల్‌లో నవీకరించబడిన శ్రేణిని ప్రింట్ చేయడానికి లూప్ ఉపయోగించబడుతుంది.
అమలు ముగిసిన తర్వాత, కన్సోల్ క్రింది విధంగా కనిపిస్తుంది:
పైన ఉన్న స్నాప్‌షాట్ “లో డేటా చొప్పించబడిందని చూపిస్తుంది 2-డైమెన్షనల్ ' అమరిక.
ఉదాహరణ 3: 3-డైమెన్షనల్ అర్రేని ప్రారంభించడానికి “Arrays.fill()” పద్ధతిని ఉపయోగించడం
ది ' Arrays.fill() ” పద్ధతి జావాలో 3-డైమెన్షనల్ శ్రేణిని పూరించడానికి లేదా ప్రారంభించేందుకు కార్యాచరణను కూడా అందిస్తుంది:
java.util.Arraysని దిగుమతి చేయండి;పబ్లిక్ క్లాస్ ThreDimArrFillExam {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
int [ ] [ ] [ ] ary = కొత్త int [ 2 ] [ 2 ] [ 2 ] ;
కోసం ( int [ ] [ ] విషయం: అవును ) {
కోసం ( int [ ] రోయింగ్: మేటర్ ) {
శ్రేణులు.పూర్తి ( రోయింగ్, 16 ) ;
}
}
System.out.println ( Arrays.deepToString ( మరియు ) ) ;
}
}
పై కోడ్ బ్లాక్‌లో:
- మొదట, ' 3-డైమెన్షనల్ 'అరే' లోపల సృష్టించబడింది ప్రధాన () ” పద్ధతి.
- తరువాత, 'ని ఉపయోగించండి కోసం ” లూప్ 3D శ్రేణిలో ప్రతి 2D మ్యాట్రిక్స్ (ప్రతి మ్యాట్రిక్స్ 2D స్లైస్‌ను సూచిస్తుంది)పై మళ్ళించే లూప్.
- అప్పుడు, సమూహాన్ని ఉపయోగించండి ' కోసం లూప్ కోసం మెరుగుపరచబడిన మరొకదాన్ని ఉపయోగించి ప్రస్తుత 2D మ్యాట్రిక్స్‌లోని ప్రతి 1D అడ్డు వరుసపై మళ్ళించడానికి లూప్.
- ఆ తర్వాత, ప్రస్తుత వరుసలోని ప్రతి మూలకాన్ని విలువతో పూరించండి ' 16 'ఉపయోగించి' పూరించండి () ” పద్ధతి.
- చివరికి, 'ని ఉపయోగించండి deepToString() ” కన్సోల్‌లోని స్క్వేర్ బ్రాకెట్‌ల లోపల శ్రేణి మూలకాలను ప్రదర్శించే పద్ధతి.
అమలు ముగిసిన తర్వాత, ఫలితం క్రింద చూపబడింది:
స్నాప్‌షాట్ 3-డైమెన్షనల్ అర్రే లోపల డేటా చొప్పించబడిందని చూపిస్తుంది.
ముగింపు
ది ' Arrays.fill() అందించిన విలువతో శ్రేణిని పూరించడానికి ” పద్ధతి సాధారణంగా ఉపయోగించబడుతుంది. అందించిన విలువలతో ఇప్పటికే ఉన్న శ్రేణి యొక్క డేటా మూలకాలను రీసెట్ చేయడానికి కూడా ఇది ఉపయోగించబడుతుంది. దీన్ని ఉపయోగించడం ద్వారా, ప్రోగ్రామర్ శ్రేణి ప్రారంభించడం లేదా రీసెట్ చేయడం కోసం సరళత, సామర్థ్యం మరియు మెరుగైన కోడ్ రీడబిలిటీని సాధించవచ్చు. శ్రేణిలోని అన్ని మూలకాలను అందించిన నిర్దిష్ట విలువకు త్వరగా సెట్ చేయడంలో దీని ప్రయోజనం ఉంటుంది. దీని వినియోగం మరియు అమలు గురించి అంతే “ Arrays.fill() ” జావాలో పద్ధతి.