లో వెక్టర్స్ ప్రోగ్రామింగ్ ప్రపంచంలో సాధారణంగా ఉపయోగించే డేటా నిర్మాణాలలో ఒకటి.అది మనందరికీ తెలుసు శ్రేణులు డేటాను సరళ పద్ధతిలో ఉంచే డేటా నిర్మాణాలు. వెక్టర్స్ కూడా డేటాను సరళ పద్ధతిలో నిల్వ చేస్తాయి, కానీ శ్రేణుల మాదిరిగా కాకుండా, వాటికి స్థిర పరిమాణం లేదు. బదులుగా, వాటి పరిమాణాన్ని డిమాండ్ మీద పెంచవచ్చు.
వెక్టర్ క్లాస్ అనేది పిల్లల తరగతి వియుక్త జాబితా తరగతి మరియు పనిముట్లు జాబితా .వెక్టర్లను ఉపయోగించడానికి, మేము మొదట java.util ప్యాకేజీ నుండి వెక్టర్ క్లాస్‌ను దిగుమతి చేసుకోవాలి:
దిగుమతి java.util.Vector
ఈ వ్యాసంలో, వెక్టర్స్ యొక్క ఈ క్రింది భావనలను మేము చర్చిస్తాము:
- జావాలో వెక్టర్ యొక్క ప్రయోజనాలు
- వెక్టర్‌లో ఎలిమెంట్స్‌ను ఎలా యాక్సెస్ చేయాలి?
- వెక్టర్ కన్స్ట్రక్టర్లు
- వెక్టర్స్ యొక్క మెమరీ కేటాయింపు
- వెక్టర్లలో పద్ధతులు
ప్రారంభిద్దాం!
ప్రయోజనం జావాలో వెక్టర్ యొక్క
- డైనమిక్ పరిమాణాన్ని కలిగి ఉన్న ఆస్తి చాలా ఉపయోగకరంగా ఉంటుంది, ఎందుకంటే ఇది మనకు పరిమాణం తెలియకపోతే మెమరీ వ్యర్థాన్ని నివారిస్తుంది డేటా నిర్మాణం ప్రకటన సమయంలో.
- మేము ప్రోగ్రామ్ మధ్యలో మా డేటా నిర్మాణం యొక్క పరిమాణాన్ని మార్చాలనుకున్నప్పుడు, వెక్టర్స్ చాలా ఉపయోగకరంగా ఉన్నాయని నిరూపించవచ్చు.
డైనమిక్ పరిమాణాన్ని కలిగి ఉన్న ఆస్తి జావాలోని వెక్టర్లకు ప్రత్యేకమైనది కాదు. అర్రేలిస్ట్ అని పిలువబడే మరొక డేటా నిర్మాణం డైనమిక్ పరిమాణాన్ని కలిగి ఉన్న ఆస్తిని కూడా చూపిస్తుంది. ఏదేమైనా, వెక్టర్స్ కొన్ని కారణాల వల్ల శ్రేణి జాబితాల నుండి భిన్నంగా ఉంటాయి:
- మొదట, వెక్టర్స్ సమకాలీకరించబడతాయి, ఇది దానిపై ప్రయోజనాన్ని ఇస్తుంది పోలిస్తే డేటా అవినీతి ప్రమాదాలు ఉన్నందున కార్యక్రమాలు.
- రెండవది, వెక్టర్స్ కొన్ని లెగసీ ఫంక్షన్లను కలిగి ఉంటాయి, ఇవి వెక్టార్లలో మాత్రమే అమలు చేయబడతాయి మరియు అర్రేలిస్ట్లలో కాదు.
వెక్టర్‌లో ఎలిమెంట్స్‌ను ఎలా యాక్సెస్ చేయాలి
మేము శ్రేణుల్లోని మూలకాలను యాక్సెస్ చేసినట్లే, మూలకం యొక్క సూచికను ఉపయోగించడం ద్వారా మేము డేటా సభ్యులను యాక్సెస్ చేయవచ్చు.
ఉదాహరణ- మేము వెక్టర్ v లోని మూడవ మూలకాన్ని యాక్సెస్ చేయాలనుకుంటే, మేము దానిని v [3] గా సూచిస్తాము.
వెక్టర్స్ కన్స్ట్రక్టర్స్
వెక్టర్ యొక్క బహుళ వైవిధ్యాలు క్రింద ఇవ్వబడ్డాయి కన్స్ట్రక్టర్లు ఉపయోగించడానికి అందుబాటులో ఉంది:
- వెక్టర్ (పూర్ణాంక ప్రారంభ సామర్థ్యం, పూర్ణాంక పెరుగుదల) - ఇచ్చిన ప్రారంభ సామర్థ్యం మరియు దాని పరిమాణంలో పెరుగుదలతో వెక్టర్‌ను నిర్మిస్తుంది.
- వెక్టర్ (పూర్ణాంక ప్రారంభ సామర్థ్యం) - ఇచ్చిన ప్రారంభ సామర్థ్యంతో ఖాళీ వెక్టర్‌ను నిర్మిస్తుంది. ఈ సందర్భంలో, పెరుగుదల సున్నా.
- వెక్టర్() - సామర్థ్యం 10 యొక్క డిఫాల్ట్ వెక్టర్‌ను నిర్మిస్తుంది.
- వెక్టర్ (సేకరణ సి) - ఇచ్చిన సేకరణతో వెక్టర్‌ను నిర్మిస్తుంది, మూలకాల క్రమం సేకరణ యొక్క మళ్ళి ద్వారా తిరిగి వస్తుంది.
వెక్టర్లలో మూడు రక్షిత పారామితులు కూడా ఉన్నాయి
- Int సామర్థ్యం పెరుగుదల () - పరిమాణం సామర్థ్యం కంటే ఎక్కువైనప్పుడు ఇది స్వయంచాలకంగా వెక్టర్ సామర్థ్యాన్ని పెంచుతుంది.
- Int ఎలిమెంట్‌కౌంట్ () - వెక్టర్‌లోని మూలకాల సంఖ్యను చెప్పండి
- ఆబ్జెక్ట్ [] ఎలిమెంట్‌డేటా () - వెక్టర్ యొక్క మూలకాలు నిల్వ చేయబడిన శ్రేణి
వెక్టర్స్ ప్రకటనలో చాలా సాధారణ లోపాలు
- వెక్టర్ ఒక విసురుతాడు చట్టవిరుద్ధ ఆర్గ్యుమెంట్ ఎక్సెప్షన్ నిర్వచించిన వెక్టర్ యొక్క ప్రారంభ పరిమాణం ప్రతికూలంగా ఉంటే.
- పేర్కొన్న సేకరణ శూన్యమైతే, అది విసురుతుంది NullPointerException
గమనిక:
- వెక్టర్ ఇంక్రిమెంట్ పేర్కొనబడకపోతే దాని సామర్థ్యం ఉంటుందిప్రతి ఇంక్రిమెంట్ చక్రంలో రెట్టింపు అవుతుంది.
- వెక్టర్ యొక్క సామర్థ్యం పరిమాణం కంటే తక్కువగా ఉండకూడదు, అది దానికి సమానం కావచ్చు.
వెక్టర్స్ కన్స్ట్రక్టర్లను ప్రారంభించడానికి ఒక ఉదాహరణను పరిశీలిద్దాం.
ఉదాహరణ: వెక్టర్ కన్స్ట్రక్టర్లను ప్రారంభించడం
/ వెక్టర్ కన్స్ట్రక్టర్స్ ఇలస్ట్రేటింగ్ java.util ను వివరిస్తుంది. క్రొత్త వెక్టర్ (20) // ఇచ్చిన పరిమాణం మరియు పెరుగుదల వెక్టర్ యొక్క వెక్టర్‌ను సృష్టించండి v3 = కొత్త వెక్టర్ (30,10) v2.add (100) v2.add (100) v2.add (100) // ఇచ్చిన వెక్టర్‌ను సృష్టించండి సేకరణ వెక్టర్ v4 = కొత్త వెక్టర్ (v2) System.out.println ('సామర్థ్యం యొక్క వెక్టర్ v1' + v1.capacity ()) System.out.println ('సామర్థ్యం యొక్క వెక్టర్ v2' + v2.capacity ()) System.out .println ('సామర్థ్యం యొక్క వెక్టర్ v3' + v3.capacity ()) System.out.println ('సామర్థ్యం యొక్క వెక్టర్ v4' + v4.capacity ())} 
వెక్టర్స్ యొక్క మెమరీ కేటాయింపు
ఇప్పటివరకు, వెక్టర్లకు స్థిర పరిమాణం లేదని మీరు అర్థం చేసుకోవాలి, బదులుగా, వాటి పరిమాణాన్ని డైనమిక్‌గా మార్చగల సామర్థ్యం వారికి ఉంది. వస్తువులను నిల్వ చేయడానికి వెక్టర్స్ నిరవధిక సుదీర్ఘ స్థలాన్ని కేటాయిస్తాయని ఒకరు అనుకోవచ్చు. కానీ ఈ పరిస్థితి లేదు. వెక్టర్స్ ‘కెపాసిటీ’ మరియు ‘కెపాసిటీఇన్‌క్రీమెంట్’ అనే రెండు రంగాల ఆధారంగా వాటి పరిమాణాన్ని మార్చవచ్చు. ప్రారంభంలో, వెక్టర్ ప్రకటించినప్పుడు ‘సామర్థ్యం’ ఫీల్డ్‌కు సమానమైన పరిమాణం కేటాయించబడుతుంది. మేము సామర్థ్యానికి సమానమైన అంశాలను చొప్పించగలము. కానీ తదుపరి మూలకం చొప్పించిన వెంటనే, ఇది శ్రేణి యొక్క పరిమాణాన్ని ‘సామర్థ్యంఇన్‌క్రీమెంట్’ ద్వారా పెంచుతుంది. అందువల్ల, దాని పరిమాణాన్ని డైనమిక్‌గా మార్చగలదు.
ఒక కోసం డిఫాల్ట్ కన్స్ట్రక్టర్ , సామర్థ్యం నిండినప్పుడల్లా సామర్థ్యం రెట్టింపు అవుతుంది మరియు కొత్త మూలకాన్ని చేర్చాలి.
ఉదాహరణ - మనకు ఇనిషియల్ కెపాసిటీ 5 యొక్క వెక్టర్ ఉందని అనుకుందాం సామర్థ్యం పెరుగుదల యొక్క 2. కాబట్టి వెక్టర్ యొక్క ప్రారంభ పరిమాణం 5 అంశాలు మేము ఈ వెక్టర్‌లోకి 5 మూలకాలను ఒక్కొక్కటిగా చొప్పించాము, అవి 1,2,3,4,5. వెక్టర్ 6 లో మరొక మూలకాన్ని చొప్పించడానికి మేము ప్రయత్నించినప్పుడు, వెక్టర్ యొక్క పరిమాణం 2 ద్వారా పెరుగుతుంది. అందువల్ల వెక్టర్ యొక్క పరిమాణం ఇప్పుడు 7 గా ఉంటుంది. కాబట్టి వెక్టర్ దాని పరిమాణాన్ని సంఖ్య ప్రకారం సులభంగా సర్దుబాటు చేస్తుంది. మూలకాల యొక్క.
మరో ఆసక్తికరమైన విషయం ఏమిటంటే, శ్రేణుల మాదిరిగా కాకుండా, వెక్టర్స్ నిజమైన వస్తువులను కలిగి ఉండవు, కానీ వస్తువులను మాత్రమే సూచిస్తాయి. అందువల్ల, వేర్వేరు డేటా రకాల వస్తువులను ఒకే వెక్టర్‌లో నిల్వ చేయడానికి ఇది అనుమతిస్తుంది.
వెక్టర్‌లోని పద్ధతులు
చాలా తరచుగా ఉపయోగించే కొన్ని వెక్టర్ పద్ధతులను చూద్దాం.
- బూలియన్ యాడ్ (ఆబ్జెక్ట్ ఓ) - ఇది వెక్టర్ చివరిలో ఒక మూలకాన్ని జోడిస్తుంది.
// జావా కోడ్ బూలియన్ యాడ్ () పద్దతిని దిగుమతి java.util. ) // జాబితా చివరిలో 1 ని జోడిస్తుంది v.add ('జావా') // జాబితా చివరిలో 'జావా' ను జతచేస్తుంది v.add ('is') // జోడిస్తుంది 'చివరిలో' జాబితా v.add ('ఫన్') // జాబితా చివరిలో 'ఫన్' ను జోడిస్తుంది System.out.println ('వెక్టర్' + v)}} అవుట్పుట్
- శూన్య జోడింపు (పూర్ణాంక సూచిక, ఇ మూలకం) - ఇది వెక్టర్‌లోని పేర్కొన్న సూచిక వద్ద ఇచ్చిన మూలకాన్ని జోడిస్తుంది
// జావా కోడ్ శూన్య జోడింపు () పద్ధతి దిగుమతి java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {వెక్టర్ v = కొత్త వెక్టర్ () // ఇది డిఫాల్ట్ వెక్టర్ v.add (0 , 1) // ఇండెక్స్ 0 లో 1 ని జోడిస్తుంది v.add (1, 'జావా') // ఇండెక్స్ 1 వద్ద 'జావా' ను జోడిస్తుంది v.add (2, 'is') // ఇండెక్స్ వద్ద 'జోడిస్తుంది' 2 v.add (3, 'ఫన్') // ఇండెక్స్ 3 వద్ద 'ఫన్' ను జోడిస్తుంది v.add (4, '!!!') // ఇండెక్స్ 4 System.out.println (' వెక్టర్ '+ v)} is అవుట్పుట్
లోతులేని vs లోతైన కాపీ జావా
- బూలియన్ తొలగించు (ఆబ్జెక్ట్ ఓ) - ఇది వెక్టర్‌లో ఇచ్చిన సూచిక వద్ద మూలకాన్ని తీసివేస్తుంది
// జావా కోడ్ బూలియన్ తొలగింపు () పద్ధతి దిగుమతి java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {వెక్టర్ v = కొత్త వెక్టర్ () // ఇది డిఫాల్ట్ వెక్టర్ v.add (1 ) // జాబితా చివరిలో 1 ని జోడిస్తుంది v.add ('జావా') // జాబితా చివరిలో 'జావా' ను జతచేస్తుంది v.add ('is') // జోడిస్తుంది 'చివరిలో' జాబితా v.add ('ఫన్') // జాబితా చివరిలో 'ఫన్' ను జోడిస్తుంది System.out.println ('తొలగింపుకు ముందు వెక్టర్' + v) v.remove (1) System.out.println ('వెక్టర్ తరువాత తొలగింపు '+ v)}} అవుట్పుట్
- బూలియన్ రిమూవ్ ఎలిమెంట్ ( ఆబ్జెక్ట్ ఆబ్జెక్ట్) - ఇది మూలకాన్ని దాని పేరు ద్వారా తొలగిస్తుంది (సూచిక సంఖ్య ద్వారా కాదు)
// తొలగించు ఎలిమెంట్ () పద్దతిని దిగుమతి చేసే జావా కోడ్ java.util. // జాబితా చివరిలో 1 ని జోడిస్తుంది v.add ('జావా') // జాబితా చివరిలో 'జావా' ని జతచేస్తుంది v.add ('is') // జాబితా చివరిలో 'is' is ' v.add ('ఫన్') // జాబితా చివరలో 'ఫన్' ను జోడిస్తుంది System.out.println ('తొలగించడానికి ముందు వెక్టర్' + v) v.removeElement ('జావా') System.out.println ('వెక్టర్ తీసివేసిన తరువాత '+ v)}} అవుట్పుట్
- Int పరిమాణం () - ఇది వెక్టర్ యొక్క పరిమాణాన్ని అందిస్తుంది.
// జావా కోడ్ పరిమాణం () పద్ధతి దిగుమతి java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {వెక్టర్ v = కొత్త వెక్టర్ () // ఇది డిఫాల్ట్ వెక్టర్ v.add (0, 1) // సూచిక 0 లో 1 ని జోడిస్తుంది v.add (1, 'జావా') // ఇండెక్స్ 1 వద్ద 'జావా' ను జతచేస్తుంది v.add (2, 'is') // ఇండెక్స్ 2 వద్ద 'జోడిస్తుంది' v.add (3, 'ఫన్') // ఇండెక్స్ 3 వద్ద 'ఫన్' ను జోడిస్తుంది System.out.println ('వెక్టర్ పరిమాణం' + v.size ())}} అవుట్పుట్
- Int సామర్థ్యం () - ఇది వెక్టర్ యొక్క సామర్థ్యాన్ని తిరిగి ఇస్తుంది
// జావా కోడ్ సామర్థ్యాన్ని చూపించే () పద్ధతి దిగుమతి java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {వెక్టర్ v = కొత్త వెక్టర్ () // ఇది డిఫాల్ట్ వెక్టర్ v.add (0, 1) // సూచిక 0 లో 1 ని జోడిస్తుంది v.add (1, 'జావా') // ఇండెక్స్ 1 వద్ద 'జావా' ను జతచేస్తుంది v.add (2, 'is') // ఇండెక్స్ 2 వద్ద 'జోడిస్తుంది' v.add (3, 'ఫన్') // ఇండెక్స్ 3 వద్ద 'ఫన్' ను జోడిస్తుంది System.out.println ('వెక్టర్ సామర్థ్యం' + v.capacity ())}} అవుట్పుట్
- ఆబ్జెక్ట్ గెట్ (పూర్ణాంక సూచిక) - ఇది వెక్టర్‌లో ఇచ్చిన స్థానం వద్ద మూలకాన్ని తిరిగి ఇస్తుంది
// జావా కోడ్ గెట్ () పద్దతిని దిగుమతి చేసుకోండి java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {వెక్టర్ v = కొత్త వెక్టర్ () // ఇది డిఫాల్ట్ వెక్టర్ v.add (1) // జాబితా చివరిలో 1 ని జోడిస్తుంది v.add ('జావా') // జాబితా చివరిలో 'జావా' ని జతచేస్తుంది v.add ('is') // జాబితా చివరిలో 'is' is ' v.add ('ఫన్') // జాబితా చివరిలో 'ఫన్' ను జోడిస్తుంది System.out.println ('ఇండెక్స్ 1 లోని మూలకం' + v.get (1))}} అవుట్పుట్
- ఆబ్జెక్ట్ ఫస్ట్ ఎలిమెంట్ () - ఇది మొదటి మూలకాన్ని అందిస్తుంది
// ఫస్ట్ ఎలిమెంట్ () పద్దతిని దిగుమతి చేసే జావా కోడ్. Java.util. // జాబితా చివరిలో 1 ని జోడిస్తుంది v.add ('జావా') // జాబితా చివరిలో 'జావా' ని జతచేస్తుంది v.add ('is') // జాబితా చివరిలో 'is' is ' v.add ('ఫన్') // జాబితా చివరిలో 'ఫన్' ను జోడిస్తుంది System.out.println ('మొదటి మూలకం' + v.firstElement ())}} అవుట్పుట్
- ఆబ్జెక్ట్ చివరి ఎలిమెంట్ () - ఇది చివరి మూలకాన్ని అందిస్తుంది
లాస్ట్ ఎలిమెంట్ () పద్దతిని దిగుమతి చేసే జావా కోడ్ java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {వెక్టర్ v = కొత్త వెక్టర్ () // ఇది డిఫాల్ట్ వెక్టర్ v.add (1) // జాబితా చివరిలో 1 ని జోడిస్తుంది v.add ('జావా') // జాబితా చివరిలో 'జావా' ని జతచేస్తుంది v.add ('is') // జాబితా చివరిలో 'is' is ' v.add ('ఫన్') // జాబితా చివరిలో 'ఫన్' ను జోడిస్తుంది System.out.println ('చివరి మూలకం' + v.lastElement ())}} అవుట్పుట్
- బూలియన్ సమానం (ఆబ్జెక్ట్ ఓ) - ఇది వెక్టర్‌ను సమానత్వం కోసం పేర్కొన్న వస్తువుతో పోలుస్తుంది. అన్ని అంశాలు వాటి సంబంధిత సూచికలలో నిజమైతే ఇది నిజం అవుతుంది
// బూలియన్ ఈక్వల్స్ () పద్ధతి దిగుమతి java.util ను చూపించే జావా కోడ్. () v.add (1) // జాబితా చివరిలో 1 ని జోడిస్తుంది v.add ('జావా') // జాబితా చివరిలో 'జావా' ను జతచేస్తుంది v.add ('is') // జోడిస్తుంది ' 'జాబితా చివరిలో v.add (' ఫన్ ') // జాబితా చివరిలో' ఫన్ 'ను జతచేస్తుంది vcopy.add (0,1) // సూచిక 0 వద్ద 1 ని జోడిస్తుంది vcopy.add (1, 'జావా') // సూచిక 1 వద్ద 'జావా' ని జోడిస్తుంది vcopy.add (2, 'is') // జోడిస్తుంది 'is' at index 2 vcopy.add (3, 'Fun') // 'Fun' ని జోడిస్తుంది ఇండెక్స్ 3 వద్ద vcopy.add (4, '!!!') // ఇండెక్స్ 4 వద్ద 'ఫన్' ను జోడిస్తే (v.equals (vcopy)) System.out.println ('రెండు వెక్టర్స్ సమానమైనవి') వేరే సిస్టమ్ .out.println ('వెక్టర్స్ సమానం కాదు')}} అవుట్పుట్
- ట్రిమ్టోసైజ్ () ను రద్దు చేయండి - ఈ పద్ధతి అదనపు సామర్థ్యాన్ని తొలగిస్తుంది మరియు మూలకాలను పట్టుకునే సామర్థ్యాన్ని ఉంచుతుంది, అంటే పరిమాణానికి సమానం
// ట్రిమ్టోసైజ్ () పద్దతిని దిగుమతి చేసే జావా కోడ్ java.util. 1) // సూచిక 0 లో 1 ని జోడిస్తుంది v.add (1, 'జావా') // ఇండెక్స్ 1 వద్ద 'జావా' ను జతచేస్తుంది v.add (2, 'is') // ఇండెక్స్ 2 వద్ద 'జోడిస్తుంది' v.add (3, 'ఫన్') // ఇండెక్స్ 3 వద్ద 'ఫన్' ను జోడిస్తుంది System.out.println ('వెక్టర్ సామర్థ్యం' + v.capacity ()) v.trimToSize () System.out.println ( 'వెక్టర్ సామర్థ్యం' + v.capacity ())}} అవుట్పుట్
ఇతరులు ముఖ్యమైన పద్ధతులు
వెక్టర్స్‌తో ఎలా పని చేయాలనే దానిపై మీకు ఇప్పుడు మంచి ఆలోచన వచ్చింది. మీరు వెక్టర్ పద్ధతులను మరింత అన్వేషించాలనుకుంటే, క్రింద ఇవ్వబడిన పట్టికను చూడండి.
| పద్ధతి పేరు | విధానం యొక్క పనితీరు |
బూలియన్ isEmpty () | అంశాలు ఉన్నాయో లేదో తనిఖీ చేస్తుంది |
బూలియన్ కలిగి ఉంది (ఆబ్జెక్ట్ ఓ) css మరియు css3 మధ్య తేడా ఏమిటి | ఒక నిర్దిష్ట మూలకం యొక్క ఉనికిని తనిఖీ చేయడానికి ఉపయోగిస్తారు, o అని చెప్పండి |
పూర్ణాంక సూచికఆఫ్ (ఆబ్జెక్ట్ ఓ) | ఇది మూలకం యొక్క సూచికను తిరిగి ఇస్తుంది |
void removeRange (int s, int e) | s నుండి ప్రారంభించి (e-1) తో ముగుస్తున్న వెక్టర్ నుండి మూలకాలను తొలగిస్తుంది |
void clear () | అన్ని అంశాలను తొలగిస్తుంది |
void sureCapacity (int c) | ఇది సి ద్వారా సామర్థ్యాన్ని పెంచుతుంది |
శూన్య సెట్‌సైజ్ (పూర్ణాంకాలు) | ఇది పరిమాణాన్ని s కు సెట్ చేస్తుంది. S> పరిమాణం ఉంటే, అదనపు సామర్థ్యం శూన్య విలువలతో నిండి ఉంటుంది. ఉంటే |
ఆబ్జెక్ట్ ఎలిమెంట్అట్ (int a) | సూచిక సంఖ్య వద్ద ఉన్న మూలకాన్ని తిరిగి ఇస్తుంది a ఉదాహరణలతో ప్రారంభకులకు pl sql ట్యుటోరియల్ |
ఆబ్జెక్ట్ సెట్ (int a, ఆబ్జెక్ట్ o) | సూచిక వద్ద ఉన్న మూలకాన్ని ఇచ్చిన మూలకం o తో భర్తీ చేస్తుంది |
ఆబ్జెక్ట్ [] toArray () | వెక్టర్ మాదిరిగానే మూలకాలను కలిగి ఉన్న శ్రేణిని అందిస్తుంది |
ఆబ్జెక్ట్ క్లోన్ () | వెక్టర్ వస్తువు కాపీ చేయబడింది |
బూలియన్ యాడ్అల్ (కలెక్షన్ సి) | సేకరణ సి యొక్క అన్ని అంశాలను వెక్టర్‌కు జతచేస్తుంది |
బూలియన్ యాడ్అల్ (int a, కలెక్షన్ సి) | సేకరణ యొక్క అన్ని అంశాలను చొప్పిస్తుంది c సూచించిన సూచిక వద్ద వెక్టర్‌కు a |
బూలియన్ నిలుపుదల అన్ని (సేకరణ సి) | సేకరణలో ఉన్న వెక్టర్‌లోని అన్ని అంశాలను కలిగి ఉంటుంది |
జాబితా ఉప జాబితా (int s, int e) | మూలకాలను జాబితా వస్తువుగా, s నుండి ప్రారంభించి, వెక్టర్ నుండి (e-1) తో ముగుస్తుంది. |
ప్రతి మంచి విషయం ముగియడంతో, వెక్టర్స్ లో మా బ్లాగ్ కూడా ఉంది . మేము ఈ బ్లాగులో జావా వెక్టర్స్ యొక్క అన్ని అంశాలను కవర్ చేయగలిగామని మరియు వెక్టర్స్ గురించి మీరు కొంత జ్ఞానాన్ని సేకరించగలిగామని మేము ఆశిస్తున్నాము.
మీరు వీలైనంత వరకు ప్రాక్టీస్ చేశారని నిర్ధారించుకోండి మరియు మీ అనుభవాన్ని తిరిగి పొందండి.
చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, ఈ జావా ఇంటర్వ్యూ ప్రశ్నలతో పాటుగా, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ ‘జావాలోని వెక్టర్స్’ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి వ్యాసం మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.