java arraylist conversions other collections
In diesem Lernprogramm werden ArrayList-Konvertierungen in andere Sammlungen wie Set, LinkedList, Listen usw. sowie Unterschiede zwischen diesen Sammlungen erläutert:
Bisher haben wir fast alle Konzepte im Zusammenhang mit ArrayList in Java gesehen. Neben dem Erstellen und Bearbeiten von ArrayList mithilfe verschiedener Operationen oder Methoden, die von der ArrayList-Klasse bereitgestellt werden, ist es manchmal auch erforderlich, ArrayList in eine oder mehrere Sammlungen zu konvertieren.
=> Besuchen Sie hier, um Java von Grund auf neu zu lernen.
In diesem Tutorial werden einige der Konvertierungen von ArrayList in andere Sammlungen erläutert, darunter List, LinkedList, Vector, Set usw. Wir werden auch die Konvertierung zwischen ArrayList und String in Betracht ziehen. Nach der Konvertierung werden auch die Unterschiede zwischen ArrayLists und anderen Sammlungen erläutert - Arrays, List, Vector, LinkedList usw.
Was du lernen wirst:
- Konvertierung von ArrayList in String
- Konvertierung von Zeichenfolgen in ArrayList
- Liste in ArrayList konvertieren In Java
- Konvertieren Sie ArrayList in Java
- Set in ArrayList in Java konvertieren
- Ein Array von ArrayList in Java
- ArrayList von Arrays in Java
- Liste gegen ArrayList in Java
- Vektor gegen ArrayList
- ArrayList vs LinkedList
- Häufig gestellte Fragen
- Fazit
- Literatur-Empfehlungen
Konvertierung von ArrayList in String
Die folgenden Methoden können verwendet werden, um ArrayList in String zu konvertieren.
# 1) Verwenden eines StringBuilder-Objekts
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); } } Ausgabe:
Die ArrayList: (Software, Testen, Hilfe)
Zeichenfolge aus ArrayList: Hilfe zum Testen von Software
Im obigen Programm wird ein StringBuilder-Objekt erstellt. Mit der forEach-Schleife wird dann jedes Element in der ArrayList an das StringBuilder-Objekt angehängt. Dann wird das StringBuilder-Objekt in einen String konvertiert. Beachten Sie, dass Sie die StringBuilder-Methode 'Anhängen' verwenden. Sie können der Zeichenfolge auch ein entsprechendes Trennzeichen hinzufügen.
Im obigen Beispiel haben wir Leerzeichen („“) als Trennzeichen verwendet.
# 2) Verwenden der String.join () -Methode
Mit der Methode String.join () kann die ArrayList in String konvertiert werden. Hier können Sie auch ein entsprechendes Trennzeichen an die Join-Methode übergeben.
Das folgende Programm zeigt dies.
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); } }Ausgabe:
Die ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
Aus ArrayList konvertierter String: Delhi Mumbai Chennai Kolkata
Sie können sehen, dass wir die ArrayList zusammen mit dem Trennzeichen direkt als Argument an die String.join () -Methode übergeben.
Für einfache String ArrayLists ist String.join () die beste Methode zum Konvertieren in String. Bei komplexeren ArrayLists-Objekten ist die Verwendung von StringBuilder jedoch effizienter.
Konvertierung von Zeichenfolgen in ArrayList
Um einen String in ArrayList zu konvertieren, gibt es zwei Schritte:
- Die Zeichenfolge wird mit der Funktion split () aufgeteilt, und die Teilzeichenfolgen (auf dem entsprechenden Trennzeichen aufgeteilt) werden in einem Zeichenfolgenarray gespeichert.
- Das durch Aufteilen des Strings erhaltene String-Array wird dann mit der Methode 'asList ()' der Arrays-Klasse in ArrayList konvertiert.
Das Programm zum Konvertieren von Zeichenfolgen in ArrayList ist unten angegeben.
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 ); } } Ausgabe:
Die Eingabezeichenfolge: Die Zeichenfolge für das ArrayList-Programm
Die ArrayList von String: (Das Programm, string, to, ArrayList,)
Im obigen Programm teilen wir die Zeichenfolge in Leerzeichen auf und sammeln sie in einem Zeichenfolgenarray. Dieses Array wird dann in eine ArrayList von Zeichenfolgen konvertiert.
Liste in ArrayList konvertieren In Java
ArrayList implementiert die List-Schnittstelle. Wenn Sie eine Liste in ihre Implementierung wie ArrayList konvertieren möchten, können Sie dies mit der addAll-Methode der List-Schnittstelle tun.
Das folgende Programm zeigt die Konvertierung der Liste in ArrayList, indem alle Listenelemente zur ArrayList hinzugefügt werden.
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); } } Ausgabe:
Listeninhalt: (ArrayList, Vector, LinkedList, Stack, Set, Map)
ArrayList nach dem Hinzufügen von Elementen: (ArrayList, Vector, LinkedList, Stack, Set, Map)
Konvertieren Sie ArrayList in Java
Die folgenden Methoden konvertieren eine ArrayList in eine Gruppe.
# 1) Verwenden eines traditionellen iterativen Ansatzes
Dies ist der traditionelle Ansatz. Hier durchlaufen wir die Liste und fügen jedes Element der ArrayList zur Menge hinzu.
Im folgenden Programm haben wir eine ArrayList von Zeichenfolgen. Wir deklarieren ein HashSet von string. Dann iterieren wir mit der forEach-Schleife über die ArrayList und fügen jedes Element dem HashSet hinzu.
In ähnlicher Weise können wir ArrayList auch in ein treeSet konvertieren.
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); } } Ausgabe:
Die ArrayList: (Rot, Grün, Blau, Cyan, Magenta, Gelb)
Von ArrayList erhaltenes HashSet: (Rot, Cyan, Blau, Gelb, Magenta, Grün)
# 2) Set Constructor verwenden
Die nächste Methode zum Konvertieren einer ArrayList in eine Menge ist die Verwendung des Konstruktors. Bei dieser Methode übergeben wir die ArrayList als Argument an den Set-Konstruktor und initialisieren so das Set-Objekt mit ArrayList-Elementen.
Das folgende Programm zeigt die Verwendung von ArrayList beim Erstellen eines festgelegten Objekts.
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); } } Ausgabe:
Die ArrayList: (Rot, Grün, Blau, Cyan, Magenta, Gelb
TreeSet aus ArrayList: (Blau, Cyan, Grün, Magenta, Rot, Gelb)
# 3) Verwenden der addAll-Methode
Sie können auch die addAll-Methode von Set verwenden, um alle Elemente von ArrayList zum Set hinzuzufügen.
Wie deklariere ich ein String-Array in Java?
Das folgende Programm verwendet die addAll-Methode, um die Elemente von ArrayList zum HashSet hinzuzufügen.
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); } } Ausgabe:
Die ArrayList: (Rot, Grün, Blau, Cyan, Magenta, Gelb)
Von ArrayList erhaltenes HashSet: (Rot, Cyan, Blau, Gelb, Magenta, Grün)
# 4) Verwenden von Java 8 Stream
Streams sind die neuen Ergänzungen zu Java 8. Diese Stream-Klasse bietet eine Methode zum Konvertieren von ArrayList in Stream und anschließendes Festlegen.
Das folgende Java-Programm demonstriert die Verwendung der Stream-Klassenmethode zum Konvertieren von ArrayList in 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); } } Ausgabe:
Die ArrayList: (Rot, Grün, Blau, Cyan, Magenta, Gelb)
Set aus ArrayList: (Rot, Cyan, Blau, Gelb, Magenta, Grün)
Set in ArrayList in Java konvertieren
Im letzten Abschnitt haben wir die Konvertierung von ArrayList in Set gesehen. Bei der Konvertierung von Set in ArrayList werden dieselben Methoden wie oben beschrieben verwendet, mit dem Unterschied, dass sich die Position von Set und ArrayList ändert.
Im Folgenden finden Sie Programmierbeispiele zum Konvertieren von Set in ArrayList. Die andere Beschreibung für jede Methode bleibt gleich.
# 1) Iterativer Ansatz
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); } } Ausgabe:
Das gegebene Set: (Eins, Zwei, Drei)
ArrayList aus Set: (Eins, Zwei, Drei)
Im obigen Programm durchlaufen wir die Menge und jedes Mengenelement wird der ArrayList hinzugefügt.
# 2) Konstruktor verwenden
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); } } Ausgabe:
Das gegebene Set: (Eins, Zwei, Drei)
ArrayList aus Set: (Eins, Zwei, Drei)
Das obige Programm erstellt eine Menge und eine ArrayList. Das ArrayList-Objekt wird erstellt, indem in seinem Konstruktor ein festgelegtes Objekt als Argument angegeben wird.
# 3) Verwenden der addAll-Methode
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); } } Ausgabe:
Das gegebene Set: (Eins, Zwei, Drei)
ArrayList aus Set: (Eins, Zwei, Drei)
Hier verwenden wir die addAll-Methode von ArrayList, um die Elemente aus der Menge zur ArrayList hinzuzufügen.
# 4) Verwenden von Java 8 Stream
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); } } Ausgabe:
Das gegebene Set: (Eins, Zwei, Drei)
ArrayList aus Set: (Eins, Zwei, Drei)
Das obige Programm verwendet die Stream-Klasse, um Set in ArrayList zu konvertieren.
Ein Array von ArrayList in Java
Ein Array von ArrayList besteht, wie der Name schon sagt, aus ArrayLists als Elementen. Obwohl die Funktion nicht regelmäßig verwendet wird, wird sie verwendet, wenn eine effiziente Nutzung des Speicherplatzes erforderlich ist.
Das folgende Programm implementiert ein Array von ArrayLists in 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 Ausgabe:
c ++ Eingabe Ausgabedatei
Inhalt des Arrays von ArrayList:
(Eins, zwei, zwei)
(Rot grün blau)
Im obigen Programm definieren wir zunächst zwei Listen. Dann deklarieren wir ein Array aus zwei ArrayList. Jedes Element dieses Arrays ist die zuvor definierte ArrayList. Schließlich wird der Inhalt eines Arrays von ArrayList mithilfe einer for-Schleife angezeigt.
ArrayList von Arrays in Java
So wie wir ein Array von ArrayLists haben, können wir auch ArrayList von Arrays haben. Hier ist jedes einzelne Element einer ArrayList ein Array.
Das folgende Programm demonstriert 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)); } } } Ausgabe:
Inhalt von ArrayList of Arrays:
(Rot grün blau)
(Pune, Mumbai, Delhi)
Das obige Programm demonstriert ArrayList of Arrays. Zunächst deklarieren wir eine ArrayList von String-Arrays. Dies bedeutet, dass jedes Element von ArrayList ein String-Array ist. Als nächstes definieren wir zwei String-Arrays. Anschließend wird jedes der Arrays zur ArrayList hinzugefügt. Schließlich drucken wir den Inhalt von ArrayList of Arrays.
Um den Inhalt zu drucken, durchlaufen wir die ArrayList mit der for-Schleife. Für jede Iteration drucken wir den Inhalt des ArrayList-Elements, das ein Array enthält, mit der Methode Arrays.toString ().
Liste gegen ArrayList in Java
Die folgenden Tabellen zeigen einige der Unterschiede zwischen einer Liste und einer ArrayList.
Liste Anordnungsliste Die Liste ist eine Schnittstelle in Java ArrayList ist Teil des Java Collection-Frameworks Die Liste ist als Schnittstelle implementiert ArrayList ist als Auflistungsklasse implementiert Erweitert die Sammlungsschnittstelle implementiert die List-Schnittstelle und erweitert AbstractList Teil des System.Collection.generic-Namespace Teil des System.Collections-Namespace Mit List kann eine Liste von Elementen erstellt werden, auf die über Indizes zugegriffen werden kann. Mit ArrayList können wir ein dynamisches Array von Elementen oder Objekten erstellen, deren Größe sich automatisch mit den Änderungen des Inhalts ändert.
Vektor gegen ArrayList
Im Folgenden sind einige der Unterschiede zwischen einem Vektor und einer ArrayList aufgeführt.
Anordnungsliste LinkedList ArrayList implementiert die List-Schnittstelle LinkedList implementiert List- und Deque-Schnittstellen. Datenspeicherung und Zugriff sind in ArrayList effizient. LinkedList kann Daten gut bearbeiten. ArrayList implementiert intern ein dynamisches Array. LinkedList implementiert intern eine doppelt verknüpfte Liste. Da ArrayList intern ein dynamisches Array implementiert, ist das Hinzufügen / Löschen von Elementen langsam, da viele Bitverschiebungen erforderlich sind. LinkedList ist beim Hinzufügen / Entfernen von Elementen schneller, da keine Bitverschiebung erforderlich ist. Weniger Speicheraufwand, da in ArrayList nur tatsächliche Daten gespeichert werden. Mehr Speicheraufwand, da jeder Knoten in LinkedList Daten sowie die Adresse zum nächsten Knoten enthält.
ArrayList vs LinkedList
Lassen Sie uns nun die verschiedenen Unterschiede zwischen einer ArrayList und einer LinkedList diskutieren.
Anordnungsliste LinkedList ArrayList implementiert die List-Schnittstelle LinkedList implementiert List- und Deque-Schnittstellen. Datenspeicherung und Zugriff sind in ArrayList effizient. LinkedList kann Daten gut bearbeiten. ArrayList implementiert intern ein dynamisches Array. LinkedList implementiert intern eine doppelt verknüpfte Liste. Da ArrayList intern ein dynamisches Array implementiert, ist das Hinzufügen / Löschen von Elementen langsam, da viele Bitverschiebungen erforderlich sind. LinkedList ist beim Hinzufügen / Entfernen von Elementen schneller, da keine Bitverschiebung erforderlich ist. Weniger Speicheraufwand, da in ArrayList nur tatsächliche Daten gespeichert werden. Mehr Speicheraufwand, da jeder Knoten in LinkedList Daten sowie die Adresse zum nächsten Knoten enthält.
Häufig gestellte Fragen
F # 1) Wie konvertiert man eine ArrayList in ein Array in Java?
Antworten: Um eine ArrayList in Java in ein Array zu konvertieren, können Sie die toArray () -Methode der ArrayList-API verwenden, die eine bestimmte ArrayList in ein Array konvertiert.
Q # 2) Wie teilt man eine Zeichenfolge und speichert sie in einer ArrayList in Java?
Antworten: Die Zeichenfolge wird mithilfe einer split () - Funktion aufgeteilt. Diese Methode gibt ein Array von Zeichenfolgen zurück. Mit der Methode Arrays.asList () kann das String-Array dann in eine ArrayList von Strings konvertiert werden.
F # 3) Was ist die Standardgröße einer ArrayList?
Antworten: Ein ArrayList-Objekt, das ohne Angabe der Kapazität erstellt wurde, hat die Größe 0, da der Liste keine Elemente hinzugefügt wurden. Die Standardkapazität dieser ArrayList beträgt jedoch 10.
F # 4) Was ist der Unterschied zwischen Länge () und Größe () von ArrayList?
Antworten: Eine ArrayList hat keine Eigenschaft oder Methode length (). Es wird nur die size () -Methode bereitgestellt, die die Gesamtzahl der Elemente in der ArrayList zurückgibt.
F # 5) Was ist der Unterschied zwischen der Kapazität und der Größe von ArrayList?
Antworten: ArrayList besitzt sowohl Kapazität als auch Größe. Die Kapazität ist die Gesamtgröße der ArrayList oder die Gesamtzahl der Elemente, die sie enthalten kann. Größe ist die Anzahl der Elemente oder Positionen, in denen Daten enthalten sind.
Zum Beispiel, Wenn die ArrayList-Kapazität 10 und die Größe 5 beträgt, bedeutet dies, dass eine ArrayList bis zu 10 Elemente enthalten kann, aber derzeit nur 5 Standorte Daten enthalten.
Fazit
In diesem Tutorial haben wir einige der zusätzlichen Konzepte im Zusammenhang mit ArrayList erläutert, z. B. das Konvertieren von ArrayList in eine Zeichenfolge, eine Liste, eine Menge und umgekehrt. Wir haben auch die Unterschiede zwischen ArrayList und Vector, ArrayList und LinkedList usw. diskutiert.
In unserem nächsten Tutorial werden wir eine weitere Sammlung aufnehmen und sie gründlich lernen.
=> Hier finden Sie A-Z der Java-Schulungsanleitungen.
Literatur-Empfehlungen
- Java String mit String Buffer und String Builder Tutorial
- Java ArrayList - Deklarieren, Initialisieren und Drucken einer ArrayList
- Java Reflection Tutorial mit Beispielen
- Java String Tutorial | Java-String-Methoden mit Beispielen
- Java-Threads mit Methoden und Lebenszyklus
- Java-Bereitstellung: Erstellung und Ausführung einer Java-JAR-Datei
- Java-Grundlagen: Java-Syntax, Java-Klasse und Java-Kernkonzepte
- Java Virtual Machine: Wie JVM beim Ausführen von Java-Anwendungen hilft
