covert list array
Denna handledning förklarar hur man konverterar Java-lista till matris och andra samlingar. Det innehåller exempel för att konvertera lista till array, sträng, set och vice versa:
I våra tidigare handledning diskuterade vi detaljerna i listsamlingen. Vi har sett de olika operationerna på listan, iteratorer etc. Med tanke på en lista kan vi konvertera den här listan till andra samlingar eller datastrukturer som strängar, matriser, ArrayList, set etc.
=> Besök här för den exklusiva Java-utbildningsserien.
Vad du kommer att lära dig:
Lista omvandlingar
Här, vad vi faktiskt gör är att vi överför elementen från en samling / struktur till en annan och därmed ändrar vi faktiskt elementens layout eftersom varje samling eller datastruktur har sin egen layout.
I den här handledningen kommer vi att diskutera några omvandlingar från listan till andra datastrukturer och vice versa.
Konvertera lista till sträng
Du kan enkelt konvertera elementlistan till dess strängrepresentation. För det mesta vill du konvertera en lista med strängar eller tecken till en strängrepresentation.
Det finns olika metoder för att konvertera listan till en sträng. De mest populära diskuteras nedan.
# 1) Använda toString-metoden
Detta är den enklaste metoden för att konvertera lista till sträng. I den här metoden använder du helt enkelt metoden 'toString' i en lista som konverterar listan till en strängrepresentation.
Programmet nedan visar implementeringen av toString-metoden.
import java.util.Arrays; import java.util.List; // Convert List of Characters to String in Java class Main { public static void main(String() args) { // create and initialize a character list List strList = Arrays.asList('H', 'e', 'l', 'l', 'o'); //convert list to string using toString method System.out.println('List converted to string representation:
' + strList.toString()); //replace comma between characters with blanks String string = strList.toString() .substring(1, 3 * strList.size() - 1) .replaceAll(', ', ''); // print string System.out.println('String representation by removing delimiters:
' + string); } } Produktion:
I det här programmet kan du se att efter att konvertera teckenlistan till en strängrepresentation, förfinas strängen ytterligare genom att ta bort avgränsande tecken från den och representera den som ett enda ord.
# 2) Använda Collectors Class
Från och med Java 8 kan du använda stream-API: er med klassen 'Collectors' för att konvertera listan till en sträng.
Exempel:
import java.util.stream.Collectors; import java.util.Arrays; import java.util.List; class Main { public static void main(String() args) { // create and initialize list List strList = Arrays.asList('W', 'o', 'r', 'l','d'); // convert list to string using collect and joining() method String string= strList.stream().map(String::valueOf).collect(Collectors.joining()); // print string System.out.println('List converted to string:' + string); } } Produktion:
I ovanstående program använder vi stream-API: er, kartlägger värdena och använder sedan metoden () i Collectors-klass och konverterar listan till sträng.
# 3) Använda StringBuilder Class
Den tredje metoden för att konvertera listan till sträng är att använda ett StringBuilder-objekt. Här läggs varje element i listan till StringBuilder-objektet med en slinga. Sedan konverteras StringBuilder-objektet till dess strängrepresentation med metoden toString.
Kontrollera följande program för demonstration.
import java.util.Arrays; import java.util.List; class Main { public static void main(String() args) { // create and initialize the list List strList = Arrays.asList('I', 'n', 'd', 'i', 'a'); // object of stringBuilder StringBuilder sb = new StringBuilder(); // use append method to append list element to StringBuilder object for (Character ch : strList) { sb.append(ch); } // convert StringBuilder object to string using toString() String string = sb.toString(); // print string System.out.println('List converted to string: ' + string); } } Produktion:
Ovanstående program visar användningen av StringBuilder-objektet som elementen i listan läggs till. Sedan konverteras objektet till en sträng.
Konvertera lista till en matris
Med en lista med element måste du konvertera den här listan till en matris. För att göra detta kan du använda någon av metoderna som beskrivs nedan.
# 1) Använda toArray
Det enklaste sättet att konvertera en lista till en array är att använda metoden 'toArray' i listan.
Följande program visar denna implementering av toArray-metoden.
import java.util.*; public class Main { public static void main(String() args) { //create and initialize list List strList = new LinkedList(); strList.add('This'); strList.add('is'); strList.add('Java'); strList.add('Tutorial'); System.out.println('The given list:' + strList); //use toArray method to convert list to array String() strArray = strList.toArray(new String(0)); //print the array System.out.println('The Array from List: '); for (String val : strArray) System.out.print(val + ' '); } } Produktion:
I programmet ovan har vi konverterat en lista med strängar till en strängmatris med metoden 'toArray'.
# 2) Använda Java 8 Stream
gratis Windows-rengöringsprogram och reparation
Nästa metod för att konvertera en lista till en matris är att använda ström-API: er för Java 8. I detta konverteras listan först till ström och sedan med ström (). ToArray konverteras den till en matris.
Följande Java-program visar denna konvertering.
import java.util.*; class Main { public static void main (String()args) { //create and initialize the list List l_list = new LinkedList (); l_list.add ('Software'); l_list.add ('Testing'); l_list.add ('Help'); l_list.add ('Tutorial'); System.out.println('The given list:' + l_list); //Convert list to array using stream and toArray methods String() str_array = l_list.stream ().toArray (String()::new); //print the array System.out.println('The Array converted from list : '); for (String val:str_array) System.out.print (val + ' '); } } Produktion:
Ovanstående program använder stream-API: er för Java 8 och konverterar listan till en array. Arrayen skrivs sedan ut med varje slinga.
# 3) Använda get-metoden
Detta är en annan metod för att konvertera listan till en matris. I detta använder vi get () i listan som kan användas för att hämta enskilda element i listan.
Programmet för att konvertera listan till en array med get () -metoden visas nedan.
import java.io.*; import java.util.List; import java.util.LinkedList; class Main { public static void main (String() args) { List colors_list = new LinkedList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Yellow'); System.out.println('Given list: ' + colors_list); //define the array String() colors_array = new String(colors_list.size()); // get list elements into the array for (int i =0; i Produktion:
I ovanstående program skapade vi en matris av samma storlek som en lista. Därefter hämtas listelementen med get () -metoden och tilldelas matrisen.
Konvertera Array To List
Eftersom du kan konvertera en lista till en array kan du också konvertera en array till en lista i Java. Nedan följer några av metoderna som du kan konvertera en matris till en lista.
# 1) Använda vanlig Java-kod
Detta är den traditionella metoden för att konvertera en matris till en lista. Här lägger du till varje arrayelement i listan en efter en med hjälp av en loop. För denna tilläggsmetod i listan används.
Följande program implementerar den traditionella metoden för att konvertera array till en lista.
import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String strArray() = { 'Java', 'Python', 'C++', 'SQL', 'Perl' }; // Print the Array System.out.println('Array: ' + Arrays.toString(strArray)); // Create a List List strlist = new ArrayList(); // Iterate through the array and add each element to the list for (String val : strArray) { strlist.add(val); } // Print the List System.out.println('
List obtained from array: ' + strlist); } } Produktion:
# 2) Använda asList () -metoden
Nästa metod för att konvertera en matris till en lista är att använda metoden asList () i Arrays-klassen. Här kan du skicka Array som ett argument till asList () -metoden och den returnerar den erhållna listan.
Följande program visar detta.
import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { //create and intialize array Integer() oddArray = { 1,3,5,7,9,11 }; //declare a list and use asList method to assign the array to list List oddList = Arrays.asList(oddArray); // Print the List System.out.println('List from array: ' + oddList); } } Produktion:
I programmet ovan har vi en rad udda nummer. Sedan skapar vi en lista med heltal och tilldelar den till utdata från asList-metoden som är en lista.
# 3) Använda Collection.addAll () -metoden
Du kan också använda metoden addAll () för samlingsklassen eftersom arrayen och listan är båda delar av samlingsramen i Java.
Följande program visar användningen av metoden Collections.addAll () för att konvertera array till lista.
import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String strArray() = { 'Java', 'C++', 'C', 'Perl', 'Python' }; // Print the Array System.out.println('Array: ' + Arrays.toString(strArray)); // create a string list List myList = new ArrayList(); // Add array to list using Collections addAll method Collections.addAll(myList, strArray); // Print the List System.out.println('List obtained from array: ' + myList); } } Produktion:
Här har vi initierat en matris. Vi skapade en tom lista. Då används metoden Collections.addAll () genom att skicka listor och array som ett argument. Framgångsrik körning av denna metod kommer att innehålla en lista fylld med arrayelementen.
# 4) Använda Java 8 Streams
Nästa metod för att konvertera array till lista är med hjälp av Java 8 Stream API och Collectors-klassen. Här konverteras matrisen först till ström och sedan samlas elementen in i en lista med ström. Samla metod. Listan returneras äntligen.
Följande program visar implementeringen som konverterar arrayen till en lista med Stream API.
import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String colorsArray() = { 'Red', 'Green', 'Blue', 'Yellow', 'Magenta' }; // Print the Array System.out.println('Array: ' + Arrays.toString(colorsArray)); // convert the Array to List using stream () and Collectors class List colorslist = Arrays .stream(colorsArray) .collect(Collectors.toList()); // Print the List System.out.println('List from Array: ' + colorslist); } } Produktion:
I programmet ovan skapas en rad färger. Därefter skapas en tom lista och sedan tilldelas listan från arrayen med hjälp av stream API.
Konvertera lista för att ställa in
En uppsättning är en oordnad samling av element som inte tillåter dubbla värden. Set är en del av Java Collections-ramverket. Du kan konvertera en lista för att ställa in och vice versa om det behövs.
I det här avsnittet kan vi se några av metoderna som används för att konvertera en lista till en uppsättning.
# 1) Använda den traditionella metoden
Du kan konvertera listan för att ställa in med traditionell Java-kod. I detta kan du skapa en HashSet eller treeSet. Och använd sedan add-metoden, lägg till varje listelement till uppsättningen i en loop.
Denna implementering visas nedan.
import java.util.*; class Main { public static void main(String() args) { // Creating a list of strings List strList = Arrays.asList('Java', 'Perl', 'Python', 'C++', 'C'); //print the list System.out.println('The list : ' + strList); //create a set Set hashSet = new HashSet(); //add list elements to hashset for (String ele : strList) hashSet.add(ele); //print the set System.out.println('HashSet from list:'); for (String val : hashSet) System.out.print(val + ' '); } } Produktion:
I ovanstående program kan du se att vi har skapat ett HashSet-objekt av typsträng. Därefter läggs varje element i listan till i setet med förbättrad för loop. Slutligen skrivs satsen ut.
Rekommenderad läsning = >> HashSet i Java
# 2) Använda HashSet eller trädkonstruktör
Nästa metod är att använda en uppsättningskonstruktör. Här skapar vi en uppsättningskonstruktör (treeSet eller HashSet). En lista skickas till denna konstruktör som ett argument. Med hjälp av den här listan är uppsättningen konstruerad.
Kontrollera programmet nedan för denna implementering.
import java.util.*; class Main { public static void main(String() args) { // Create a list of strings List strList = Arrays.asList('Red', 'Green', 'Blue', 'Yellow', 'Cyan', 'Magenta'); System.out.println('Original List:' + strList); // Creating a hash set using constructor and pass list to the constructor Set hashSet = new HashSet(strList); System.out.println('
HashSet created from list:'); //print the hashSet for (String val : hashSet) System.out.print(val + ' '); //Create a treeset using constructor and pass list to the constructor Set treeSet = new TreeSet(strList); System.out.println('
TreeSet from list: '); //print the treeset for (String x : treeSet) System.out.print(x + ' '); } } Produktion:
I ovanstående program skapar vi både HashSet och treeSet genom att skicka listan som argument. Slutligen visas innehållet i både HashSet och trädset.
# 3) Använda metoden AddAll
Detta är detsamma som addAll-metoden för samlingar som vi såg tidigare. Här används metoden addAll för att kopiera listinnehållet till uppsättningen.
Följande program visar användningen av addAll-metoden.
import java.util.*; class Main { public static void main(String() args) { // Creating a list of strings List intList = Arrays.asList(1,3,5,7,9,11,13); System.out.println('Original List: ' + intList); //create a hashset Set hashSet = new HashSet(); //add elements of list to hashSet using addAll method hashSet.addAll(intList); System.out.println('HashSet created from list: '); //print the hashSet for (Integer val : hashSet) System.out.print(val + ' '); } } Produktion:
Detta program skapar ett HashSet-objekt. Därefter anropas metoden addAll på HashSet-objektet med listan som parameter. Denna metod kopierar listinnehållet till uppsättningen.
# 4) Använda Java 8 Streams
Som redan sett kan du också använda Java 8-strömmar för att konvertera listan till någon annan samling inklusive uppsättning. Du måste använda stream (). Samla metoden för att göra detta.
Följande program visar denna implementering.
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a list of strings List colorsList = Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow'); System.out.println('Original List:' + colorsList); // Convert to set using stream and Collectors class toSet() method Set colorsSet = colorsList.stream().collect(Collectors.toSet()); System.out.println('The set from list:'); //print the set for (String x : colorsSet) System.out.print(x + ' '); } Produktion:
Ovanstående program liknar det som visas i fallet med konvertering från listan till en array. Först omvandlas listan till ström och sedan samlar samlingsmetoden strömelementen och konverteras för att ställa in.
Nu när vi har sett olika metoder som utför omvandlingen från listan till uppsättning, låt oss se metoderna som används för att konvertera uppsättningen till listan.
Konvertera Set To List
På samma sätt som du konverterar lista till set kan du också konvertera set till en lista. Du kan använda samma metoder som beskrivs ovan för denna konvertering. Den enda skillnaden är att du byter plats i listan och ställer in i programmet.
Nedan ges exempel på konvertering från uppsättning till lista för varje metod.
# 1) Använda vanlig Java
importjava.util.*; class Main { public static void main(String() args) { // Create a set(hashset) and initialize it Set hashSet = new HashSet(); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); hashSet.add('Cyan'); hashSet.add('Magenta'); hashSet.add('Yellow'); //print the set System.out.println('The set elements:'); for (String x : hashSet) System.out.print(x + ' '); //create a list (ArrayList) List strList = new ArrayList(hashSet.size()); //traverse the set and add its elements to the list for (String x : hashSet) strList.add(x); //print the list System.out.println('
Created ArrayList:' + strList); } } Produktion:
Ovanstående program deklarerar och initialiserar en uppsättning. Sedan skapar den en lista och lägger till varje uppsättningselement i listan. Slutligen skriver den ut listan.
# 2) Använda konstruktörer
import java.util.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize it Set hashSet = new HashSet(); hashSet.add('Delhi'); hashSet.add('Mumbai'); hashSet.add('Chennai'); hashSet.add('Kolkata'); //print the Set System.out.println('The set :'); for(String str: hashSet) System.out.print(str + ' '); //pass hashset to linkedlist constructor List l_List = new LinkedList(hashSet); //print the linked list System.out.println ('
LinkedList from set: ' + l_List); } } Produktion:
Här kan du använda listkonstruktören med ett angivet objekt som argument. Detta kopierar alla uppsatta element till listobjektet.
# 3) Använda metoden AddAll
import java.util.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize it Set hashSet = new HashSet(); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); hashSet.add('Cyan'); hashSet.add('Magenta'); hashSet.add('Yellow'); //print the Set System.out.println('The set: '); for(String x:hashSet) System.out.print(x + ' '); //create a list(ArrayList) List colorList = new ArrayList(); //use addAll method to add elements from set colorList.addAll(hashSet); //print the list System.out.println('
The ArrayList from set: ' + colorList); } } Produktion:
I det här programmet skapas ett listobjekt. Sedan använder du metoden Collections.addAll () och elementen i uppsättningen läggs till i listan.
# 4) Använda Java 8 Stream
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize the set Set hashSet = new HashSet(); hashSet.add('Yellow'); hashSet.add('Magenta'); hashSet.add('Cyan'); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); //print the Set System.out.println('The set:'); for(String str : hashSet) System.out.print(str + ' '); //create a list and assign it elements of set through stream and Collectors class List strList = hashSet.stream().collect(Collectors.toList()); //print the list System.out.println('
List obtained from set: ' + strList); } } Produktion:
Du kan också använda Java 8-strömmar och samlingsmetoden för att konvertera set till listan som visas i ovanstående program.
Array Vs List
Låt oss diskutera några av skillnaderna mellan en matris och en lista.
Array Lista Matrisen är en grundläggande datastruktur i Java. Listan är ett gränssnitt som ingår i samlingsramen i Java från vilken många av klasserna kan utökas som LinkedList, ArrayList etc. Har fast storlek Liststorleken är dynamisk. Matriselement kan nås med (). Listmedlemmar nås med metoder. Matrisen kan ha både primitiva typer och objekt som dess element. Listor kan endast innehålla objekt. Arrays kan använda operatörer med dess element. Listor kan inte använda operatörer. Istället listas användningsmetoder. Arrays kan inte fungera med generika för att säkerställa typsäkerhet. Listor kan vara generiska.
Vanliga frågor
F # 1) Hur konverterar du en lista till en array i Java?
Svar: Den grundläggande metoden för att konvertera en lista till en array i Java är att använda metoden “toArray ()” i List-gränssnittet.
Det enkla samtalet nedan konverterar listan till en matris.
Object() array = list.toArray();Det finns också andra metoder som diskuterats ovan för att konvertera listan till en matris.
F # 2) Är en matris en lista i Java?
Svar: Nej. En array är en grundstruktur i Java med en fast längd. Det sträcker sig inte från listgränssnittet. Strukturen som sträcker sig från listgränssnittet och liknar arrayen är ArrayList.
F # 3) Hur konverterar du en matris till en lista i Java?
Svar: En av de grundläggande metoderna för att konvertera en matris till en lista i Java är att använda metoden asList () i Arrays-klassen.
List aList = Arrays.asList (myarray);Bortsett från detta finns det fler metoder som konverterar en matris till en lista som diskuterats tidigare i denna handledning.
F # 4) Vilken är en snabbare uppsättning eller lista i Java?
Svar: Det beror på vilken data som lagras. Om uppgifterna är unika är listan bättre och snabbare. Om du har en stor datamängd, gå till uppsättningar. Den inställda strukturen kräver vanligtvis tio gånger mer minne än listor.
F # 5) Vad är skillnaden mellan en ArrayList och en uppsättning?
Svar: Listan är en samling beställda element medan uppsättningen är en samling oordnade element. Listan kan ha dubbla element men uppsättningen kan inte ha dubbla element.
Slutsats
I den här guiden har vi sett olika listkonverteringar till arrayen, set och vice versa. Vi har också sett de stora skillnaderna mellan en matris och en lista.
I nästa handledning kommer vi att diskutera listklasser som ArrayList, LinkedList, etc. i detalj.
=> Kolla in den perfekta Java-träningsguiden här.
Rekommenderad läsning
- Java Copy Array: Hur man kopierar / klonar en array i Java
- Java Array - Hur man skriver ut delar av en array i Java?
- Java List - Hur man skapar, initialiserar och använder en lista i Java
- Array Data Typer - int Array, Double array, Array of Strings Etc.
- Java Array - Förklara, skapa och initialisera en array i Java
- Hur man skickar / returnerar en matris i Java
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- Java Array Length Tutorial With Code Exempel
