Java ArrayList addAll() పద్ధతి

మీరు ఒక ArrayList() సేకరణలోని అన్ని ఎలిమెంట్‌లను మరొకదానికి జోడించాలనుకుంటే , మీరు Java ArrayList క్లాస్ యొక్క addAll() పద్ధతిని ఉపయోగించవచ్చు . ఈ వ్యాసంలో, నేను ఈ పద్ధతి ఎలా పనిచేస్తుందో వివరిస్తాను మరియు కొన్ని కోడ్ ఉదాహరణలను అందించబోతున్నాను.

అర్రేలిస్ట్ addAll() పద్ధతి సంతకం

java.util.ArrayList.addAll పద్ధతికి రెండు రకాలు ఉన్నాయి . వారు ఇక్కడ ఉన్నారు.

boolean addAll(Collection<? extends E> c)

కాల్ ఫలితంగా జాబితా మార్చబడితే ఈ పద్ధతి నిజమని చూపుతుంది, కానీ ముఖ్యంగా, పేర్కొన్న సేకరణ యొక్క అన్ని మూలకాలను ఈ జాబితా చివరలో జోడిస్తుంది, అవి పేర్కొన్న సేకరణ యొక్క ఇటరేటర్ ద్వారా తిరిగి వచ్చే క్రమంలో. ఎలిమెంట్ సి అనేది మీ అర్రేలిస్ట్‌లో జోడించబడే జాబితా . అలాగే పేర్కొన్న సేకరణ శూన్యమైతే, పద్ధతి NullPointerExceptionని విసురుతుంది.

boolean addAll(int index, Collection<? extends E> c)

ఈ పద్ధతి పేర్కొన్న స్థాన సూచికతో ప్రారంభించి, పేర్కొన్న సేకరణ c లోని అన్ని మూలకాలను ఈ జాబితాలోకి చొప్పిస్తుంది.

అర్రేలిస్ట్ addAll() సింటాక్స్ ఉదాహరణ

జావా ప్రోగ్రామ్‌లో ArrayList addAll() పద్ధతికి కాల్ ఇలా కనిపిస్తుంది:

myList.addAll(myNewList))

myList అనేది అసలైన అర్రేలిస్ట్ మరియు myNewList అనేది జాబితా అయిన చోట , వాటి యొక్క అన్ని విలువలు ఉనికిలో ఉన్నట్లయితే myList కి జోడించబడతాయి .

myList.addAll(2, myNewList))

రెండు పారామితులతో ArrayList addAll() పద్ధతి యొక్క వేరియంట్ . myNewList నుండి అన్ని మూలకాలు myList కి జోడించబడతాయి మరియు మొదటి మూలకం myNewList[0] myList[2] అవుతుంది , myNewList[1] ఇప్పుడు myList[3] , మరియు మొదలైనవి. అసలు జాబితా నుండి ప్రారంభమయ్యే అంశాలు సంఖ్య 2, కొత్త కాంబో జాబితా యొక్క టెయిల్‌కి తీసుకువెళతారు.

ArrayList addAll() కోడ్ ఉదాహరణలు

ఇప్పుడు కొన్ని కోడ్ ఉదాహరణల కోసం సమయం ఆసన్నమైంది. మన స్నేహితుల జాబితాను రూపొందించి, దానిని 'స్నేహితులు' అని పిలుద్దాం మరియు అక్కడ వారి పేర్లను చేర్చుదాం. చెప్పండి, మేము కాలేజీని ప్రారంభించాము మరియు ఒకేసారి కొంతమంది కొత్త స్నేహితులను సంపాదించాము. వారి కోసం కొత్త స్నేహితుల జాబితాను రూపొందించడానికి ఇది మంచి క్షణం. సమయం గడిచిపోయింది, మీ కొత్త స్నేహితులు ఒకసారి నిజమని మీరు నిర్ధారించుకున్నారు, కాబట్టి మీరు వారిని ప్రధాన స్నేహితుల జాబితాకు తరలించాలని నిర్ణయించుకున్నారు. మీరు addAll() పద్ధతిని ఉపయోగించి దీన్ని చేయవచ్చు . ప్రోగ్రామ్‌లో, మేము కన్సోల్‌కు స్నేహితుల ప్రారంభ జాబితా, కొత్త స్నేహితుల జాబితా, నవీకరించబడిన స్నేహితుల జాబితా, అలాగే addAll() పద్ధతి ద్వారా అందించబడిన బూలియన్ విలువను ప్రింట్ చేస్తాము . పద్ధతి యొక్క ఆపరేషన్ కారణంగా ఒరిజినల్ లిస్ట్ మార్చబడితే అది ఒప్పు అని మరియు ఇది జరగకపోతే తప్పు అని చూపుతుంది.

import java.util.ArrayList;
import java.util.List;

public class AddAllDemo {
       public static void main(String[] args) {

           List<String> friends = new ArrayList<>();
           friends.add("Johnny");
           friends.add("Ivy");
           friends.add("Rick");
           System.out.println(friends);
           List<String> newFriends = new ArrayList<>();
           newFriends.add("Andrew");
           newFriends.add("Alex");
           newFriends.add("Neil");
           System.out.println(newFriends);
           //let's print out the value addAll() method returns
           //here it's true because list friends was changed
           System.out.println(friends.addAll(newFriends));
           System.out.println("My new list with new friends added: ");
           System.out.println(friends);
       }
   }

అవుట్పుట్: మనం అదే ఆపరేషన్ చేసి స్నేహితులకు ఖాళీ జాబితాను జోడించడానికి ప్రయత్నిస్తే, పద్ధతి పని చేస్తుంది, కానీ అసలైన జాబితా మారనందున అది తప్పుగా తిరిగి వస్తుంది.

import java.util.ArrayList;
       import java.util.List;

public class AddAllDemo3 {
   public static void main(String[] args) {
       List<String> friends = new ArrayList<>();
       friends.add("Johnny");
       friends.add("Ivy");
       friends.add("Rick");
       System.out.println(friends);
       List<String> newFriends = new ArrayList<>();
       System.out.println(newFriends);
       System.out.println(friends.addAll(newFriends));
       System.out.println("My new list with new friends added: ");
       System.out.println(friends);
   }
}

అవుట్‌పుట్: ఇప్పుడు రెండు పారామితులతో addAll() పద్ధతిని ప్రయత్నిద్దాం .

boolean addAll(int index, Collection<? extends E> c)

తోకలో కాకుండా మధ్యలో మళ్లీ కొత్త స్నేహితులను లిస్టులో చేర్చుకుందాం. జానీ తర్వాత చెప్పండి, ఇది మన విషయంలో సున్నా సంఖ్యతో ఉంటుంది.

import java.util.ArrayList;
import java.util.List;

public class AddAllDemo2 {
   public static void main(String[] args) {

       List<String> friends = new ArrayList<>();
       friends.add("Johnny");
       friends.add("Ivy");
       friends.add("Rick");
       System.out.println(friends);
       List<String> newFriends = new ArrayList<>();
       newFriends.add("Andrew");
       newFriends.add("Alex");
       newFriends.add("Neil");
       System.out.println(newFriends);
       System.out.println(friends.addAll(1, newFriends));
       System.out.println("My new list with new friends added: ");
       System.out.println(friends);
   }
}

ప్రోగ్రామ్ యొక్క పని యొక్క ఆశించిన ఫలితం: ఆండ్రూ ఇప్పుడు సంయుక్త జాబితాలో నంబర్ 1, అలెక్స్ - 2, నీల్ - 3, మరియు ముందు # 1 స్థానంలో ఉన్న ఐవీ 4వ స్థానానికి చేరుకున్నారు.