Menu

Skjult liste til matrix og andre samlinger i Java

covert list array

Prøv Vores Instrument Til At Fjerne Problemer

Denne vejledning forklarer, hvordan du konverterer Java-listen til matrix og andre samlinger. Det inkluderer eksempler til konvertering af liste til matrix, streng, sæt og omvendt:

I vores tidligere tutorials diskuterede vi detaljerne i listesamlingen. Vi har set de forskellige operationer på listen, iteratorer osv. Med en liste kan vi konvertere denne liste til andre samlinger eller datastrukturer som strenge, arrays, ArrayList, sæt osv.

=> Besøg her for den eksklusive Java-træningsundervisningsserie.

Konverter Java List til Array og andre samlinger

Hvad du lærer:

Liste konverteringer

Her, hvad vi rent faktisk gør, er at vi overfører elementerne fra en samling / struktur til en anden, og ved at ændre det ændrer vi faktisk elementernes layout, da hver samling eller datastruktur har sit eget layout.

I denne vejledning diskuterer vi et par konverteringer fra listen til andre datastrukturer og omvendt.

Konverter liste til streng

Du kan nemt konvertere listen over elementer til dens strengrepræsentation. For det meste vil du konvertere en liste med strenge eller tegn til en strengrepræsentation.

Der er forskellige metoder til at konvertere listen til en streng. De mest populære diskuteres nedenfor.

# 1) Brug af toString-metoden

Dette er den enkleste metode til at konvertere listen til streng. I denne metode bruger du simpelthen 'toString'-metoden på en liste, der konverterer listen til en strengrepræsentation.

Programmet nedenfor viser implementeringen af ​​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:

Brug af toString-metoden - Output

I dette program kan du se, at strengen efter konvertering af tegnlisten til en strengrepræsentation forbedres yderligere ved at fjerne de afgrænsende tegn fra den og repræsentere den som et enkelt ord.

# 2) Brug af Collectors Class

Fra og med Java 8 kan du bruge stream-API'er med klassen 'Collectors' til at konvertere listen til en streng.

Eksempel:

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:

Brug af Collectors klasse

I ovenstående program bruger vi stream-API'er, kortlægger værdierne og bruger derefter sammenføjningsmetode () i Collectors-klassen og konverterer listen til streng.

# 3) Brug af StringBuilder Class

Den tredje metode til at konvertere listen til streng er ved hjælp af et StringBuilder-objekt. Her tilføjes hvert element på listen til StringBuilder-objektet ved hjælp af en løkke. Derefter konverteres StringBuilder-objektet til dets strengrepræsentation ved hjælp af toString-metoden.

Tjek følgende program for 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:

Brug af StringBuilder klasse

Ovenstående program viser brugen af ​​StringBuilder-objektet, som elementerne på listen er knyttet til. Derefter konverteres objektet til en streng.

Konvertering af liste til en matrix

Med en liste over elementer skal du konvertere denne liste til en matrix. For at gøre dette kan du bruge en af ​​metoderne beskrevet nedenfor.

# 1) Brug af toArray

Den enkleste måde at konvertere en liste til en matrix er at bruge 'toArray' -metoden på listen.

Følgende program viser denne implementering af 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:

Brug af toArray

I ovenstående program har vi konverteret en liste over strenge til en streng array ved hjælp af 'toArray' metoden.

# 2) Brug af Java 8 Stream

hvilket program åbner en eps-fil

Den næste metode til at konvertere en liste til en matrix er ved hjælp af stream-API'erne i Java 8. I dette konverteres listen først til stream og derefter ved hjælp af stream (). Til Array konverteres den til en array.

Følgende Java-program viser denne 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:

Brug af Java 8 stream

Ovenstående program bruger stream-API'er fra Java 8 og konverterer listen til en matrix. Arrayet udskrives derefter ved hjælp af for hver løkke.

# 3) Brug get-metode

Dette er en anden metode til at konvertere listen til en matrix. I dette bruger vi get () på listen, der kan bruges til at hente individuelle elementer på listen.

Programmet til at konvertere listen til et array ved hjælp af get () -metoden vises nedenfor.

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:

Brug get-metoden

I ovenstående program oprettede vi en matrix af samme størrelse som en liste. Derefter hentes listeelementerne i en løkke ved hjælp af get () -metoden og tildeles arrayet.

Konverter Array til liste

Da du kan konvertere en liste til en matrix, kan du også konvertere en matrix til en liste i Java. Nedenfor er nogle af de metoder, hvor du kan konvertere en matrix til en liste.

# 1) Brug af almindelig Java-kode

Dette er den traditionelle metode til at konvertere en matrix til en liste. Her tilføjer du hvert matrixelement til listen en efter en ved hjælp af en loop. Til denne tilføjelsesmetode på listen bruges.

Det følgende program implementerer den traditionelle metode til at konvertere array til en liste.

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:

Brug af almindelig Java-kode

# 2) Brug af asList () metode

Den næste metode til at konvertere en matrix til en liste er ved hjælp af metoden asList () i Arrays-klassen. Her kan du videregive Array som et argument til asList () -metoden, og den returnerer den opnåede liste.

Det følgende program viser dette.

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:

Brug metoden asList ()

I ovenstående program har vi en række ulige tal. Derefter opretter vi en liste over heltal og tildeler den til output af asList-metoden, som er en liste.

# 3) Brug af Collection.addAll () -metoden

Du kan også bruge addAll () -metoden i samlingsklassen, da arrayet og listen begge er dele af samlingsrammen i Java.

Det følgende program viser brugen af ​​metoden Collections.addAll () til at konvertere array til liste.

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:

Brug af metoden Collection.addAll ()

Her har vi initialiseret en matrix. Vi oprettede en tom liste. Derefter bruges metoden Collections.addAll () ved at videregive lister og matrix som et argument. En vellykket udførelse af denne metode vil have en liste udfyldt med matrixelementerne.

# 4) Brug af Java 8 Streams

Den næste metode til at konvertere array til liste er ved hjælp af Java 8 Stream API og Collectors-klassen. Her konverteres arrayet først til stream, og derefter samles elementerne i en liste ved hjælp af stream. Saml metode. Listen returneres endelig.

Det følgende program viser implementeringen, der konverterer arrayet til listen ved hjælp af 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:

Brug af Java 8 Streams

I ovenstående program oprettes en række farver. Derefter oprettes en tom liste, og derefter tildeles listen, der er opnået fra arrayet ved hjælp af stream API.

Konverter liste til indstilling

Et sæt er en uordnet samling af elementer, der ikke tillader duplikatværdier. Sæt er en del af Java Collections-rammen. Du kan konvertere en liste til at indstille og omvendt, hvis det er nødvendigt.

Lad os i dette afsnit se nogle af de metoder, der bruges til at konvertere en liste til et sæt.

# 1) Brug af den traditionelle metode

Du kan konvertere listen til indstilling ved hjælp af traditionel java-kode. I dette kan du oprette en HashSet eller treeSet. Og derefter tilføje hvert listeelement til sættet i en løkke ved hjælp af tilføjelsesmetoden.

Denne implementering er vist nedenfor.

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:

Brug af den traditionelle metode

I ovenstående program kan du se, at vi har oprettet et HashSet-objekt af typen streng. Derefter føjes hvert element på listen ved hjælp af forbedret til løkke til sættet. Endelig udskrives sættet.

Anbefalet læsning = >> HashSet i Java

# 2) Brug af HashSet eller træsetkonstruktør

Den næste metode er at bruge en sætkonstruktør. Her opretter vi en sætkonstruktør (treeSet eller HashSet). En liste sendes til denne konstruktør som et argument. Ved hjælp af denne liste er sættet konstrueret.

Tjek nedenstående program for denne 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:

Brug af HashSet eller træsætkonstruktør

I ovenstående program opretter vi både HashSet og treeSet ved at sende listen som argument. Endelig vises indholdet af både HashSet og træsæt.

# 3) Brug af AddAll-metoden

Dette er den samme som addAll-metoden for samlinger, vi så før. Her bruges addAll-metoden til at kopiere listeindholdet til sættet.

Det følgende program viser brugen af ​​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:

Brug af addAll-metoden

Dette program opretter et HashSet-objekt. Derefter påkaldes metoden addAll på HashSet-objektet med listen som parameter. Denne metode kopierer listeindholdet til sættet.

# 4) Brug af Java 8 Streams

Som allerede set kan du også bruge Java 8-streams til at konvertere listen til enhver anden samling inklusive sæt. Du skal bruge stream (). Collect-metoden til at gøre dette.

Følgende program viser denne 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:

Brug af Java 8 streams_convert-listen til at indstille

Ovenstående program svarer til det, der vises i tilfælde af konvertering fra listen til en matrix. Først konverteres listen til stream, og derefter indsamler metoden stream-elementerne og konverteres til sæt.

Nu hvor vi har set forskellige metoder, der udfører konverteringen fra listen til sæt, lad os se de metoder, der bruges til at konvertere sæt til listen.

Konverter sæt til liste

Svarende til den måde, hvorpå du konverterer liste til sæt, kan du også konvertere sæt til en liste. Du kan bruge de samme metoder som beskrevet ovenfor til denne konvertering. Den eneste forskel er, at du skifter sted på listen og indstiller i programmet.

Nedenfor er eksempler på konvertering fra sæt til liste for hver metode.

# 1) Brug af almindelig 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:

Brug af almindeligt Java_convert indstillet til liste

Ovenstående program erklærer og initialiserer et sæt. Derefter opretter den en liste og føjer hvert sætelement til listen. Endelig udskriver den listen.

# 2) Brug af 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:

Brug af konstruktører

Her kan du bruge listekonstruktøren med et sæt objekt som argument. Dette kopierer alle de indstillede elementer til listeobjektet.

# 3) Brug af AddAll-metoden

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:

Brug addAll method_convert indstillet til liste

I dette program oprettes et listeobjekt. Derefter tilføjes elementerne i sættet til listen ved hjælp af metoden Collections.addAll ().

# 4) Brug af 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:

Brug af Java 8 Stream_Convert indstillet til liste

Du kan også bruge Java 8-streams og samle-metoden til at konvertere sæt til listen som vist i ovenstående program.

Array Vs List

Lad os diskutere nogle af forskellene mellem en matrix og en liste.

Array Liste
Arrayet er en grundlæggende datastruktur i Java.Listen er et grænseflade, der er en del af samlingsrammen i Java, hvorfra mange af klasser kan udvides som LinkedList, ArrayList osv.
Har fast størrelseListestørrelse er dynamisk.
Du kan få adgang til matrixelementer ved hjælp af ().Listemedlemmer åbnes ved hjælp af metoder.
Arrayet kan have primitive typer såvel som objekter som dets elementer.Lister kan kun indeholde objekter.
Arrays kan bruge operatorer med dets elementer.Lister kan ikke bruge operatorer. I stedet viser det brugsmetoder.
Arrays kan ikke arbejde med generiske stoffer for at sikre typesikkerhed.Lister kan være generiske.

Ofte stillede spørgsmål

Q # 1) Hvordan konverterer du en liste til et array i Java?

Svar: Den grundlæggende metode til at konvertere en liste til en matrix i Java er at bruge 'toArray ()' - metoden i List interface.

Det enkle kald nedenfor konverterer listen til en matrix.

Object() array = list.toArray();

Der er også andre metoder som beskrevet ovenfor for at konvertere listen til en matrix.

Q # 2) Er en matrix en liste i Java?

Svar: Nej. En matrix er en grundlæggende struktur i Java med en fast længde. Det strækker sig ikke fra listegrænsefladen. Den struktur, der strækker sig fra listegrænsefladen og ligner array, er ArrayList.

Q # 3) Hvordan konverterer du en matrix til en liste i Java?

Svar: En af de grundlæggende metoder til at konvertere en matrix til en liste i Java er at bruge metoden asList () i Arrays-klassen.

List aList = Arrays.asList (myarray);

Bortset fra dette er der flere metoder, der konverterer en matrix til en liste som diskuteret tidligere i denne vejledning.

Q # 4) Hvilket er et hurtigere sæt eller en liste i Java?

Svar: Det afhænger af de data, der gemmes. Hvis dataene er unikke, er listen bedre og hurtigere. Hvis du har et stort datasæt, skal du gå efter sæt. Den indstillede struktur kræver normalt 10 gange mere hukommelse end lister.

Spørgsmål nr. 5) Hvad er forskellen mellem en ArrayList og et sæt?

Svar: Listen er en samling af ordnede elementer, mens sættet er en samling af ikke-ordnede elementer. Listen kan have duplikatelementer, men sættet kan ikke have duplikatelementer.

Konklusion

I denne vejledning har vi set forskellige listekonverteringer til arrayet, sæt og omvendt. Vi har også set de store forskelle mellem en matrix og en liste.

I denne næste tutorial vil vi diskutere listeklasser som ArrayList, LinkedList osv. Detaljeret.

=> Tjek den perfekte Java-træningsvejledning her.

Anbefalet læsning

^