Ik wil een lege array declareren in java en dan wil ik deze updaten, maar de code werkt niet

Ik wil een lege array declareren in java en dan wil ik deze updaten, maar de code werkt niet…

public class JavaConversion
{
    public static void main(String args[])
    {
        int array[]={};
        int number = 5, i = 0,j = 0;
        while (i<4) {
            array[i]=number;
            i=i+1;
        }
        while (j<4) {
            System.out.println(array[j]);
        }
    }
}

Antwoord 1, autoriteit 100%

Je maakt een array van nul lengte (geen slots om iets in te plaatsen)

int array[]={/*nothing in here = array with no elements*/};

en vervolgens proberen waarden toe te wijzen aan array-elementen (die je niet hebt, omdat er geen slots zijn)

array[i] = number; //array[i] = element i in the array of length 0

U moet een grotere array definiëren om aan uw behoeften te voldoen

int array[] = new int[4]; //Create an array with 4 elements [0],[1],[2] and [3] each containing an int value

Antwoord 2, autoriteit 38%

Je code compileert prima. Uw array-initialisatieregel is echter verkeerd:

int array[]={};

Wat dit doet, is een array declareren met een grootte die gelijk is aan het aantal elementen tussen de haakjes. Aangezien er niets tussen de haakjes staat, zegt u dat de grootte van de array 0 is – dit maakt de array volledig onbruikbaar, aangezien het nu niets kan opslaan.

In plaats daarvan kunt u ofwel de array in uw oorspronkelijke regel initialiseren:

int array[] = { 5, 5, 5, 5 };

Of u kunt de grootte aangeven en deze vervolgens invullen:

int array[] = new int[4];
// ...while loop

Als u de grootte van de array niet van tevoren weet (bijvoorbeeld als u een bestand leest en de inhoud opslaat), moet u in plaats daarvan een ArrayListgebruiken, want dat is een array die dynamisch groter wordt naarmate er meer elementen aan worden toegevoegd (in termen van de leek).

Antwoord 3, autoriteit 29%

Je moet de array een grootte geven:

public static void main(String args[])
{
    int array[] = new int[4];
    int number = 5, i = 0,j = 0;
    while (i<4){
        array[i]=number;
        i=i+1;
    }
    while (j<4){
        System.out.println(array[j]);
        j++;
    }
}

Antwoord 4, autoriteit 8%

Je kunt geen getal op een willekeurige plaats in de array zetten zonder de array te vertellen hoe groot deze moet zijn. Voor jouw voorbeeld: int[] array = new int[4];

Antwoord 5, autoriteit 4%

Je kunt zoiets als dit doen,

Initialiseer met lege array en wijs de waarden later toe

String importRt = "23:43 43:34";
if(null != importRt) {
            importArray = Arrays.stream(importRt.split(" "))
                    .map(String::trim)
                    .toArray(String[]::new);
        }
System.out.println(Arrays.toString(exportImportArray));

Hopelijk helpt het..

Antwoord 6, autoriteit 4%

Dus het probleem zit in uw arrayverklaring die u een lege array met de lege krullende beugels {} verklaart in plaats van een array die slots toestaat.

Roughly speaking, there can be three types of inputs :
 1. int array[] = null; #Does not point to any memory locations so is a null arrau
 2. int array[] = {) which is sort of equivalent to int array[] = new int[0];
 3. int array[] = new int[n] where n is some number indicating the number of 
memory locations in the array

Antwoord 7, Autoriteit 4%

U kunt proberen nieuwe array te maken bij elke iteratie met een grootte groter dan in de vorige iteratie.
d.w.z.

public class JavaConversion
{
    public static void main(String args[])
    {
        int array[]=new int[0];
        int number = 5, i = 0,j = 0;
        while (i<4) {
            array = Arrays.copyOf(array, array.length + 1);
            array[i]=number;
            i=i+1;
        }
        while (j<4) {
            System.out.println(array[j]);
        }
    }
}