java arraylist conversions other collections
Acest tutorial discută conversiile ArrayList la alte colecții cum ar fi Set, LinkedList, liste etc., împreună cu diferențele dintre aceste colecții:
Până acum am văzut aproape toate conceptele legate de ArrayList în Java. În afară de crearea și manipularea ArrayList utilizând diverse operațiuni sau metode furnizate de clasa ArrayList, uneori este necesar și să convertiți ArrayList într-una sau mai multe colecții.
=> Vizitați aici pentru a afla Java de la zero.
În acest tutorial, vom discuta unele dintre conversiile de la ArrayList la alte colecții care includ List, LinkedList, Vector, Set etc. Vom lua în considerare și conversia între ArrayList și String. După conversii, vom discuta, de asemenea, diferențele dintre ArrayLists și alte colecții - Arrays, List, Vector, LinkedList etc.
Ce veți învăța:
- Conversie ArrayList To String
- Conversie String To ArrayList
- Convertiți lista în ArrayList în Java
- Convertiți ArrayList pentru a seta în Java
- Convertiți setul în ArrayList în Java
- O matrice de liste Array în Java
- ArrayList of Array în Java
- Listează Vs ArrayList în Java
- Vector Vs ArrayList
- ArrayList vs LinkedList
- întrebări frecvente
- Concluzie
- Lectură recomandată
Conversie ArrayList To String
Următoarele metode pot fi utilizate pentru a converti ArrayList în șir.
# 1) Utilizarea unui obiect StringBuilder
import java.util.ArrayList; public class Main { public static void main(String args()) { //Create and initialize the ArrayList ArrayList strList = new ArrayList(); strList.add('Software'); strList.add('Testing'); strList.add('Help'); //print the ArrayList System.out.println('The ArrayList: ' + strList); //define a stringbuilder object StringBuffer sb = new StringBuffer(); //append each ArrayList element to the stringbuilder object for (String str : strList) { sb.append(str + ' '); } //convert stringbuilder to string and print it. String myStr = sb.toString(); System.out.println('
String from ArrayList: ' + myStr); } } Ieșire:
Lista Array: (Software, Testare, Ajutor)
Șir din ArrayList: Ajutor pentru testarea software-ului
În programul de mai sus, este creat un obiect StringBuilder. Apoi, utilizând bucla forEach, fiecare element din ArrayList este atașat la obiectul StringBuilder. Apoi obiectul StringBuilder este convertit într-un șir. Rețineți că folosind metoda „adăugați” StringBuilder; puteți adăuga, de asemenea, delimitator corespunzător șirului.
În exemplul de mai sus, am folosit spațiul („„) ca delimitator.
# 2) Folosind metoda String.join ()
Metoda String.join () poate fi utilizată pentru a converti ArrayList în String. Aici puteți trece, de asemenea, un delimitator adecvat metodei de asociere.
Programul de mai jos demonstrează acest lucru.
import java.util.ArrayList; public class Main { public static void main(String() args) { // create and initialize the ArrayList ArrayList metroList = new ArrayList(); metroList.add('Delhi'); metroList.add('Mumbai'); metroList.add('Chennai'); metroList.add('Kolkata'); //print the ArrayList System.out.println('The ArrayList: ' + metroList); // Join with an empty delimiter to concat all strings. String resultStr = String.join(' ', metroList); System.out.println('
String converted from ArrayList: '+resultStr); } }Ieșire:
The ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
Șir convertit din ArrayList: Delhi Mumbai Chennai Kolkata
Puteți vedea că trecem direct ArrayList ca argument la metoda String.join () împreună cu delimitatorul.
Pentru StringLists simple String, String.join () este cea mai bună metodă de conversie în String. Dar pentru obiectele ArrayLists mai complexe, utilizarea StringBuilder este mai eficientă.
Conversie String To ArrayList
Pentru a converti un șir în ArrayList, există doi pași:
- Șirul este împărțit folosind funcția split (), iar șirurile de caractere (împărțite pe delimitatorul adecvat) sunt stocate într-un șir de matrice.
- Matricea de șiruri obținută din împărțirea șirului este apoi convertită în ArrayList folosind metoda ‘asList ()’ din clasa Arrays.
Programul de conversie a șirului în ArrayList este dat mai jos.
import java.util.ArrayList; import java.util.List; import java.util.Arrays; public class Main { public static void main(String args()){ //define a string String myStr = 'The string to ArrayList program'; //convert string to array using split function on spaces String strArray() = myStr.split(' '); //print the string System.out.println('The input string : ' + myStr); //declare an ArrayList List strList = new ArrayList(); //convert string array to ArrayList using asList method strList = Arrays.asList(strArray); //print the resultant ArrayList System.out.println('
The ArrayList from String:' + strList ); } } Ieșire:
Șirul de intrare: șirul către programul ArrayList
ArrayList de la String: (The, string, to, ArrayList, program)
În programul de mai sus, împărțim șirul în spații și îl colectăm într-o matrice de șiruri. Această matrice este apoi convertită într-o ArrayList de șiruri.
Convertiți lista în ArrayList în Java
ArrayList implementează interfața List. Dacă doriți să convertiți o listă la implementarea acesteia, cum ar fi ArrayList, puteți face acest lucru folosind metoda addAll a interfeței List.
Programul de mai jos arată conversia listei în ArrayList prin adăugarea tuturor elementelor listei în ArrayList.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String a()){ //create a list & initiliaze it List collections_List = new ArrayList(); collections_List.add('ArrayList'); collections_List.add('Vector'); collections_List.add('LinkedList'); collections_List.add('Stack'); collections_List.add('Set'); collections_List.add('Map'); //print the list System.out.println('List contents: '+collections_List); //create an ArrayList ArrayList myList = new ArrayList(); //use addAll() method to add list elements to ArrayList myList.addAll(collections_List); //print the ArrayList System.out.println('
ArrayList after adding elements: '+myList); } } Ieșire:
Conținutul listei: (ArrayList, Vector, LinkedList, Stack, Set, Map)
ArrayList după adăugarea de elemente: (ArrayList, Vector, LinkedList, Stack, Set, Map)
Convertiți ArrayList pentru a seta în Java
Următoarele metode convertesc un ArrayList într-un set.
# 1) Folosind o abordare iterativă tradițională
Aceasta este abordarea tradițională. Aici, iterăm prin listă și adăugăm fiecare element al ArrayList la set.
În programul de mai jos, avem un ArrayList de șiruri. Declarăm un HashSet de șir. Apoi, folosind bucla forEach, vom itera peste ArrayList și adăugăm fiecare element la HashSet.
În mod similar, putem converti ArrayList într-un treeSet.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a HashSet Set hSet = new HashSet(); //Add each ArrayList element to the set for (String x : colorsList) hSet.add(x); //Print the HashSet System.out.println('
HashSet obtained from ArrayList: ' + hSet); } } Ieșire:
Lista Array: (Roșu, Verde, Albastru, Cyan, Magenta, Galben)
HashSet obținut din ArrayList: (Roșu, Cyan, Albastru, Galben, Magenta, Verde)
# 2) Utilizarea Set Constructor
Următoarea metodă pentru a converti un ArrayList într-un set este folosirea constructorului. În această metodă, trecem ArrayList ca argument către constructorul setului și astfel inițializăm obiectul set cu elemente ArrayList.
Programul de mai jos arată utilizarea ArrayList în crearea unui obiect set.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a TreeSet Set tSet = new TreeSet(colorsList); //Print the TreeSet System.out.println('
TreeSet obtained from ArrayList: ' + tSet); } } Ieșire:
Lista Array: (Roșu, Verde, Albastru, Cyan, Magenta, Galben
TreeSet obținut din ArrayList: (Albastru, Cyan, Verde, Magenta, Roșu, Galben)
# 3) Utilizarea metodei addAll
De asemenea, puteți utiliza metoda addAll din Set pentru a adăuga toate elementele ArrayList la set.
Următorul program folosește metoda addAll pentru a adăuga elementele ArrayList la HashSet.
import java.util.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); //Declare a HashSet Set hSet = new HashSet(); //use addAll method of HashSet to add elements of ArrayList hSet.addAll(colorsList); //Print the HashSet System.out.println('
HashSet obtained from ArrayList: ' + hSet); } } Ieșire:
Lista Array: (Roșu, Verde, Albastru, Cyan, Magenta, Galben)
HashSet obținut din ArrayList: (Roșu, Cyan, Albastru, Galben, Magenta, Verde)
cum se utilizează stringstream în c ++
# 4) Utilizarea fluxului Java 8
Fluxurile sunt noile adăugiri la Java 8. Această clasă de flux oferă o metodă pentru a converti ArrayList în flux și apoi pentru a seta.
Programul Java de mai jos demonstrează utilizarea metodei clasei de flux pentru a converti ArrayList la set.
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create & initialize an ArrayList ArrayList colorsList = new ArrayList (Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow')); //print the ArrayList System.out.println('The ArrayList:' + colorsList); // Convert ArrayList to set using stream Set set = colorsList.stream().collect(Collectors.toSet()); //Print the Set System.out.println('
Set obtained from ArrayList: ' + set); } } Ieșire:
Lista Array: (Roșu, Verde, Albastru, Cyan, Magenta, Galben)
Set obținut din ArrayList: (Roșu, Cyan, Albastru, Galben, Magenta, Verde)
Convertiți setul în ArrayList în Java
În ultima secțiune, am văzut conversia ArrayList în Set. Conversia de la Set la ArrayList folosește, de asemenea, aceleași metode descrise mai sus, cu diferența că se modifică poziția setului și ArrayList.
Mai jos sunt exemple de programare pentru a converti Setul în ArrayList. Cealaltă descriere pentru fiecare metodă rămâne aceeași.
# 1) Abordare iterativă
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList ArrayList numList = new ArrayList(set.size()); //add each set element to the ArrayList using add method for (String str : set) numList.add(str); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Ieșire:
Setul dat: (Unu, Doi, Trei)
ArrayList obținut din Set: (Unu, Doi, Trei)
În programul de mai sus, iterăm prin Set și fiecare element de set este adăugat la ArrayList.
# 2) Utilizarea Constructor
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList and pass set to the constructor List numList = new ArrayList(set); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Ieșire:
Setul dat: (Unu, Doi, Trei)
ArrayList obținut din Set: (Unu, Doi, Trei)
Programul de mai sus creează un set și un ArrayList. Obiectul ArrayList este creat prin furnizarea unui obiect set ca argument în constructorul său.
# 3) Utilizarea metodei addAll
import java.util.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList List numList = new ArrayList(); //use addAll method of ArrayList to add elements of set numList.addAll(set); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Ieșire:
Setul dat: (Unu, Doi, Trei)
ArrayList obținut din Set: (Unu, Doi, Trei)
Aici, folosim metoda addAll din ArrayList pentru a adăuga elementele din set în ArrayList.
# 4) Utilizarea fluxului Java 8
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a set of strings & add elements to it Set set = new HashSet(); set.add('One'); set.add('Two'); set.add('Three'); //print the set System.out.println('The given Set: ' + set); //create an ArrayList and using stream method,assign stream of elements to ArrayList List numList = set.stream().collect(Collectors.toList()); //print the ArrayList System.out.println('
ArrayList obtained from Set: ' + numList); } } Ieșire:
Setul dat: (Unu, Doi, Trei)
ArrayList obținut din Set: (Unu, Doi, Trei)
Programul de mai sus folosește clasa de flux pentru a converti Setul în ArrayList.
O matrice de liste Array în Java
Un Array of ArrayList, așa cum sugerează și numele, este format din ArrayLists ca elemente. Deși caracteristica nu este utilizată în mod regulat, este utilizată atunci când este necesară utilizarea eficientă a spațiului de memorie.
Următorul program implementează o matrice de liste Array în Java.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String() args) { //define and initialize a num_list List num_list = new ArrayList(); num_list.add('One'); num_list.add('Two'); num_list.add('Two'); //define and initialize a colors_list List colors_list = new ArrayList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); //define Array of ArrayList with two elements List() arrayOfArrayList = new List(2); //add num_list as first element arrayOfArrayList(0) = num_list; //add colors_list as second element arrayOfArrayList(1) = colors_list; //print the contents of Array of ArrayList System.out.println('Contents of Array of ArrayList:'); for (int i = 0; i Ieșire:
Conținutul Array of ArrayList:
(Unu, Doi, Doi)
(Roșu, Verde, Albastru)
În programul de mai sus, definim mai întâi două liste. Apoi declarăm un Array de două ArrayList. Fiecare element al acestui tablou este ArrayList definit mai devreme. În cele din urmă, conținutul unui Array of ArrayList este afișat folosind o buclă for.
ArrayList of Array în Java
Așa cum avem un Array of ArrayLists, putem avea și ArrayList of Arrays. Aici, fiecare element individual al unei ArrayList este un Array.
Programul de mai jos demonstrează ArrayList of Arrays.
import java.util.*; public class Main { public static void main(String() args) { // declare ArrayList of String arrays ArrayList ArrayList_Of_Arrays = new ArrayList(); //define individual string arrays String() colors = { 'Red', 'Green', 'Blue' }; String() cities = { 'Pune', 'Mumbai', 'Delhi'}; //add each array as element to ArrayList ArrayList_Of_Arrays.add(colors); ArrayList_Of_Arrays.add(cities); // print ArrayList of Arrays System.out.println('Contents of ArrayList of Arrays:'); for (String() strArr : ArrayList_Of_Arrays) { System.out.println(Arrays.toString(strArr)); } } } Ieșire:
Conținutul ArrayList of Array:
(Roșu, Verde, Albastru)
(Pune, Mumbai, Delhi)
Programul de mai sus demonstrează ArrayList of Arrays. Inițial, declarăm ArrayList of String Arrays. Acest lucru înseamnă că fiecare element din ArrayList va fi un String Array. Apoi, definim două matrice de șiruri. Apoi, fiecare dintre matrice este adăugată la ArrayList. În cele din urmă, imprimăm conținutul ArrayList of Arrays.
Pentru a imprima conținutul, parcurgem ArrayList folosind bucla for. Pentru fiecare iterație, imprimăm conținutul elementului ArrayList care are un Array folosind metoda Arrays.toString ().
Listează Vs ArrayList în Java
Următoarele tabele prezintă câteva dintre diferențele dintre o Listă și ArrayList.
Listă ArrayList Lista este o interfață în Java ArrayList face parte din cadrul Java Collection Lista este implementată ca o interfață ArrayList este implementat ca o clasă de colecție Extinde interfața de colecție implementează interfața Listă și extinde AbstractList O parte din spațiul de nume System.Collection.generic Parte a spațiului de nume System.Collections Folosind List, se poate crea o listă de elemente care pot fi accesate folosind indici. Folosind ArrayList, putem crea o matrice dinamică de elemente sau obiecte a căror dimensiune se modifică automat odată cu modificările de conținut.
Vector Vs ArrayList
Date mai jos sunt câteva dintre diferențele dintre un vector și un ArrayList.
ArrayList LinkedList ArrayList implementează interfața List LinkedList implementează interfețele List și Deque. Stocarea și accesul datelor sunt eficiente în ArrayList. LinkedList este bun la manipularea datelor. ArrayList implementează intern o matrice dinamică. LinkedList implementează intern o listă dublă legată. Deoarece ArrayList implementează intern matrice dinamică, adăugarea / ștergerea elementelor este lentă, deoarece este necesară o mulțime de schimbare de biți. LinkedList este mai rapid în ceea ce privește adăugarea / eliminarea elementelor, deoarece nu este necesară schimbarea de biți. Mai puține cheltuieli de memorie, deoarece în ArrayList sunt stocate doar datele reale. Mai multă memorie, deoarece fiecare nod din LinkedList conține date, precum și adresa către nodul următor.
ArrayList vs LinkedList
Să discutăm acum diferențele dintre o ArrayList și o LinkedList.
ArrayList LinkedList ArrayList implementează interfața List LinkedList implementează interfețele List și Deque. Stocarea și accesul datelor sunt eficiente în ArrayList. LinkedList este bun la manipularea datelor. ArrayList implementează intern o matrice dinamică. LinkedList implementează intern o listă dublă legată. Deoarece ArrayList implementează intern matrice dinamică, adăugarea / ștergerea elementelor este lentă, deoarece este necesară o mulțime de schimbare de biți. LinkedList este mai rapid în ceea ce privește adăugarea / eliminarea elementelor, deoarece nu este necesară schimbarea de biți. Mai puține cheltuieli de memorie, deoarece în ArrayList sunt stocate doar datele reale. Mai multă memorie, deoarece fiecare nod din LinkedList conține date, precum și adresa către nodul următor.
întrebări frecvente
Q # 1) Cum convertiți un ArrayList într-un Array în Java?
Răspuns: Pentru a converti un ArrayList într-un Array în Java, se poate folosi metoda toArray () din ArrayList API care convertește un ArrayList dat într-un Array.
Q # 2) Cum împărțiți un șir și îl stocați într-o ArrayList în Java?
Răspuns: Șirul este împărțit folosind o funcție split (). Această metodă returnează o matrice de șiruri. Apoi folosind metoda Arrays.asList (), matricea de șiruri poate fi convertită într-o ArrayList de șiruri.
Î # 3) Care este dimensiunea implicită a unui ArrayList?
Răspuns: Un obiect ArrayList creat fără a specifica capacitatea are o dimensiune 0 deoarece nu există elemente adăugate în listă. Dar capacitatea implicită a acestui ArrayList este 10.
Q # 4) Care este diferența dintre lungimea () și dimensiunea () ArrayList?
Răspuns: Un ArrayList nu are o proprietate sau o metodă length (). Oferă doar metoda size () care returnează numărul total de elemente din ArrayList.
Q # 5) Care este diferența dintre capacitatea și dimensiunea ArrayList?
Răspuns: ArrayList posedă atât capacitate, cât și dimensiune. Capacitatea este dimensiunea totală a ArrayList sau numărul total de elemente pe care le poate deține. Dimensiunea este numărul de elemente sau locații care conțin date.
De exemplu, dacă capacitatea ArrayList este 10 și dimensiunea sa este 5, aceasta înseamnă că o ArrayList poate conține până la 10 elemente, dar în prezent doar 5 locații au date în ele.
Concluzie
În acest tutorial, am discutat câteva dintre conceptele suplimentare legate de ArrayList, cum ar fi convertirea ArrayList într-un șir, listă, set și invers. De asemenea, am discutat despre diferențele dintre ArrayList și Vector, ArrayList și LinkedList etc.
În viitorul nostru tutorial, vom prelua o altă colecție și o vom învăța temeinic.
=> Verificați aici pentru a vedea A-Z a tutorialelor de instruire Java aici.
Lectură recomandată
- Java String cu buffer de șiruri și tutorial pentru generatorul de șiruri
- Java ArrayList - Cum să declarați, inițializați și tipăriți o listă Array
- Tutorial de reflecție Java cu exemple
- Tutorial Java String | Metode Java String cu exemple
- Fire Java cu metode și ciclu de viață
- Implementarea Java: crearea și executarea fișierului Java JAR
- Noțiuni de bază Java: Sintaxă Java, Java Class și Core Java Concepts
- Mașină virtuală Java: Cum ajută JVM la rularea aplicației Java
