Java ArrayList

Hej! I tidigare lektioner gjorde vi en djupdykning i arrayer och gick igenom vanliga exempel på att arbeta med arrayer. I den här lektionen tar vi en närmare recension på Java ArrayList. I allmänhet är arrayer superhändiga. Och, som du redan har märkt, kan du göra mycket med dem :) Men arrayer har ett antal brister.

• Begränsad storlek. Du måste veta hur många element din array behöver innehålla när du skapar den. Om du underskattar, kommer du inte att ha tillräckligt med utrymme. Överskatta, och arrayen förblir halvtom, vilket också är dåligt. När allt kommer omkring, allokerar du fortfarande mer minne än vad som är nödvändigt.


• En array har inga metoder för att lägga till element. Du måste alltid uttryckligen ange indexet för den position där du vill lägga till ett element. Om du av misstag anger indexet för en position som upptas av något värde du behöver, kommer det att skrivas över.


• Det finns inga metoder för att ta bort ett objekt. Ett värde kan bara "nollställas".

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");

       cats[1] = null;

      
      
       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

Utdata: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] Lyckligtvis är Javas skapare väl medvetna om arrays fördelar och nackdelar och skapade därför en mycket intressant datastruktur som heter Java ArrayList . Om man talar så enkelt som möjligt är en Java ArrayList en "superad" array med många nya funktioner.

Hur man skapar en ArrayList

Det är väldigt enkelt att skapa:

ArrayList<Cat> cats = new ArrayList<Cat>();

Nu har vi skapat en lista för att lagra Cat -objekt. Observera att vi inte anger storleken på ArrayList eftersom den kan expandera automatiskt. Hur är detta möjligt? Det är ganska enkelt, faktiskt. Det kanske överraskar dig, men ArrayList i Java är byggt ovanpå en väldigt vanlig array :) Ja, den innehåller en array, och det är där våra element lagras. Men ArrayList i Java har ett speciellt sätt att arbeta med den arrayen:

• När den interna arrayen är fylld skapar ArrayList en ny array internt. Storleken på den nya arrayen är storleken på den gamla arrayen gånger 1,5 plus 1.


• All data kopieras från den gamla arrayen till den nya


• Den gamla matrisen rensas upp av sophämtaren.

Denna mekanism tillåter Java ArrayList (till skillnad från en vanlig array) att implementera en metod för att lägga till nya element. Det är add()metoden

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Behemoth"));
}

Nya objekt läggs till i slutet av listan. Nu finns det ingen risk att arrayen svämmar över, så den här metoden är helt säker. Förresten, ArrayList kan inte bara hitta ett objekt genom dess index, utan också vice versa: den kan använda en referens för att hitta ett objekts index i ArrayList ! Det här är vad indexOf() -metoden är till för: Vi skickar en referens till objektet vi vill ha, och indexOf() returnerar dess index:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

Utgång: 0 Det stämmer. Vårt thomas- objekt är verkligen lagrat i element 0. Arrayer har inte bara nackdelar. De har också obestridliga fördelar. En av dem är möjligheten att söka element efter index. Eftersom vi pekar på ett index, dvs på en specifik minnesadress, går det mycket snabbt att söka i en array på detta sätt. ArrayListvet hur man gör det också! Metoden get () implementerar detta:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

Utdata: Cat{name='Behemoth'} Dessutom kan du enkelt ta reda på om ArrayList innehåller ett visst objekt. Detta görs med metoden ArrayList contains():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.remove(fluffy);
   System.out.println(cats.contains(fluffy));
}

Metoden kontrollerar om ArrayLists interna array innehåller elementet och returnerar ett booleskt värde (sant eller falskt). Output: false Och en annan viktig sak om infogning. ArrayList låter dig använda ett index för att infoga element inte bara i slutet av arrayen, utan var som helst. Den har två metoder för detta:

• ArrayList add(int index, Cat-element)
• ArrayList set(int index, Cat-element)

Som argument tar båda dessa metoder indexet för den position där du vill infoga, och en referens till själva objektet. Skillnaden är att om du infogar med set() skrivs det gamla värdet över. Om du infogar med add() skiftar du först med ett alla element från [index] till slutet av arrayen och lägger sedan till det angivna objektet i den resulterande tomma positionen.

Här är ett exempel:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set

   System.out.println(cats.toString());
}

Utdata: [[Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Behemoth'}] Vi hade en lista med 2 katter . Sedan infogade vi en annan som element 0 med metoden set() . Som ett resultat har det gamla elementet ersatts av ett nytt.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add

   System.out.println(cats.toString());
}

Och här ser vi att add() fungerar annorlunda. Den flyttar alla element till höger och skriver sedan det nya värdet som element 0. Utdata: [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] För att rensa listan helt använder vi metoden clear() :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.clear();

   System.out.println(cats.toString());
}

Utdata: [] Allt togs bort från listan. Observera förresten: till skillnad från arrayer åsidosätter ArrayList metoden toString() och visar redan listan på lämpligt sätt som strängar. Med vanliga arrayer var vi tvungna att använda klassen Arrays för detta. Och eftersom jag nämnde Arrays : Java låter dig enkelt "växla" mellan en array och en ArrayList , dvs konvertera en till en annan. Klassen Arrays har en Arrays.asList()- metod för detta. Vi använder den för att hämta innehållet som en array och skicka dem till vår ArrayList -konstruktor:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   Cat[] catsArray = {thomas, behemoth, lionel, fluffy};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

Utdata: [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}] Du kan också gå i motsatt riktning: hämta en array från ett ArrayList- objekt. Vi gör detta med metoden toArray() :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

Notera: vi skickade en tom array till toArray() -metoden. Detta är inte ett fel. Inuti klassen ArrayList är den här metoden implementerad på ett sådant sätt att överföring av en tom array ökar dess prestanda. Ha bara detta i åtanke för framtiden (naturligtvis kan du skicka en array av någon specifik storlek, det kommer också att fungera). Åh, ungefär storleken. Listans nuvarande storlek kan hittas med metoden size() :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

Det är viktigt att förstå att till skillnad från en arrays length -egenskap returnerar metoden ArrayList.size() det faktiska antalet element, inte den ursprungliga kapaciteten. När allt kommer omkring angav vi ingen storlek när vi skapade ArrayList . Du kan dock specificera det — ArrayList har en lämplig konstruktor. Men när det gäller att lägga till nya element ändrar detta inte dess beteende:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);// create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

Konsolutgång: 4 Vi har skapat en lista med 2 element, men den utökades tyst när vi behövde det. En annan övervägande är att om vi skapar en mycket liten lista initialt, kommer den att behöva utökas oftare, vilket kommer att använda vissa resurser. Vi berörde knappt processen att ta bort element från en ArrayList i den här lektionen. Naturligtvis beror det inte på att det har missat oss. Vi har lagt detta ämne i en separat lektion som du kommer att träffa senare :) För att förstärka det du lärde dig föreslår vi att du tittar på en videolektion från vår Java-kurs