Een reeks objecten in Java

Ik ben nieuw bij Java en voor de tijd creëerde een scala aan objecten in Java.

Ik heb bijvoorbeeld een klasse A –

A[] arr = new A[4];

Maar dit maakt alleen aanwijzingen (referenties) naar Aen niet 4 objecten. Is dit correct? Ik zie dat wanneer ik probeer toegang te krijgen tot functies / variabelen in de gemaakt objecten krijg ik een null-aanwijzer uitzondering.
Om de objecten te kunnen manipuleren / openen, moest ik dit doen:

A[] arr = new A[4];
for (int i = 0; i < 4; i++) {
    arr[i] = new A();
}

Is dit correct of doe ik iets verkeerd? Als dit correct is, is het echt vreemd.

EDIT: Ik vind dit vreemde omdat je in C++ je gewoon een nieuwe A[4]zegt en het creëert de vier objecten.

Antwoord 1, Autoriteit 100%

Dit is correct.

A[] a = new A[4];

… Creëert 4 AREFERENTIES, vergelijkbaar met dit:

A a1;
A a2;
A a3;
A a4;

Nu zou je niet kunnen doen a1.someMethod()zonder a1als volgt toe te wijzen:

a1 = new A();

Evenzo, met de array die u dit moet doen:

a[0] = new A();

… voordat u het gebruikt.

Antwoord 2, Autoriteit 31%

Dit is correct. U kunt ook doen:

A[] a = new A[] { new A("args"), new A("other args"), .. };

Deze syntaxis kan ook worden gebruikt om een ​​array overal te maken en initialiseren, zoals in een methodeargument:

someMethod( new A[] { new A("args"), new A("other args"), . . } )

Antwoord 3, Autoriteit 14%

Ja, het creëert alleen referenties, die zijn ingesteld op hun standaardwaarde null. Dat is waarom u een nullpointerexceptie krijgt, moet u objecten afzonderlijk maken en de referentie toewijzen. Er zijn 3 stappen om arrays in Java –

te maken

Verklaring – In deze stap specificeren we het gegevenstype en de afmetingen van de array die we gaan maken. Maar vergeet niet dat we de maten van dimensies nog niet noemen. Ze zijn leeg gelaten.

Instantiation – In deze stap maken we de array of toewijzen geheugen voor de array, met behulp van het nieuwe sleutelwoord. Het is in deze stap die we de maten van de array-afmetingen vermelden.

Initialisatie – De array wordt altijd geïnitialiseerd naar de standaardwaarde van het gegevenstype. Maar we kunnen onze eigen initialisaties maken.

Aankomende arrays in Java

Dit is hoe we een eendimensionale array in Java –

verklaren

int[] array;
int array[];

Oracle beveelt aan dat u de voormalige syntaxis gebruikt voor het declareren van arrays.
Hier zijn enkele andere voorbeelden van juridische aangiften –

// One Dimensional Arrays
int[] intArray;             // Good
double[] doubleArray;
// One Dimensional Arrays
byte byteArray[];           // Ugly!
long longArray[];
// Two Dimensional Arrays
int[][] int2DArray;         // Good
double[][] double2DArray;
// Two Dimensional Arrays
byte[] byte2DArray[];       // Ugly
long[] long2DArray[];

En dit zijn enkele voorbeelden van illegale verklaringen –

int[5] intArray;       // Don't mention size!
double{} doubleArray;  // Square Brackets please!

Instantiëring

Dit is hoe we “instantieren” of geheugen toewijzen aan een array –

int[] array = new int[5];

Als de JVM het trefwoord newtegenkomt, begrijpt hij dat hij ergens geheugen voor moet toewijzen. En door int[5]op te geven, bedoelen we dat we een array van ints willen, van grootte 5.
Dus de JVM creëert het geheugen en wijst de referentie van het nieuw toegewezen geheugen toe aan de array, een “referentie” van het type int[]

Initialisatie

Een lus gebruiken– Het gebruik van een for-lus om elementen van een array te initialiseren is de meest gebruikelijke manier om de array op gang te brengen. Het is niet nodig om een for-lus uit te voeren als u de standaardwaarde zelf gaat toewijzen, omdat JVM dit voor u doet.

Alles in één..!– We kunnen onze array in één keer declareren, instantiëren en initialiseren. Hier is de syntaxis –

int[] arr = {1, 2, 3, 4, 5};

Hier vermelden we de grootte niet, omdat JVM kan zien dat we 5 waarden geven.

Dus, totdat we een instantie maken, blijven de verwijzingen nul. Ik hoop dat mijn antwoord je heeft geholpen..! 🙂

Bron – Arrays in Java

Antwoord 4, autoriteit 2%

Hier is het duidelijke voorbeeld van het maken van een array van 10 werknemersobjecten, met een constructor die parameter nodig heeft:

public class MainClass
{  
    public static void main(String args[])
    {
        System.out.println("Hello, World!");
        //step1 : first create array of 10 elements that holds object addresses.
        Emp[] employees = new Emp[10];
        //step2 : now create objects in a loop.
        for(int i=0; i<employees.length; i++){
            employees[i] = new Emp(i+1);//this will call constructor.
        }
    }
}
class Emp{
    int eno;
    public Emp(int no){
        eno = no;
        System.out.println("emp constructor called..eno is.."+eno);
    }
}

Antwoord 5, autoriteit 2%

Je hebt gelijk. Afgezien daarvan, als we een array van specifieke grootte willen maken, gevuld met elementen die worden geleverd door een “fabriek”, sinds Java 8 (die stream API) kunnen we deze one-liner gebruiken:

A[] a = Stream.generate(() -> new A()).limit(4).toArray(A[]::new);

• Stream.generate(() -> new A())is een soort fabriek voor afzonderlijke A-elementen die zijn gemaakt op een manier die wordt beschreven door lambda, () -> new A()wat de implementatie is van Supplier<A>– het beschrijft hoe elke nieuwe A-instantie moet worden gemaakt.
• limit(4)stelt het aantal elementen in dat de stream genereert
• toArray(A[]::new)(kan ook worden herschreven als toArray(size -> new A[size])) – het laat ons beslissen /describe type array dat moet worden geretourneerd.

Voor sommige primitieve typen kunt u DoubleStream, IntStream, LongStreamgebruiken die bovendien generatoren bieden zoals rangerangeCloseden enkele anderen.

Antwoord 6

De algemene vorm om een nieuwe array in java te declareren is als volgt:

type arrayName[] = new type[numberOfElements];

Waarbij type een primitief type of object is. numberOfElementsis het aantal elementen dat u in de array opslaat en deze waarde kan niet veranderenomdat Java geen dynamische arrays ondersteunt (als u een flexibele en dynamische structuur nodig heeft voor met objecten die u misschien wilt gebruiken in sommige Java-verzamelingen).

Laten we een array initialiseren om de salarissen van alle werknemers in een klein bedrijf van 5 personen op te slaan:

int salaries[] = new int[5];

Het type array (in dit geval int) is van toepassing op alle waarden in de array. U kunt geen typen in één array combineren.

Nu we onze salarisreeks hebben geïnitialiseerd, willen we er enkele waarden in opnemen. We kunnen dit tijdens de initialisatie als volgt doen:

int salaries[] = {50000, 75340, 110500, 98270, 39400};

Of om het later als volgt te doen:

salaries[0] = 50000;
salaries[1] = 75340;
salaries[2] = 110500;
salaries[3] = 98270;
salaries[4] = 39400;

Meer visueel voorbeeld van het maken van arrays:

Voor meer informatie over arrays, bekijk je de handleiding.

Antwoord 7

Ja, het is correct in Java, er zijn verschillende stappen om een array van objecten te maken:

1. Declareren en vervolgens instantiëren (geheugen maken om ‘4’ objecten op te slaan):

   A[ ] arr = new A[4];
   

2. De objecten initialiseren (in dit geval kunt u 4 objecten van klasse A initialiseren)

   arr[0] = new A();
   arr[1] = new A();
   arr[2] = new A();
   arr[3] = new A();
   

   of

   for( int i=0; i<4; i++ )
     arr[i] = new A();
   

Je kunt nu bestaande methoden aanroepen van de objecten die je zojuist hebt gemaakt, enz.

Bijvoorbeeld:

 int x = arr[1].getNumber();

of

 arr[1].setNumber(x);

Antwoord 8

Voor generieke klasse is het noodzakelijk om een wrapperklasse aan te maken.
Bijvoorbeeld:

Set<String>[] sets = new HashSet<>[10]

resulteert in: “Kan geen generieke array maken”

Gebruik in plaats daarvan:

       class SetOfS{public Set<String> set = new HashSet<>();}
        SetOfS[] sets = new SetOfS[10];  

Antwoord 9

Stel dat klasse A zo is:

class A{
int rollno;
int DOB;
}        

en u wilt een array maken van de objecten voor de klasse A. Dus u doet dit als volgt,

   A[] arr = new A[4];    //Statement 1
    for (int i = 0; i < 4; i++) {
    arr[i] = new A();      //Statement 2
    }

wat absoluut correct is.

Hier is A de klasse en in Statement 1 is klasse A een datatype van de array. Wanneer deze instructie wordt uitgevoerd vanwege het nieuwe sleutelwoord, wordt er een object gemaakt en wordt er dynamisch geheugen aan toegewezen dat gelijk is aan de ruimte die nodig is voor de 4 blokken van datatype A, dwz (voor één blok in de array is de benodigde ruimte 8 bytes (4+4), ik neem aan dat int 4 bytes aan ruimte in beslag neemt, daarom is de totale toegewezen ruimte 4*4 bytes voor de array).
Vervolgens wordt de referentie van het object gegeven aan de variabele arr. Hier is een belangrijk punt om op te merken dat Statement 1 niets te maken heeft met het maken van een object voor klasse A, er wordt geen object gemaakt voor deze klasse, het wordt alleen gebruikt als een gegevenstype dat de grootte van de klasse A geeft die nodig is voor de geheugentoewijzing van de reeks.

Als de for-lus wordt uitgevoerd en Statement 2 wordt uitgevoerd, wijst JVM nu het geheugen toe voor de klasse A (d.w.z. creëert een object) en geeft de verwijzing naar de arr[i]. Elke keer dat de lus wordt aangeroepen, wordt er een object gemaakt en wordt de referentie ervan gegeven aan arr[i].

Dus arr[0] met een spatie van 8 bytes krijgt de referentie van het object van de klasse A en elke keer dat de lus wordt uitgevoerd, wordt een nieuw object gemaakt en wordt naar dat object verwezen, zodat het nu toegang heeft tot de gegevens in dat object .