Javan List-käyttöliittymä tarjoaa tavan tallentaa tilattu kokoelma. Se on lapsen käyttöliittymä Kokoelma . Se on järjestetty kokoelma objekteja, joihin voidaan tallentaa päällekkäisiä arvoja. Koska List säilyttää lisäysjärjestyksen, se mahdollistaa paikantamisen ja elementtien lisäämisen.
Sisällysluettelo
- Listaa käyttöliittymä Javassa
- Java-luetteloliittymän ilmoitus
- Esimerkki Java-listasta
- Toiminnot Java List -liittymässä
- Luetteloliittymän monimutkaisuus Javassa
- Iterointi List Interfacen kautta Javassa
- Listan käyttöliittymän menetelmät
- Java-lista vs
Listaa käyttöliittymä Javassa
List-käyttöliittymä löytyy java.util-paketista, ja se perii Collection-rajapinnan. Se on ListIterator-liittymän tehdas. ListIteratorin avulla voimme iteroida luetteloa eteenpäin ja taaksepäin. List-rajapinnan toteutusluokat ovat ArrayList, LinkedList, Stack ja Vector. ArrayList ja LinkedList ovat laajalti käytössä Java-ohjelmoinnissa. Vector-luokka on vanhentunut Java 5:n jälkeen.
List ja ArrayList Java Collection Frameworkissa
Java-luetteloliittymän ilmoitus
public interface List extends Collection ;>
Tarkastellaanpa objektien tai ilmentymien luomista List-luokassa. Siitä asti kun Lista on käyttöliittymä , objekteja ei voida luoda tyyppiluettelosta. Tarvitsemme aina luokan, joka toteuttaa tämän Lista objektin luomiseksi. Ja myös käyttöönoton jälkeen Generics Java 1.5:ssä on mahdollista rajoittaa listaan tallennettavien objektien tyyppiä. Aivan kuten monet muutkin käyttäjän määrittelemät 'rajapinnat', jotka on toteutettu käyttäjän määrittelemillä 'luokilla', Lista on 'käyttöliittymä', jonka toteuttaa ArrayList luokka, ennalta määritetty java.util paketti.
Java-listan syntaksi
Tämän tyyppinen turvalista voidaan määritellä seuraavasti:
List list = new ArrayList ();>
Huomautus: Obj on listaan tallennettavan objektin tyyppi
Esimerkki Java-listasta
Java
// Java program to Demonstrate List Interface> > // Importing all utility classes> import> java.util.*;> > // Main class> // ListDemo class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an object of List interface> >// implemented by the ArrayList class> >List l1 =>new> ArrayList();> > >// Adding elements to object of List interface> >// Custom inputs> > >l1.add(>0>,>1>);> >l1.add(>1>,>2>);> > >// Print the elements inside the object> >System.out.println(l1);> > >// Now creating another object of the List> >// interface implemented ArrayList class> >// Declaring object of integer type> >List l2 =>new> ArrayList();> > >// Again adding elements to object of List interface> >// Custom inputs> >l2.add(>1>);> >l2.add(>2>);> >l2.add(>3>);> > >// Will add list l2 from 1 index> >l1.addAll(>1>, l2);> > >System.out.println(l1);> > >// Removes element from index 1> >l1.remove(>1>);> > >// Printing the updated List 1> >System.out.println(l1);> > >// Prints element at index 3 in list 1> >// using get() method> >System.out.println(l1.get(>3>));> > >// Replace 0th element with 5> >// in List 1> >l1.set(>0>,>5>);> > >// Again printing the updated List 1> >System.out.println(l1);> >}> }> |
>
>Lähtö
[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>
Suoritetaan nyt erilaisia toimintoja List Interface -sovelluksella ymmärtääksemme ne paremmin. Keskustelemme seuraavista alla luetelluista toiminnoista ja myöhemmin niiden toteuttamisesta puhtaiden Java-koodien avulla.
Toiminnot Java List -liittymässä
Koska List on rajapinta, sitä voidaan käyttää vain luokan kanssa, joka toteuttaa tämän rajapinnan. Katsotaanpa nyt, kuinka suorittaa muutamia usein käytettyjä toimintoja luettelossa.
- Operaatio 1: Elementtien lisääminen List-luokkaan add()-metodilla
- Operaatio 2: List-luokan elementtien päivittäminen set()-metodilla
- Operaatio 3: Elementtien etsiminen indexOf(), lastIndexOf-menetelmillä
- Operaatio 4: Elementtien poistaminen Remove()-menetelmällä
- Operaatio 5: List-luokan elementtien käyttö get()-menetelmällä
- Operaatio 6: Tarkastaa, onko elementti läsnä List-luokassa käyttäen include()-metodia
Keskustellaan nyt toiminnoista erikseen ja toteutetaan sama koodiin saadaksemme paremman otteen siitä.
1. Elementtien lisääminen List-luokkaan käyttämällä add()-menetelmä
Elementin lisäämiseksi luetteloon voimme käyttää lisätä() menetelmä. Tämä menetelmä on ylikuormitettu suorittamaan useita toimintoja eri parametrien perusteella.
Parametrit: Se vaatii 2 parametria, nimittäin:
- lisää (objekti): Tätä menetelmää käytetään elementin lisäämiseen luettelon loppuun.
- add(int index, Object): Tätä menetelmää käytetään elementin lisäämiseen luettelon tiettyyn hakemistoon
Esimerkki:
Java
objektiivinen java
// Java Program to Add Elements to a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >// Custom elements> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> >al.add(>1>,>'For'>);> > >// Print all the elements inside the> >// List interface object> >System.out.println(al);> >}> }> |
>
>Lähtö
[Geeks, For, Geeks]>
2. Päivitetään elementtejä
Elementtien lisäämisen jälkeen, jos haluamme muuttaa elementtiä, se voidaan tehdä käyttämällä aseta() menetelmä. Koska List on indeksoitu, elementin indeksillä viitataan elementtiin, jota haluamme muuttaa. Siksi tämä menetelmä ottaa indeksin ja päivitetyn elementin, joka on lisättävä kyseiseen indeksiin.
Esimerkki:
Java
// Java Program to Update Elements in a List> > // Importing utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface> >List al =>new> ArrayList();> > >// Adding elements to object of List class> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> >al.add(>1>,>'Geeks'>);> > >// Display theinitial elements in List> >System.out.println(>'Initial ArrayList '> + al);> > >// Setting (updating) element at 1st index> >// using set() method> >al.set(>1>,>'For'>);> > >// Print and display the updated List> >System.out.println(>'Updated ArrayList '> + al);> >}> }> |
>
>Lähtö
Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>
3. Elementtien etsiminen
Elementtien etsiminen List-rajapinnasta on yleinen toimenpide Java-ohjelmoinnissa. List-käyttöliittymä tarjoaa useita tapoja etsiä elementtejä, kuten sisällysluettelo() , lastIndexOf() menetelmiä.
IndexOf()-menetelmä palauttaa luettelossa määritetyn elementin ensimmäisen esiintymisen indeksin, kun taas lastIndexOf()-menetelmä palauttaa määritetyn elementin viimeisen esiintymisen indeksin.
Parametrit:
- indexOf(elementti): Palauttaa luettelossa määritetyn elementin ensimmäisen esiintymisen indeksin tai -1, jos elementtiä ei löydy
- lastIndexOf(elementti): Palauttaa luettelossa määritetyn elementin viimeisen esiintymisen indeksin tai -1, jos elementtiä ei löydy
Esimerkki:
Java
import> java.util.ArrayList;> import> java.util.List;> > public> class> ListExample {> >public> static> void> main(String[] args)> >{> >// create a list of integers> >List numbers =>new> ArrayList();> > >// add some integers to the list> >numbers.add(>1>);> >numbers.add(>2>);> >numbers.add(>3>);> >numbers.add(>2>);> > >// use indexOf() to find the first occurrence of an> >// element in the list> >int> index = numbers.indexOf(>2>);> >System.out.println(> >'The first occurrence of 2 is at index '> >+ index);> > >// use lastIndexOf() to find the last occurrence of> >// an element in the list> >int> lastIndex = numbers.lastIndexOf(>2>);> >System.out.println(> >'The last occurrence of 2 is at index '> >+ lastIndex);> >}> }> |
>
>Lähtö
The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>
4. Elementtien poistaminen
Elementin poistamiseksi luettelosta voimme käyttää Poista() menetelmä. Tämä menetelmä on ylikuormitettu suorittamaan useita toimintoja eri parametrien perusteella. He ovat:
Parametrit:
- poista (objekti): Tätä menetelmää käytetään yksinkertaisesti objektin poistamiseen luettelosta. Jos tällaisia objekteja on useita, objektin ensimmäinen esiintyminen poistetaan.
- poista (int index): Koska luettelo on indeksoitu, tämä menetelmä ottaa kokonaislukuarvon, joka yksinkertaisesti poistaa kyseisessä luettelossa olevan elementin. Elementin poistamisen jälkeen kaikki elementit siirretään vasemmalle täyttämään tila ja objektien indeksit päivitetään.
Esimerkki:
Java
maailman parhaita autoja
// Java Program to Remove Elements from a List> > // Importing List and ArrayList classes> // from java.util package> import> java.util.ArrayList;> import> java.util.List;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> > >// Creating List class object> >List al =>new> ArrayList();> > >// Adding elements to the object> >// Custom inputs> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> > >// Adding For at 1st indexes> >al.add(>1>,>'For'>);> > >// Print the initialArrayList> >System.out.println(>'Initial ArrayList '> + al);> > >// Now remove element from the above list> >// present at 1st index> >al.remove(>1>);> > >// Print the List after removal of element> >System.out.println(>'After the Index Removal '> + al);> > >// Now remove the current object from the updated> >// List> >al.remove(>'Geeks'>);> > >// Finally print the updated List now> >System.out.println(>'After the Object Removal '> >+ al);> >}> }> |
>
>Lähtö
Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
5. Elementtien käyttö
Voidaksemme käyttää luettelon elementtiä, voimme käyttää saada() menetelmä, joka palauttaa elementin määritetyssä indeksissä
Parametrit:
get(int index): Tämä menetelmä palauttaa elementin luettelossa määritetyssä indeksissä.
Esimerkki:
Java
// Java Program to Access Elements of a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >al.add(>'Geeks'>);> >al.add(>'For'>);> >al.add(>'Geeks'>);> > >// Accessing elements using get() method> >String first = al.get(>0>);> >String second = al.get(>1>);> >String third = al.get(>2>);> > >// Printing all the elements inside the> >// List interface object> >System.out.println(first);> >System.out.println(second);> >System.out.println(third);> >System.out.println(al);> >}> }> |
>
>Lähtö
Geeks For Geeks [Geeks, For, Geeks]>
6. Tarkistaa, onko luettelossa elementti
Tarkistaaksemme, onko jokin elementti luettelossa, voimme käyttää sisältää() menetelmä. Tämä menetelmä palauttaa tosi, jos määritetty elementti on luettelossa, muussa tapauksessa se palauttaa epätosi.
Parametrit:
sisältää(Object): Tämä menetelmä ottaa yhden parametrin, objektin, joka tarkistetaan, jos se on luettelossa.
Esimerkki:
Java
// Java Program to Check if an Element is Present in a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >al.add(>'Geeks'>);> >al.add(>'For'>);> >al.add(>'Geeks'>);> > >// Checking if element is present using contains()> >// method> >boolean> isPresent = al.contains(>'Geeks'>);> > >// Printing the result> >System.out.println(>'Is Geeks present in the list? '> >+ isPresent);> >}> }> |
>
>Lähtö
Is Geeks present in the list? true>
Luetteloliittymän monimutkaisuus Javassa
| Operaatio | Aika monimutkaisuus | Avaruuden monimutkaisuus |
|---|---|---|
| Elementin lisääminen luetteloliittymään | O(1) kellua nauhaan | O(1) |
| Poista elementti luetteloliittymästä | PÄÄLLÄ) | PÄÄLLÄ) |
| Korvaa elementti luetteloliittymässä | PÄÄLLÄ) | PÄÄLLÄ) |
| Listan läpikäyminen | PÄÄLLÄ) python-ohjelmointiesimerkkejä | PÄÄLLÄ) |
Iterointi List Interfacen kautta Javassa
Toistaiseksi meillä on erittäin pieni syöttökoko ja teemme toiminnot manuaalisesti jokaiselle kokonaisuudelle. Keskustelkaamme nyt eri tavoista, joilla voimme toistaa luetteloa saadaksemme ne toimimaan suuremmassa näytejoukossa.
Menetelmät: Listaa voi toistaa useilla tavoilla. Tunnetuin tapa on käyttää perus silmukalle yhdessä a:n kanssa get() -menetelmä saadaksesi elementin tietyssä indeksissä ja edistynyt silmukaksi .
Esimerkki:
Java
// Java program to Iterate the Elements> // in an ArrayList> > // Importing java utility classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// main driver method> >public> static> void> main(String args[])> >{> >// Creating an empty Arraylist of string type> >List al =>new> ArrayList();> > >// Adding elements to above object of ArrayList> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> > >// Adding element at specified position> >// inside list object> >al.add(>1>,>'For'>);> > >// Using for loop for iteration> >for> (>int> i =>0>; i // Using get() method to // access particular element System.out.print(al.get(i) + ' '); } // New line for better readability System.out.println(); // Using for-each loop for iteration for (String str : al) // Printing all the elements // which was inside object System.out.print(str + ' '); } }> |
>
>Lähtö
Geeks For Geeks Geeks For Geeks>
Listan käyttöliittymän menetelmät
Koska erityyppisten luetteloiden pääkonsepti on sama, luetteloliittymä sisältää seuraavat menetelmät:
| Menetelmä | Kuvaus |
|---|---|
| add(int indeksi, elementti) | Tätä menetelmää käytetään Java List Interfacen kanssa elementin lisäämiseen luettelon tiettyyn hakemistoon. Kun yksittäinen parametri välitetään, se yksinkertaisesti lisää elementin luettelon loppuun. |
| addAll(int index, kokoelmakokoelma) | Tätä menetelmää käytetään List Interfacen kanssa Javassa lisäämään kaikki tietyn kokoelman elementit luetteloon. Kun yksi parametri välitetään, se lisää kaikki tietyn kokoelman elementit luettelon loppuun. |
| koko() | Tätä menetelmää käytetään Java List Interfacen kanssa palauttamaan luettelon koko. |
| asia selvä() | Tätä menetelmää käytetään kaikkien luettelon elementtien poistamiseen. Luodun luettelon viite on kuitenkin edelleen tallennettu. |
| poista (int index) | Tämä menetelmä poistaa elementin määritetystä hakemistosta. Se siirtää myöhempiä elementtejä (jos sellaisia on) vasemmalle ja pienentää niiden indeksejä yhdellä. |
| poista (elementti) | Tätä menetelmää käytetään Java List Interfacen kanssa poistamaan ensimmäisen elementin esiintyminen luettelosta. |
| get(int index) | Tämä menetelmä palauttaa elementit määritetyllä indeksillä. |
| joukko (int indeksi, elementti) | Tämä menetelmä korvaa tietyn indeksin elementit uudella elementillä. Tämä funktio palauttaa elementin, joka juuri korvattiin uudella elementillä. |
| indexOf(elementti) | Tämä menetelmä palauttaa annetun elementin tai ensimmäisen esiintymän -1 jos elementtiä ei ole luettelossa. |
| lastIndexOf(elementti) | Tämä menetelmä palauttaa annetun elementin tai viimeisen esiintymän -1 jos elementtiä ei ole luettelossa. |
| yhtä kuin (elementti) | Tätä menetelmää käytetään Java List Interfacen kanssa vertaamaan annetun elementin yhtäläisyyttä listan elementteihin. |
| hash koodin() | Tätä menetelmää käytetään List Interfacen kanssa Javassa palauttamaan annetun luettelon hashcode-arvo. |
| on tyhjä() | Tätä menetelmää käytetään Java List Interfacen kanssa tarkistamaan, onko luettelo tyhjä vai ei. Se palauttaa tosi, jos lista on tyhjä, muuten false. |
| sisältää (elementin) | Tätä menetelmää käytetään List Interfacen kanssa Javassa tarkistamaan, sisältääkö luettelo tietyn elementin vai ei. Se palauttaa tosi, jos luettelo sisältää elementin. |
| sisältääKaikki (kokoelmakokoelma) | Tätä menetelmää käytetään Java List Interface -liittymän kanssa tarkistamaan, sisältääkö luettelo kaikki elementtikokoelman. |
| lajittele (vertailu comp) | Tätä menetelmää käytetään List Interfacen kanssa Javassa lajittelemaan listan elementit annetun perusteella vertailija . |
Java-lista vs
Sekä List-käyttöliittymä että Set-käyttöliittymä perivät Collection-rajapinnan. Niiden välillä on kuitenkin joitain eroja.
| Lista | Aseta |
|---|---|
| Lista on järjestetty sekvenssi. | Sarja on järjestämätön sarja. |
| Luettelo sallii elementtien kopioinnin | Joukko ei salli päällekkäisiä elementtejä. |
| Elementit niiden sijainnin mukaan ovat käytettävissä. | Elementtien sijainti ei ole sallittua. |
| Useita nollaelementtejä voidaan tallentaa. | Nolla-elementti voi tallentaa vain kerran. |
| Listatoteutukset ovat ArrayList, LinkedList, Vector, Stack | Joukkototeutukset ovat HashSet, LinkedHashSet. |
Luokkien yhdistäminen Java-luetteloliittymän kanssa
Keskustelkaamme nyt luokista, jotka toteuttavat List Interface -liittymän, joiden osalta viitataan ensin alla olevaan kuvalliseen esitykseen saadaksemme paremman käsityksen List-rajapinnasta. Se on seuraava:
Abstract List , CopyOnWriteArrayList , ja AbstractSequentialList ovat luokat, jotka toteuttavat List-rajapinnan. Jokaisessa mainitussa luokassa on toteutettu erillinen toiminnallisuus. Ne ovat seuraavat:
- AbstractList: Tätä luokkaa käytetään muokkaamattoman listan toteuttamiseen, jolle tarvitsee vain laajentaa tätä AbstractList-luokkaa ja toteuttaa vain saada() ja koko() menetelmiä.
- CopyOnWriteArrayList: Tämä luokka toteuttaa luettelorajapinnan. Se on paranneltu versio ArrayList jossa kaikki muutokset (lisää, aseta, poista jne.) toteutetaan tekemällä luettelosta uusi kopio.
- AbstractSequentialList: Tämä luokka toteuttaa Kokoelman käyttöliittymä ja AbstractCollection-luokka. Tätä luokkaa käytetään muokkaamattoman listan toteuttamiseen, jolle tarvitsee vain laajentaa tätä AbstractList-luokkaa ja toteuttaa vain saada() ja koko() menetelmiä.
Jatkamme tällä tavalla.
- ArrayList
- Vektori
- Pino
- LinkedList
Keskustellaan niistä peräkkäin ja toteutetaan sama selvittääksemme luokkien toiminnan List-rajapinnalla.
1. ArrayList
ArrayList luokka, joka on toteutettu kokoelmakehyksessä, tarjoaa meille dynaamisia taulukoita Javassa. Se voi kuitenkin olla hitaampi kuin tavalliset taulukot, mutta siitä voi olla apua ohjelmissa, joissa taulukkoa tarvitaan paljon. Katsotaan kuinka luodaan luetteloobjekti tämän luokan avulla.
Esimerkki:
Java
// Java program to demonstrate the> // creation of list object using the> // ArrayList class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of ArrayList> >int> n =>5>;> > >// Declaring the List with initial size n> >List arrli =>new> ArrayList(n);> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >arrli.add(i);> > >// Printing elements> >System.out.println(arrli);> > >// Remove element at index 3> >arrli.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(arrli);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(arrli.get(i) + ' '); } }> |
>
>Lähtö
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
2. Vektori
Vector on luokka, joka on toteutettu kokoelmakehyksessä, joka toteuttaa kasvavan objektijoukon. Vector toteuttaa dynaamisen taulukon, mikä tarkoittaa, että se voi kasvaa tai kutistua tarpeen mukaan. Kuten taulukko, se sisältää komponentteja, joita voidaan käyttää kokonaislukuindeksillä. Vektorit kuuluvat periaatteessa vanhoihin luokkiin, mutta nyt se on täysin yhteensopiva kokoelmien kanssa. Katsotaan kuinka luodaan luetteloobjekti tämän luokan avulla.
Esimerkki:
Java
scan.nextstring java
// Java program to demonstrate the> // creation of list object using the> // Vector class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the vector> >int> n =>5>;> > >// Declaring the List with initial size n> >List v =>new> Vector(n);> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >v.add(i);> > >// Printing elements> >System.out.println(v);> > >// Remove element at index 3> >v.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(v);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(v.get(i) + ' '); } }> |
>
>Lähtö
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
3. Pinoa
Pino on luokka, joka on toteutettu kokoelmakehyksessä ja laajentaa vektoriluokkamalleja ja toteuttaa Esimerkki:
Java
Esimerkki:Java
// Java program to demonstrate the> // creation of list object using the> // Stack class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the stack> >int> n =>5>;> > >// Declaring the List> >List s =>new> Stack();> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >s.add(i);> > >// Printing elements> >System.out.println(s);> > >// Remove element at index 3> >s.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(s);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(s.get(i) + ' '); } }> |
>
>Lähtö
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
4. LinkedList
Esimerkki:
Java
LinkedList on luokka, joka on toteutettu kokoelmakehyksessä, joka toteuttaa luonnostaan Esimerkki:Java
Esimerkki:Java
// Java program to demonstrate the> // creation of list object using the> // LinkedList class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the LinkedList> >int> n =>5>;> > >// Declaring the List with initial size n> >List ll =>new> LinkedList();> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >ll.add(i);> > >// Printing elements> >System.out.println(ll);> > >// Remove element at index 3> >ll.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(ll);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(ll.get(i) + ' '); } }> |
>
>Lähtö
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>