Javassa muuttumaton luettelo on luettelo, jota ei voi muokata sen luomisen jälkeen. Yritys lisätä, poistaa tai muokata luettelon elementtejä sen luomisen jälkeen aiheuttaa poikkeuksen.

Muuttumattomien luetteloiden käytön ensisijainen etu on, että ne tarjoavat säikeen turvallisuuden ja tekevät koodista vankemman. Koska luetteloa ei voi muokata sen luomisen jälkeen, ei ole vaaraa, että useat säikeet yrittäisivät muokata sitä samanaikaisesti ja aiheuttavat ongelmia. Lisäksi muuttumattomat luettelot voidaan helposti jakaa eri ohjelman osien kesken ilman pelkoa, että niitä muutetaan tahattomasti.

Kaiken kaikkiaan muuttumattomien luetteloiden käyttö Javassa voi parantaa ohjelman turvallisuutta ja kestävyyttä erityisesti monisäikeisissä ympäristöissä, joissa jaetut tietorakenteet voivat aiheuttaa ongelmia.

Luokkailmoitus

Javassa, ImmutableList luokka on osa Guava kirjasto, joka tarjoaa useita muuttumattomia kokoelmaluokkia. Käyttää ImmutableList , tuomme ensin com.google.common.collect paketti, joka sisältää ImmutableList luokkaa.

Luokkailmoitus ImmutableList on seuraava:

 public abstract class ImmutableList extends ImmutableCollection implements List 

ImmutableList laajentaa ImmutableCollection luokkaa ja toteuttaa Lista käyttöliittymä. Se on yleinen luokka, mikä tarkoittaa, että voimme luoda ImmutableList mistä tahansa tietotyypistä. The JA ilmoituksessa edustaa tyyppiparametria, jonka voimme korvata millä tahansa luokan tai käyttöliittymän nimellä.

java korvaa kaikki merkkijono

Luokkahierarkia

The ImmutableList luokka toteuttaa Lista käyttöliittymä ja edustaa luetteloa, jota ei voi muokata luomisen jälkeen.

Luokkahierarkia ImmutableList on seuraava:

 java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList 

Tässä, ImmutableCollection on abstrakti luokka, joka tarjoaa rakenteellisen toteutuksen ImmutableCollection käyttöliittymä, joka ImmutableList ulottuu.

Kaiken kaikkiaan ImmutableList luokka tarjoaa kätevän ja tehokkaan tavan luoda ja käyttää muuttumattomia listoja Javassa.

tehdä javassa

ImmutableListin luominen

On olemassa erilaisia ​​tapoja luoda ImmutableList Javassa riippuen käyttämästäsi Java-versiosta ja käytettävissä olevista kirjastoista. Tässä muutamia esimerkkejä:

1. Java 9 of() -menetelmän käyttäminen:

Java 9 esitteli List-rajapinnassa uuden menetelmän nimeltä of(), joka luo muuttumattomia listoja tiiviimmin ja luettavammin. Of()-menetelmä on tehdasmenetelmä, joka ottaa muuttuvan määrän argumentteja ja palauttaa muuttumattoman luettelon, joka sisältää kyseiset elementit. Sitä voidaan käyttää minkä tahansa luokan kanssa, joka toteuttaa List-rajapinnan, mukaan lukien ArrayList, LinkedList ja ImmutableList. Yksi of()-menetelmän käytön etu on, että se on paljon ytimekkäämpi ja tarjoaa käännösaikaisen turvallisuuden suorittamalla tyyppipäätelmän argumenteille, varmistaen, että vain oikean tyyppiset objektit lisätään luetteloon. Kaiken kaikkiaan of()-menetelmä yksinkertaistaa muuttumattomien luetteloiden luomista Javassa.

Ratkaisun löytämisen vaiheet on mainittu alla.

1. Tuo List-luokka Java.util-paketista: Tämän avulla ohjelma voi käyttää List-käyttöliittymää objektiluetteloiden luomiseen ja käsittelemiseen.
2. Luo muuttumaton luettelo Java 9 -tehdasmenetelmällä: Koodi käyttää List.of()-metodia luodakseen muuttumattoman luettelon merkkijonoista, jossa on neljä elementtiä.
3. Yritä muokata listaa: Ohjelma yrittää lisätä elementin muuttumattomaan listaan ​​add()-menetelmällä, joka ei ole sallittu muuttumattomissa listoissa. Tämän seurauksena ohjelma saa kiinni add()-metodin heittämän UnsupportedOperationExceptionin ja tulostaa viestin, joka ilmoittaa, että luetteloa ei voi muokata.

Tiedoston nimi: ImmutableListExample.java

 // Import the required List class from the Java.util package import java.util.List; // Define the class name public class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using the Java 9 factory of() method List fruits = List.of('apple', 'banana', 'orange', 'grape'); // Print the elements of the List System.out.println('Fruits: ' + fruits); // Try to modify the List (will throw UnsupportedOperationException) try { fruits.add('pineapple'); } catch (UnsupportedOperationException ex) { System.out.println('Cannot modify immutable list.'); } } } 

Lähtö:

 Fruits: [apple, banana, orange, grape] Cannot modify immutable List. 

2. Guava-kirjaston ImmutableList.Builder-luokan käyttäminen:

Elementtien lisääminen luetteloon sujuvasti, mikä tekee luettelon asteittaisesta luomisesta kätevää.

Käytetystä menetelmästä riippumatta tuloksena olevaa ImmutableList-luetteloa voidaan käyttää ja iteroida kuten mitä tahansa muuta luetteloa, mutta sen sisältöä ei voi muokata.

Tässä on vaiheittainen ratkaisu annetulle koodille:

1. Tuo vaaditut luokat: Tuo List-käyttöliittymä ja ImmutableList-luokka paketista com.google.common.collect.
2. Luo muuttumaton luettelo rakentajalla: Luo muuttumaton luettelo käyttämällä ImmutableList-rakennusohjelmaa. Käytä add()-menetelmää elementtien lisäämiseen luetteloon ja kutsu build()-metodia luodaksesi muuttumattoman luettelon.
3. Muuttumattoman luettelon luominen olemassa olevasta luettelosta: Luo List-objekti halutuilla elementeillä. Kutsu sitten ImmutableList.copyOf()-metodia, joka välittää listan parametrina, luodaksesi muuttumattoman luettelon.
4. Elementtien lisääminen: Käytä ImmutableList-rakennustyökalua lisätäksesi elementtejä addAll()-menetelmällä ja kutsu build()-metodia luodaksesi muuttumattoman luettelon.
5. Tulosta luettelot: Tulosta muuttumattomien luetteloiden sisältö System.out.println()-menetelmällä.

Toteutus:

Tiedoston nimi: ImmutableListExample.java

 import java.util.List; import com.google.common.collect.ImmutableList; public class ImmutableListExample { public static void main(String[] args) { // Creating an immutable list using the builder ImmutableList immutableList1 = ImmutableListbuilder() .add('Welcome') .add('to') .add('home') .build(); // Creating an immutable list from an existing list List existingList = List.of('Welcome', 'to', 'home', 'Think'); ImmutableList immutableList2 = ImmutableList.copyOf(existingList); // Creating an immutable list from an existing list and adding more elements ImmutableList immutableList3 = ImmutableList.builder() .addAll(existingList) .add('Big') .build(); // Let's print the lists System.out.println('Immutable List 1: ' + immutableList1); System.out.println('Immutable List 2: ' + immutableList2); System.out.println('Immutable List 3: ' + immutableList3); } } 

Lähtö:

 Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big] 

3. Käyttämällä ImmutableList-luokan of()-metodia

Guava-kirjaston ImmutableList-luokan of()-menetelmän avulla voit luoda muuttumattoman luettelon, jossa on kiinteä määrä elementtejä. Kun luettelo on luotu, et voi lisätä, poistaa tai muokata sen elementtejä.

Tiedoston nimi: ImmutableListExample.java

 import com.google.common.collect.ImmutableList; import java.util.List; class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using the Guava library's ImmutableList class ImmutableList fruits = ImmutableList.of('apple', 'banana', 'orange', 'grape'); // Print the contents of the immutable List System.out.println('Fruits: ' + fruits); } } 

Lähtö:

 Fruits: [apple, banana, orange, grape] 

4. CopyOf()-menetelmän avulla

Javassa copyOf()-menetelmä luo uuden taulukon, joka kopioi olemassa olevan taulukon tietyllä pituudella. Menetelmässä on kaksi argumenttia: kopioitava taulukko ja uuden taulukon pituus.

Tiedoston nimi: ImmutableListExample.java

binääripuutyypit

 import com.google.common.collect.ImmutableList; import java.util.*; class ImmutableListExample { public static void main(String[] args) { // Create an ArrayList and add elements to it List myArrayList = new ArrayList(); myArrayList.add('Java'); myArrayList.add('Python'); myArrayList.add('C++'); // Create an immutable list using the Guava library's ImmutableList class and the copyOf() method ImmutableList immutableList1 = ImmutableList.copyOf(myArrayList); // Create an array and convert it to a list String[] myArray = {'Learning', 'Web', 'Development', 'is', 'Fun'}; List myList = Arrays.asList(myArray); // Create an immutable list using the Guava library's ImmutableList class and the copyOf() method ImmutableList immutableList2 = ImmutableList.copyOf(myList); // Print the contents of the immutable lists System.out.println('Immutable List 1: ' + immutableList1); System.out.println('Immutable List 2: ' + immutableList2); } } 

Lähtö:

 Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun] 

5. UnsupportedOperationException

Ohjelma havainnollistaa muuttumattoman luettelon luomista Javassa Collections.unmodifiableList-menetelmällä. Lisäksi se näyttää, kuinka käsitellä UnsupportedOperationException-poikkeusta, joka ilmaantuu yritettäessä muokata luetteloa.

Ratkaisun löytämisen vaiheet on mainittu alla:

1. Ensin luomme muuttuvan ArrayList sisältää joitain alkuelementtejä käyttämällä / menetelmä, joka palauttaa muuttumattoman luettelon. Sitten ohitamme tämän ArrayList kohtaan Collections.unmodifiableList menetelmä, joka palauttaa muuttumattoman näkymän luettelosta.
2. Yritämme muokata muuttumatonta luetteloa käyttämällä lisää poista , ja aseta Koska lista on muuttumaton, sen muokkaaminen aiheuttaa Ei tuettuOperationException .
3. Me saamme kiinni Ei tuettuOperationException joka heitetään ja tulosta konsoliin viesti, joka ilmoittaa, mitä toimintoa yritettiin ja mikä epäonnistui.

Huomaa, että Collections.unmodifiableList menetelmä luo vain muuttumattoman näkymän alkuperäisestä luettelosta. Muuttumaton näkymä heijastaa näitä muutoksia, jos alkuperäistä luetteloa muutetaan. Luodaksesi todella muuttumattoman luettelon, jota ei voi muokata millään tavalla, voit käyttää mukautettua toteutusta Lista käyttöliittymä, joka tekee poikkeuksen yrittäessään muokata luetteloa.

merkkijono json-objektiin

Toteutus:

Tiedoston nimi: ImmutableListExample.java

 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using Collections.unmodifiableList List immutableList = Collections.unmodifiableList(new ArrayList(List.of('foo', 'bar', 'baz'))); // Attempt to modify the immutable List using various methods try { immutableList.add('qux'); System.out.println('Successfully added element to immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } try { immutableList.remove(0); System.out.println('Successfully removed element from immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } try { immutableList.set(0, 'qux'); System.out.println('Successfully modified element in immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } } } 

Lähtö:

 UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null 

6. Collections.unmodifiableList()

Collections.unmodifiableList() on Java Collections Frameworkin menetelmä, joka luo muokkaamattoman näkymän olemassa olevasta luettelosta. Voidaan päätellä, että muokkaamaton luettelo johtaa UnsupportedOperationExceptionin esiintymiseen. Alkuperäistä luetteloa voidaan edelleen muokata, ja kaikki muutokset näkyvät ei-muokattavassa luettelossa.

Ohjelma esittelee, kuinka Collections.unmodifiableList()-metodia käytetään muunnettavan luettelon muokkaamattoman esityksen luomiseen.

Ratkaisun löytämisen vaiheet on mainittu alla:

1. Luo muuttuva luettelo mutableList ja lisää siihen joitakin elementtejä käyttämällä lisätä() menetelmä ArrayList
2. Luo muutettavissa olevasta luettelosta muokkaamaton näkymä mutableList käyttämällä unmodifiableList() menetelmä ja liitä se muuttujaan muokkaamatonLista .
3. Yritä muokata ei-muokattavaa luetteloa muokkaamaton lista käyttämällä lisätä() Koska muokkaamaton luettelo on vain luku -tilassa, tämä heittää an Ei tuettuOperationException . Tämän poikkeuksen havaitsemisen jälkeen konsoliin tulostetaan viesti.
4. Muokkaa alkuperäistä muokattavaa luetteloa mutableList lisäämällä toinen elementti käyttämällä lisätä()
5. Tulosta sekä muutettavissa olevat että ei-muokattavat luettelot konsoliin osoittaaksesi, että ei-muokattava luettelo heijastaa alkuperäiseen muokattavaan luetteloon tehtyjä muutoksia.

Tiedoston nimi: UnmodifiableListExample.java

 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class UnmodifiableListExample { public static void main(String[] args) { List mutableList = new ArrayList(); mutableList.add('apple'); mutableList.add('banana'); mutableList.add('orange'); // Create an unmodifiable view of the mutableList List unmodifiableList = Collections.unmodifiableList(mutableList); // Attempt to modify the unmodifiableList will throw UnsupportedOperationException try { unmodifiableList.add('pear'); } catch (UnsupportedOperationException e) { System.out.println('Attempt to modify unmodifiableList failed: ' + e.getMessage()); } // The original mutableList can still be modified mutableList.add('pear'); // The unmodifiableList will reflect the changes made to the original mutableList System.out.println('mutableList: ' + mutableList); // [apple, banana, orange, pear] System.out.println('unmodifiableList: ' + unmodifiableList); // [apple, banana, orange, pear] } } 

Lähtö:

 Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear] 

ImmutableListin edut

ImmutableListillä on useita etuja, mukaan lukien:

Langan turvallisuus:Koska ImmutableList on muuttumaton, se on luonnostaan ​​lankaturvallinen. Useat säikeet voivat käyttää samaa luetteloa ilman säikeen häiriöiden tai muistin epäjohdonmukaisuuden riskiä.Turvallisuus:Muuttumattomat luettelot ovat vähemmän alttiita tietoturva-aukkoja. Jos hyökkääjä esimerkiksi yrittää muokata luetteloa lisäämällä tai poistamalla elementtejä, hän ei voi tehdä niin, koska luettelo on muuttumaton.Esitys:Koska muuttumattomat luettelot ovat vain luku -tilassa, ne voidaan tallentaa välimuistiin suorituskyvyn parantamiseksi. Jos luetteloa on käytettävä useita kertoja, muuttumattoman luettelon käyttäminen joka kerta uuden luettelon luomisen sijaan voi auttaa välttämään ylimääräisiä kustannuksia.Ennustettavuus:Koska muuttumattomia listoja ei voida muokata, niiden käyttäytyminen on ennakoitavissa. Jotkin muuttumattomien luetteloiden käytön edut poistavat puolustavan ohjelmoinnin tarpeen ja helpottavat koodin perustelemista.Yksinkertaistaa koodausta:Muuttumattomat luettelot yksinkertaistavat koodausta poistamalla synkronoinnin, suojaavan kopioinnin ja virhealtista manuaalisen muistinhallinnan tarpeen. Tämän lähestymistavan tuloksena on koodi, jota on helpompi ylläpitää ja jonka ulkonäkö on puhtaampi.Helpottaa testausta:Muuttumattomia listoja on helpompi testata, koska niiden sisältö ei muutu. Lähestymistapa helpottaa kaikki mahdolliset skenaariot ja reunatapaukset kattavien testien kirjoittamista.