ArrayDeque – add()
java.util.ArrayDeque.add() ArrayDeque సేకరణ వస్తువులో ఒక మూలకాన్ని జోడిస్తుంది.
మూలకాలను జోడించడానికి మేము ఈ పద్ధతిని నిరంతరం ఉపయోగిస్తుంటే, ప్రతి మూలకం ArrayDequeలో చివరి స్థానంలో చేర్చబడుతుంది.
వాక్యనిర్మాణం
arraydeque_object. జోడించు ( మూలకం )
ఎక్కడ arraydeque_object ArrayDeque సేకరణను సూచిస్తుంది.
పరామితి
ఇది ArrayDeque సేకరణ ఆబ్జెక్ట్ రకానికి సంబంధించి ఒక మూలకాన్ని తీసుకుంటుంది.
గమనిక
- మేము తప్పు డేటా రకం మూలకాన్ని ఇన్సర్ట్ చేస్తే, లోపం తిరిగి వస్తుంది.
- మేము శూన్య విలువను ఇన్సర్ట్ చేస్తే, a NullPointerException విసిరివేయబడుతుంది.
ఉదాహరణ 1
ఇక్కడ, మేము స్ట్రింగ్ రకంతో ఖాళీ ArrayDeque సేకరణను సృష్టిస్తాము మరియు దానికి ఒక మూలకాన్ని జోడిస్తాము.
దిగుమతి java.util.* ;దిగుమతి java.util.ArrayDeque ;
ప్రజా తరగతి ప్రధాన
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// స్ట్రింగ్ రకంతో a_deque_object పేరుతో ArrayDequeని సృష్టించండి
Dequea_deque_object = కొత్త ArrayDeque ( ) ;
వ్యవస్థ . బయటకు . println ( 'a_deque_objectలో ఉన్న వాస్తవ డేటా:' + a_deque_object ) ;
//దానికి 'జింక్' జోడించండి.
a_deque_object. జోడించు ( 'జింక్' ) ;
వ్యవస్థ . బయటకు . println ( 'a_deque_objectలో ఉన్న తుది డేటా:' + a_deque_object ) ;
}
}
అవుట్‌పుట్:
కాబట్టి a_deque_objectలో “జింక్” జోడించబడిందని మనం చూడవచ్చు.
వివరణ
పంక్తి 9,11:
స్ట్రింగ్ రకంతో a_dequeobject అనే ArrayDequeని సృష్టించండి మరియు ArrayDeque ఆబ్జెక్ట్‌ను తిరిగి ఇవ్వండి.
లైన్ 14,16:
ఇప్పుడు 'జింక్' మూలకాన్ని a_deque_objectకు జోడించి దాన్ని తిరిగి ఇవ్వండి.
ఉదాహరణ 2
ఇక్కడ, మేము పూర్ణాంకం రకంతో ఖాళీ ArrayDeque సేకరణను సృష్టిస్తాము మరియు నిరంతరంగా a5 మూలకాలను జోడిస్తాము.
దిగుమతి java.util.* ;దిగుమతి java.util.ArrayDeque ;
ప్రజా తరగతి ప్రధాన
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// పూర్ణాంక రకంతో a_deque_object పేరుతో ArrayDequeని సృష్టించండి
Dequea_deque_object = కొత్త ArrayDeque ( ) ;
//దానికి 100 జోడించండి.
a_deque_object. జోడించు ( 100 ) ;
వ్యవస్థ . బయటకు . println ( '100ని జోడించిన తర్వాత a_deque_objectలో ఉన్న డేటా:' + a_deque_object ) ;
//దానికి 200 జోడించండి.
a_deque_object. జోడించు ( 200 ) ;
వ్యవస్థ . బయటకు . println ( '200ని జోడించిన తర్వాత a_deque_objectలో ఉన్న డేటా:' + a_deque_object ) ;
//దానికి 300 జోడించండి.
a_deque_object. జోడించు ( 300 ) ;
వ్యవస్థ . బయటకు . println ( '300ని జోడించిన తర్వాత a_deque_objectలో ఉన్న డేటా:' + a_deque_object ) ;
//దానికి 400 జోడించండి.
a_deque_object. జోడించు ( 400 ) ;
వ్యవస్థ . బయటకు . println ( '400ని జోడించిన తర్వాత a_deque_objectలో ఉన్న డేటా:' + a_deque_object ) ;
//దానికి 500 జోడించండి.
a_deque_object. జోడించు ( 500 ) ;
వ్యవస్థ . బయటకు . println ( '500 జోడించిన తర్వాత a_deque_objectలో ఉన్న డేటా:' + a_deque_object ) ;
}
}
అవుట్‌పుట్:
కాబట్టి అన్ని మూలకాలు a_deque_objectకి ఒకదాని తర్వాత ఒకటి జోడించబడటం మనం చూడవచ్చు.
వివరణ
లైన్ 9:
పూర్ణాంకం రకంతో a_dequeobject పేరుతో ArrayDequeని సృష్టించండి.
లైన్ 12,13:
a_deque_objectకు మూలకం – 100ని జోడించి, దాన్ని తిరిగి ఇవ్వండి.
లైన్ 16,17:
a_deque_objectకు మూలకం – 200ని జోడించి, దాన్ని తిరిగి ఇవ్వండి.
పంక్తి 20,21:
a_deque_objectకు మూలకం – 300ని జోడించి, దాన్ని తిరిగి ఇవ్వండి.
పంక్తి 24,25:
a_deque_objectకు మూలకం – 400ని జోడించి, దాన్ని తిరిగి ఇవ్వండి.
పంక్తి 28,29:
a_deque_objectకు మూలకం – 500ని జోడించి, దాన్ని తిరిగి ఇవ్వండి.
ArrayDeque – addAll()
java.util.ArrayDeque.addAll() జావా కలెక్షన్ ఆబ్జెక్ట్‌లోని అన్ని మూలకాలను ArrayDeque సేకరణ ఆబ్జెక్ట్‌కు జోడిస్తుంది. ఇది యాడ్()ని పోలి ఉంటుంది, కానీ తేడా ఏమిటంటే ఇది ArrayDeque సేకరణ ఆబ్జెక్ట్‌కు బహుళ మూలకాలను (మొత్తం సేకరణ) జోడిస్తుంది.
వాక్యనిర్మాణం
arraydeque_object. అన్నీ జోడించండి ( సేకరణ_వస్తువు )ఎక్కడ, సేకరణ_వస్తువు వెక్టర్, అర్రేలిస్ట్, అర్రేడిక్యూ మొదలైన జావా సేకరణలను సూచిస్తుంది.
పరామితి
ఇది సేకరణ_ఆబ్జెక్ట్‌ని పారామీటర్‌గా తీసుకుంటుంది.
ఉదాహరణ 1
ఒక మూలకంతో ArrayDeque సేకరణ వస్తువును పరిశీలిద్దాం మరియు రెండు మూలకాలతో మరొక ArrayDeque సేకరణ వస్తువును సృష్టిద్దాం. చివరగా, రెండవ సేకరణ వస్తువులో ఉన్న అన్ని మూలకాలను మొదటి సేకరణ వస్తువుకు జోడించండి.
దిగుమతి java.util.* ;దిగుమతి చేసుకుంటున్నారు. ఉపయోగపడుతుంది . ArrayDeque ;
ప్రజా తరగతి ప్రధాన
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// పూర్ణాంక రకంతో a_deque_object1 పేరుతో ArrayDequeని సృష్టించండి
Deque a_deque_object1 = కొత్త ArrayDeque ( ) ;
//దానికి 100 జోడించండి.
a_deque_object1. జోడించు ( 100 ) ;
వ్యవస్థ . బయటకు . println ( 'a_deque_object1లో ఉన్న వాస్తవ డేటా:' + a_deque_object1 ) ;
// పూర్ణాంక రకంతో a_deque_object2 పేరుతో ArrayDequeని సృష్టించండి
Deque a_deque_object2 = కొత్త ArrayDeque ( ) ;
//దానికి 200,300 జోడించండి.
a_deque_object2. జోడించు ( 200 ) ;
a_deque_object2. జోడించు ( 300 ) ;
//a_deque_object2లోని అన్ని మూలకాలను a_deque_object1కి జోడించండి
a_deque_object1. అన్నీ జోడించండి ( a_deque_object2 ) ;
వ్యవస్థ . బయటకు . println ( 'a_deque_object1లో తుది డేటా ఉంది:' + a_deque_object1 ) ;
}
}
అవుట్‌పుట్:
addAll() పద్ధతిని ఉపయోగించి మొదటి ArrayDeque ఆబ్జెక్ట్‌కి ఆ మొత్తం మూలకాలు జోడించబడడాన్ని మనం చూడవచ్చు.
వివరణ
పంక్తి 8-14:
a_deque_object1 పేరుతో మొదటి ArrayDeque సేకరణ వస్తువును సృష్టించండి. దానికి 100 జోడించి ప్రదర్శించండి.
లైన్ 17-21:
a_deque_object2 పేరుతో రెండవ ArrayDeque సేకరణ వస్తువును సృష్టించండి. దానికి 200,300 జోడించండి.
పంక్తి 24,25:
addAll() పద్ధతిని ఉపయోగించి a_deque_object2లో ఉన్న అన్ని మూలకాలను a_deque_object21కి జోడించండి.
ఉదాహరణ 2
ఒక మూలకంతో ArrayDeque సేకరణ వస్తువును పరిశీలిద్దాం మరియు రెండు మూలకాలతో మరొక వెక్టర్ సేకరణ ఆబ్జెక్ట్‌ని సృష్టిద్దాం. చివరగా, రెండవ సేకరణ వస్తువులో ఉన్న అన్ని మూలకాలను మొదటి సేకరణ వస్తువుకు జోడించండి.
దిగుమతి java.util.* ;దిగుమతి java.util.ArrayDeque ;
ప్రజా తరగతి ప్రధాన
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// స్ట్రింగ్ రకంతో a_deque_object1 పేరుతో ArrayDequeని సృష్టించండి
Deque a_deque_object1 = కొత్త ArrayDeque ( ) ;
//దానికి 'హలో' జోడించండి.
a_deque_object1. జోడించు ( 'హలో' ) ;
వ్యవస్థ . బయటకు . println ( 'a_deque_object1లో ఉన్న వాస్తవ డేటా:' + a_deque_object1 ) ;
// స్ట్రింగ్ రకంతో వెక్టర్_ఆబ్జెక్ట్ అనే వెక్టర్‌ని సృష్టించండి
వెక్టార్‌వెక్టర్_ఆబ్జెక్ట్ = కొత్త వెక్టర్ ( ) ;
// దానికి 'Linuxhint', 'Python' జోడించండి.
వెక్టర్_వస్తువు. జోడించు ( 'Linux' ) ;
వెక్టర్_వస్తువు. జోడించు ( 'పైథాన్' ) ;
వ్యవస్థ . బయటకు . println ( 'వెక్టార్_ఆబ్జెక్ట్‌లో ఉన్న వాస్తవ డేటా:' + వెక్టర్_వస్తువు ) ;
//వెక్టార్_ఆబ్జెక్ట్‌లోని అన్ని ఎలిమెంట్‌లను a_deque_object1కి జోడించండి
a_deque_object1. అన్నీ జోడించండి ( వెక్టర్_వస్తువు ) ;
వ్యవస్థ . బయటకు . println ( 'a_deque_object1లో తుది డేటా ఉంది:' + a_deque_object1 ) ;
}
}
అవుట్‌పుట్:
vector_object నుండి ఆ మొత్తం మూలకాలు addAll() పద్ధతిని ఉపయోగించి మొదటి ArrayDeque ఆబ్జెక్ట్‌కి జోడించబడడాన్ని మనం చూడవచ్చు.
వివరణ
పంక్తి 9-13:
స్ట్రింగ్ రకంతో a_deque_object1 పేరుతో మొదటి ArrayDeque సేకరణ వస్తువును సృష్టించండి. దానికి 'హలో' జోడించి, దానిని ప్రదర్శించండి.
లైన్ 16-21:
vector_object పేరుతో వెక్టర్ సేకరణ వస్తువును సృష్టించండి. దానికి “Linuxhint” మరియు “Python” జోడించి ప్రదర్శించండి.
పంక్తి 25,26:
addAll() పద్ధతిని ఉపయోగించి a_deque_object21కి vector_objectలో ఉన్న అన్ని మూలకాలను జోడించండి.
ముగింపు
add() మరియు addAll() పద్ధతులను ఉపయోగించి ArrayDeque సేకరణ ఆబ్జెక్ట్‌కు ఎలిమెంట్‌లను ఎలా జోడించాలో మేము చూశాము. తేడా ఏమిటంటే add() పద్ధతి ఒక సమయంలో ఒకే మూలకాన్ని జోడిస్తుంది, అయితే addAll() ఒక సేకరణ నుండి ఎలిమెంట్‌లను జోడిస్తుంది, అది సింగిల్ లేదా మల్టిపుల్ కావచ్చు. మేము రెండు పద్ధతులకు రెండు ఉదాహరణలను చూశాము.