Array van objecten in Java

Wat is een array van objecten in Java?

A Java reeks objecten Slaat meerdere objectinstanties van dezelfde klasse op in één container met een vaste grootte. In tegenstelling tot een primitieve array die waarden opslaat zoals int, doubleof boolean Direct in elk slot wordt een array van objecten opgeslagen. referentiesElke sleuf verwijst naar de geheugenlocatie van een object, en het object zelf bevindt zich op de Java hoop.

Deze lay-out komt overeen met hoe elk object eruitziet. variabele in Java Het werkt. De array groepeert eenvoudigweg meerdere objectverwijzingen, zodat je ze via een index kunt benaderen. Het is de meest logische keuze wanneer het aantal objecten van tevoren bekend is en gedurende de levensduur van het programma niet verandert.

Syntaxis

ClassName[] obj = new ClassName[array_length];

De rechterkant biedt ruimte voor array_length verwijzingen, allemaal geïnitialiseerd naar nullGeen enkel doel van ClassName Er bestaat nog geen container die verwijzingen naar dergelijke objecten kan bevatten.

Hoe maak je een array van objecten aan in Java

Het aanmaken van een werkende array van objecten vereist altijd twee toewijzingsstappen. De eerste wijst de referentiecontainer toe, en de tweede wijst elk object toe waarnaar de container zal verwijzen.ping De tweede stap is de meest voorkomende bron van NullPointerException in het beginnersniveau Java code.

Stap 1) Open je codebewerker en kopieer de volgende code:

class ObjectArray {
    public static void main(String args[]) {
        Account obj[] = new Account[2];
        // obj[0] = new Account();
        // obj[1] = new Account();
        obj[0].setData(1, 2);
        obj[1].setData(3, 4);
        System.out.println("For Array Element 0");
        obj[0].showData();
        System.out.println("For Array Element 1");
        obj[1].showData();
    }
}

class Account {
    int a;
    int b;

    public void setData(int c, int d) {
        a = c;
        b = d;
    }

    public void showData() {
        System.out.println("Value of a = " + a);
        System.out.println("Value of b = " + b);
    }
}

Stap 2) Sla het bestand op als ObjectArray.javaCompileer en voer het vervolgens uit.

Stap 3) Noteer de foutmelding. Probeer deze op te lossen voordat u verdergaat naar stap 4.

Stap 4) Inspecteer de lijn Account obj[] = new Account[2];Het wijst een array toe van twee referentievariabelen van het type Accountmaar er wordt geen toewijzing gedaan. Account objecten. Beide sleuven bevatten nullen bellen obj[0].setData(...) een null referentie gooit een NullPointerException tijdens runtime.

Stap 5) Verwijder het commentaar bij regel 4 en 5. Deze twee regels creëren echte Account objecten en deze toewijzen aan obj[0] en obj[1]De array bevat nu echte verwijzingen en de code werkt probleemloos.

Output:

For Array Element 0
Value of a = 1
Value of b = 2
For Array Element 1
Value of a = 3
Value of b = 4

Hoe initialiseer je een array van objecten in Java

Naast de hierboven getoonde initialisatie met setters, kan een array van objecten op drie elegantere manieren worden geïnitialiseerd. Elke methode ruilt beknoptheid in voor duidelijkheid, dus kies de methode die het beste bij de situatie past.

1. Lusinitialisatie — De array wordt toegewezen, waarna elke index wordt doorlopen en een nieuw object wordt toegewezen. Dit is het standaardpatroon voor grote arrays of wanneer het aantal objecten dynamisch is.
2. Initialisatie van de constructor — Geef waarden direct door aan de constructor tijdens het aanmaken, zodat er geen aparte setter-aanroep nodig is.
3. Initialisatie van array-literalen — declareren en vullen in één enkele instructie met een inline-instructie { ... } Initialisator, ideaal voor kleine, vaste sets.

class Account {
    int a, b;

    public Account(int a, int b) {   // constructor
        this.a = a;
        this.b = b;
    }
}

public class InitDemo {
    public static void main(String[] args) {

        // 1) Loop initialisation
        Account[] loopArr = new Account[3];
        for (int i = 0; i < loopArr.length; i++) {
            loopArr[i] = new Account(i, i * 10);
        }

        // 2) Constructor initialisation, one slot at a time
        Account[] ctorArr = new Account[2];
        ctorArr[0] = new Account(1, 2);
        ctorArr[1] = new Account(3, 4);

        // 3) Array literal initialisation
        Account[] litArr = {
            new Account(5, 6),
            new Account(7, 8),
            new Account(9, 10)
        };

        System.out.println("loop size   = " + loopArr.length);
        System.out.println("ctor size   = " + ctorArr.length);
        System.out.println("literal size= " + litArr.length);
    }
}

Lusinitialisatie is de veiligste standaardmethode omdat dit garandeert dat er geen slots overblijven. nullDe initialisatie via de constructor maakt de intentie expliciet wanneer elk object verschillende argumenten nodig heeft, en arrayliteralen houden kleine democode compact. Meng geen stijlen binnen dezelfde array, tenzij je daar een goede reden voor hebt: consistentie maakt het gemakkelijker om bugs op te sporen.

Het doorlopen en benaderen van elementen in een Java Reeks objecten

Zodra een array met objecten is gevuld, dekken drie patronen vrijwel alle toegangsbehoeften. Kies de lusstijl die past bij de mate van controle die de code over de index nodig heeft.

Classic for lus Geeft toegang tot de index, wat handig is voor het vervangen van elementen, het vergelijken van buren of het doorlopen van een subbereik.

for (int i = 0; i < obj.length; i++) {
    System.out.println("Element " + i);
    obj[i].showData();
}

Verbeterde for lus (De "for-each"-lus) verbergt de index en leest natuurlijker wanneer de index niet nodig is:

for (Account acc : obj) {
    acc.showData();
}

Streams (Java 8 en later) Converteer de array naar een pipeline, wat handig is voor filteren en mappen.ping, of aggregeren zonder een lus te schrijven:

import java.util.Arrays;

Arrays.stream(obj)
      .filter(acc -> acc.a > 0)
      .forEach(Account::showData);

Om een ​​enkel element te lezen of bij te werken, gebruikt u bijvoorbeeld directe indextoegang. obj[1].setData(10, 20)Controleer altijd eerst de lengte met obj.length te voorkomen ArrayIndexOutOfBoundsExceptionWanneer elk willekeurig slot beschikbaar zou kunnen zijn nullBeveilig de toegang met een null-controle of een Optional Om ervoor te zorgen dat het programma blijft draaien in plaats van vast te lopen.

Array van objecten versus ArrayList van objecten in Java

Een eenvoudige array van objecten is snel en voorspelbaar, maar de vaste grootte ervan wordt een beperking zodra het aantal objecten tijdens de uitvoering verandert. JavaHet Collections-framework biedt ArrayList als dynamisch alternatief. De onderstaande tabel laat zien wanneer elke keuze geschikt is.

Gebruik een array wanneer een beperkt geheugenverbruik en voorspelbare indexering belangrijk zijn, bijvoorbeeld in matrixlay-outs of prestatiekritieke 'hot paths'. Reach for ArrayList In de meeste alledaagse applicatiecode is dit zo, omdat de mogelijkheid om elementen toe te voegen en te verwijderen zonder herallocatie opweegt tegen de kleine overhead per element.

Veelgestelde vragen