java list how create
Denna Java-lista Handledning förklarar hur man skapar, initierar och skriver ut listor i Java. Självstudien förklarar också listan över listor med fullständig kodexempel:
Denna handledning introducerar dig till datastrukturen 'lista' som är en av de grundläggande strukturerna i Java Collection Interface.
En lista i Java är en sekvens av element enligt en ordning. Listgränssnittet för paketet java.util är det som implementerar denna sekvens av objekt som beställts på ett visst sätt som heter List.
=> Kontrollera ALLA Java-handledning här.
Precis som arrayer kan listelementen också nås med hjälp av index med det första indexet som börjar på 0. Indexet indikerar ett visst element vid index 'i', dvs. det är i-element bort från början av listan.
Några av egenskaperna för listan i Java inkluderar:
- Listor kan ha dubbla element.
- Listan kan också innehålla ”null” -element.
- Listor stöder generik, dvs du kan ha generiska listor.
- Du kan också ha blandade objekt (objekt i olika klasser) i samma lista.
- Listor behåller alltid införingsordningen och tillåter positionell åtkomst.
Vad du kommer att lära dig:
- Lista i Java
- Slutsats
Lista i Java
Gränssnittet Java List är en undertyp av Java Collection-gränssnittet. Detta är standardgränssnittet som ärver Java-samlingsgränssnittet.
Nedan följer ett klassdiagram över Java List-gränssnittet.
Som visas i klassdiagrammet ovan sträcker sig Java-listgränssnittet från samlingsgränssnittet för java.util-paketet som i sin tur sträcker sig från det Iterable-gränssnittet för java.util-paketet. Klassen AbstractList tillhandahåller skelettimplementeringen av List-gränssnittet.
Klasserna LinkedList, Stack, Vector, ArrayList och CopyOnWriteArrayList är alla implementeringsklasser i List-gränssnitt som ofta används av programmerare. Det finns alltså fyra typer av listor i Java, dvs Stack, LinkedList, ArrayList och Vector.
Därför, när du måste implementera listgränssnittet, kan du implementera någon av ovanstående listtypsklasser beroende på kraven. För att inkludera funktionerna i listgränssnittet i ditt program måste du importera paketet java.util. * som innehåller listgränssnitt och andra klassdefinitioner enligt följande:
import java.util.*;Skapa & deklarera lista
Vi har redan sagt att List är ett gränssnitt och implementeras av klasser som ArrayList, Stack, Vector och LinkedList. Därför kan du deklarera och skapa förekomster av listan på något av följande sätt:
List linkedlist = new LinkedList(); List arrayList = new ArrayList(); List vec_list = new Vector(); List stck_list = new Stack(); Som visas ovan kan du skapa en lista med någon av ovanstående klasser och sedan initiera dessa listor med värden. Från ovanstående uttalanden kan du ta reda på att ordningen på element kommer att ändras beroende på vilken klass som används för att skapa en förekomst av listan.
Till exempel, för en lista med stackklass är ordern Last In, First Out (LIFO).
Initiera Java-listan
Du kan använda någon av metoderna nedan för att initialisera ett listobjekt.
# 1) Använda asList-metoden
Metoden asList () behandlas redan i detalj i Arrays-ämnet. Du kan skapa en oföränderlig lista med hjälp av arrayvärdena.
Den allmänna syntaxen är:
List listname = Arrays.asList(array_name);Här ska data_typen matcha den för matrisen.
Ovanstående uttalande skapar en oföränderlig lista. Om du vill att listan ska kunna ändras måste du skapa en förekomst av listan med hjälp av ny och sedan tilldela arrayelementen till den med asList-metoden.
Detta är som visas nedan:
List listname = new ArrayList (Arrays.asList(array_name));Låt oss implementera ett program i Java som visar skapandet och initialiseringen av listan med metoden asList .
nedladdning av c ++ standardbibliotek
import java.util.*; public class Main { public static void main(String() args) { //array of strings String() strArray = {'Delhi', 'Mumbai', 'Kolkata', 'Chennai'}; //initialize an immutable list from array using asList method List mylist = Arrays.asList(strArray); //print the list System.out.println('Immutable list:'); for(String val : mylist){ System.out.print(val + ' '); } System.out.println('
'); //initialize a mutable list(arraylist) from array using asList method List arrayList = new ArrayList(Arrays.asList(strArray)); System.out.println('Mutable list:'); //add one more element to list arrayList.add('Pune'); //print the arraylist for(String val : arrayList){ System.out.print(val + ' '); } } Produktion:
I programmet ovan har vi skapat den oföränderliga listan först med metoden asList. Sedan skapar vi en förändrad lista genom att skapa en instans av ArrayList och sedan initiera denna ArrayList med värden från matrisen med asList-metoden.
Observera att eftersom den andra listan kan ändras kan vi också lägga till fler värden i den.
# 2) Använda List.add ()
Som redan nämnts, eftersom listan bara är ett gränssnitt kan den inte instantieras. Men vi kan starta klasser som implementerar detta gränssnitt. För att initialisera listklasserna kan du därför använda deras respektive tilläggsmetoder som är en listgränssnittsmetod men implementerad av var och en av klasserna.
Om du starta en länkad listklass enligt nedan:
List llist = new LinkedList ();För att lägga till ett element i en lista kan du sedan använda tilläggsmetoden enligt följande:
llist.add(3);Det finns också en teknik som kallas 'Dubbel staginitiering' där listan initieras och initieras genom att anropa add-metoden i samma uttalande.
Detta görs enligt nedan:
List llist = new LinkedList (){{ add(1); add(3);}};Ovanstående uttalande lägger till element 1 och 3 i listan.
Följande program visar initialiseringar av listan med hjälp av add-metoden . Den använder också initialiseringstekniken för dubbel stag.
import java.util.*; public class Main { public static void main(String args()) { // ArrayList.add method List str_list = new ArrayList(); str_list.add('Java'); str_list.add('C++'); System.out.println('ArrayList : ' + str_list.toString()); // LinkedList.add method List even_list = new LinkedList(); even_list.add(2); even_list.add(4); System.out.println('LinkedList : ' + even_list.toString()); // double brace initialization - use add with declaration & initialization List num_stack = new Stack(){{ add(10);add(20); }}; System.out.println('Stack : ' + num_stack.toString()); } }Produktion:
Detta program har tre olika listadeklarationer, dvs ArrayList, LinkedList och Stack.
ArrayList- och LinkedList-objekt instansieras och sedan läggs metoderna till för att lägga till element i dessa objekt. För stack används dubbelstaginitiering där tilläggsmetoden kallas under själva instantieringen.
# 3) Använda klassmetoder för samlingar
Samlingsklassen på Java har olika metoder som kan användas för att initialisera listan.
Några av metoderna är:
- Lägg till alla
De allmän syntax för samlingar addAll-metoden är:
List listname = Collections.EMPTY_LIST; Collections.addAll(listname = new ArrayList(), values…); Här lägger du till värden i en tom lista. Metoden addAll tar listan som den första parametern följt av de värden som ska infogas i listan.
- unmodifiableList ()
Metoden 'unmodifiableList ()' returnerar en oföränderlig lista där elementen inte kan läggas till eller raderas.
Den allmänna syntaxen för denna metod är som följer:
List listname = Collections.unmodifiableList(Arrays.asList(values…));Metoden tar listvärden som parametrar och returnerar en lista. Om du alls försöker lägga till eller ta bort något element från den här listan, har kompilatorn ett undantag Ej stöddOperationException.
- singletonList ()
Metoden 'singletonList' returnerar en lista med ett enda element i den. Listan är oföränderlig.
Den allmänna syntaxen för denna metod är:
List listname = Collections.singletonList(value);Följande Java-program visar alla de tre metoderna i klassen Collections som diskuterats ovan.
import java.util.*; public class Main { public static void main(String args()) { // empty list List list = new ArrayList(); // Instantiating list using Collections.addAll() Collections.addAll(list, 10, 20, 30, 40); // Print the list System.out.println('List with addAll() : ' + list.toString()); // Create& initialize the list using unmodifiableList method List intlist = Collections.unmodifiableList( Arrays.asList(1,3,5,7)); // Print the list System.out.println('List with unmodifiableList(): ' + intlist.toString()); // Create& initialize the list using singletonList method List strlist = Collections.singletonList('Java'); // Print the list System.out.println('List with singletonList(): ' + strlist.toString()); } }Produktion:
# 4) Använda Java8-strömmar
Med introduktionen av strömmar i Java 8 kan du också skapa en dataström och samla dem i en lista.
Det följande programmet visar skapandet av en lista med ström.
import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; public class Main { public static void main(String args()) { // Creating a List using toList Collectors method List list1 = Stream.of('January', 'February', 'March', 'April', 'May') .collect(Collectors.toList()); // Print the list System.out.println('List from Java 8 stream: ' + list1.toString()); } }Produktion:
Ovanstående program samlar strängströmmen i en lista och returnerar den. Du kan också använda de andra Collectors-metoderna som 'toCollection', 'unmodifiableList' etc. förutom asList i samlingsfunktionen.
# 5) Java 9 List.of () -metod
En ny metod introduceras i Java 9, List.of () som tar valfritt antal element och konstruerar en lista. Listan som konstrueras är oföränderlig.
import java.util.List; public class Main { public static void main(String args()) { // Create a list using List.of() List strList = List.of('Delhi', 'Mumbai', 'Kolkata'); // Print the List System.out.println('List using Java 9 List.of() : ' + strList.toString()); } }Produktion:
Listexempel
Nedan följer ett komplett exempel på att använda ett listgränssnitt och dess olika metoder.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List intList = new ArrayList(); //add two values to the list intList.add(0, 10); intList.add(1, 20); System.out.println('The initial List:
' + intList); // Creating another list List cp_list = new ArrayList(); cp_list.add(30); cp_list.add(40); cp_list.add(50); // add list cp_list to intList from index 2 intList.addAll(2, cp_list); System.out.println('List after adding another list at index 2:
'+ intList); // Removes element from index 0 intList.remove(0); System.out.println('List after removing element at index 0:
' + intList); // Replace value of last element intList.set(3, 60); System.out.println('List after replacing the value of last element:
' + intList); } } Produktion:
Ovanstående programutdata visar de olika operationerna som utförs på en ArrayList. Först skapar och initialiserar den listan. Sedan kopieras innehållet i en annan lista till den här listan och tar också bort ett element från listan. Slutligen ersätter det det sista elementet i listan med ett annat värde.
Vi kommer att utforska listmetoderna i detalj i vår nästa handledning.
Utskriftslista
Det finns olika metoder där du kan skriva ut elementen i listan i Java.
Låt oss diskutera några av metoderna här.
# 1) Använda For Loop / Enhanced For Loop
Listan är en beställd samling som kan nås med hjälp av index. Du kan använda för loop som används för att iterera med hjälp av indexen för att skriva ut varje element i listan.
Java har en annan version av for loop känd som förbättrad för loop som också kan användas för att komma åt och skriva ut varje element i listan.
Java-programmet som visas nedan visar utskrift av listinnehåll med hjälp av för loop och förbättrad för loop.
import java.util.List; import java.util.ArrayList; import java.util.Arrays; class Main{ public static void main (String() args) { //string list List list = Arrays.asList('Java', 'Python', 'C++', 'C', 'Ruby'); //print list using for loop System.out.println('List contents using for loop:'); for (int i = 0; i Produktion:
# 2) Använda metoden toString
Metoden 'toString ()' i listgränssnittet returnerar strängrepresentationen för listan.
Programmet nedan visar användningen av metoden toString ().
import java.util.List; import java.util.ArrayList; class Main{ public static void main (String() args){ //initialize a string list List list = new ArrayList(){{add('Python');add('C++');add('Java');}}; // string representation of list using toString method System.out.println('List contents using toString() method:' + list.toString()); } } Produktion:
Lista omvandlas till en matris
Listan har en metod toArray () som konverterar listan till en matris. När du väl har konverterats till en array kan du använda arraymetoderna som diskuteras i respektive ämne för att skriva ut innehållet i denna array. Du kan antingen använda för eller förbättrad för loop eller till och med toString-metoden.
Exemplet nedan använder toString-metoden för att skriva ut matrisinnehållet.
import java.util.*; class Main { public static void main (String() args) { //list of odd numbers List oddlist = Arrays.asList(1,3,5,7,9,11); // using List.toArray() method System.out.println('Contents of list converted to Array:'); System.out.println(Arrays.toString(oddlist.toArray())); } } Produktion:
Använda Java 8 Streams
Strömmar introduceras i Java 8. Du kan använda strömmar för att gå igenom listan. Det finns också lambdas som du kan använda genom listan.
Programmet nedan visar användningen av strömmar för att iterera genom listan och visa dess innehåll.
odefinierad hänvisning till klass c ++
import java.util.*; class Main{ public static void main (String() args){ //list of even numbers List evenlist = Arrays.asList(2,4,6,8,10,12,14); // print list using streams System.out.println('Contents of evenlist using streams:'); evenlist.stream().forEach(S ->System.out.print(S + ' ')); } } Produktion:
Förutom metoderna som diskuterats ovan kan du använda lista iteratorer för att itera igenom listan och visa dess innehåll. Vi kommer att ha en fullständig artikel om listens iterator i de efterföljande handledningarna.
Lista över listor
Gränssnittet i Java-listan stöder ”listan över listor”. I detta är de enskilda elementen i listan återigen en lista. Det betyder att du kan ha en lista i en annan lista.
Detta koncept är mycket användbart när du måste läsa data från exempelvis CSV-filer. Här kan du behöva läsa flera listor eller listor i listor och sedan lagra dem i minnet. Återigen måste du bearbeta dessa data och skriva tillbaka till filen. I sådana situationer kan du alltså hålla en lista med listor för att förenkla databehandlingen.
Följande Java-program visar ett exempel på en Java-lista med listor.
I det här programmet har vi en lista med listor av typen String. Vi skapar två separata listor med typsträngar och tilldelar värden till dessa listor. Båda dessa listor läggs till i listan med hjälp av add-metoden.
För att visa innehållet i listan med listor använder vi två slingor. Den yttre slingan (foreach) går igenom listorna med listor som har åtkomst till listorna. Den inre foreach-slingan öppnar de enskilda strängelementen i var och en av dessa listor.
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String() args) { //create list of lists List java_listOfLists = new ArrayList (); //create a language list and add elements to it ArrayList lang_list = new ArrayList(); lang_list.add('Java'); lang_list.add('C++'); //add language list to java list of list java_listOfLists.add(lang_list); //create a city list and add elements to it ArrayList city_list = new ArrayList(); city_list.add('Pune'); city_list.add('Mumbai'); //add the city list to java list of lists java_listOfLists.add(city_list); //display the contents of list of lists System.out.println('Java list of lists contents:'); java_listOfLists.forEach((list) -> //access each list { list.forEach((city)->System.out.print(city + ' ')); //each element of inner list }); } } Produktion:
Java-listan med listor är ett litet koncept men är viktigt särskilt när du måste läsa komplexa data i ditt program.
Vanliga frågor
F # 1) Vad är en lista och ställs in i Java?
Svar: En lista är en ordnad samling av element. Du kan ha dubbla element i listan.
En uppsättning är inte en beställd samling. Element i uppsättningen är inte ordnade i någon särskild ordning. Elementen i uppsättningen måste också vara unika. Det tillåter inte dubbletter.
F # 2) Hur fungerar en lista i Java?
Svar: Listan är ett gränssnitt i Java som sträcker sig från samlingsgränssnittet. Klasserna ArrayList, LinkedList, Stack och Vector implementerar listgränssnittet. Således kan en programmerare använda dessa klasser för att använda funktionaliteten i listgränssnittet.
F # 3) Vad är en ArrayList i Java?
Svar: ArrayList är en dynamisk matris. Det är en resizable samling av element och implementerar listgränssnittet. ArrayList använder internt en array för att lagra elementen.
F # 4) Börjar listor vid 0 eller 1 i Java?
Svar: Listor i Java har ett nollbaserat heltalindex. Det betyder att det första elementet i listan är vid index 0, det andra elementet i index 1 och så vidare.
F # 5) Beställs listan?
Svar: Ja. Listan är en ordnad samling av element. Denna ordning bevaras under införandet av ett nytt element i listan,
Slutsats
Denna handledning gav en introduktion till listgränssnittet i Java. Vi diskuterade också de viktigaste begreppen listor som skapande, initialisering av listor, utskrift av listor etc.
I våra kommande handledning kommer vi att diskutera de olika metoderna som tillhandahålls av listgränssnittet. Vi kommer också att diskutera iteratorkonstruktionen som används för att iterera listobjektet. Vi kommer att diskutera konverteringen av listobjekt till andra datastrukturer i vår kommande handledning.
=> Besök här för att se Java Training Series för alla.
Rekommenderad läsning
- Java Array - Förklara, skapa och initialisera en array i Java
- Objektuppsättning i Java: Hur man skapar, initierar och använder
- Java Hello World - Skapa ditt första program i Java idag
- Java-distribution: Skapande och utförande av Java JAR-fil
- Java Virtual Machine: Hur JVM hjälper till att köra Java-applikationen
- Åtkomstmodifierare i Java - Handledning med exempel
- Java Reflection Tutorial med exempel
- Introduktion till Java-programmeringsspråk - Videohandledning
