In C/C++Vroeger gebruikte ik
int arr[10] = {0};
… om al mijn array-elementen te initialiseren naar 0.
Is er een vergelijkbare snelkoppeling in Java?
Ik wil vermijden met behulp van de lus, is het mogelijk?
int arr[] = new int[10];
for(int i = 0; i < arr.length; i++) {
arr[i] = 0;
}
Antwoord 1, Autoriteit 100%
Een standaardwaarde van 0 voor arrays met integrale typen wordt gegarandeerd door de Taal spec :
Elke klasse variabele, instrumentenvariabele of array-component wordt geïnitialiseerd met een standaardwaarde wanneer deze is gemaakt (§15.9, §15.10) […] voor type
int, de standaardwaarde is nul, dat wil zeggen,0. & nbsp;
Als u een eendimensionale array op een andere waarde wilt initialiseren, kunt u java.util.arrays.fill () (die natuurlijk intern een lus zal gebruiken).
Antwoord 2, Autoriteit 19%
Hoewel de andere antwoorden correct zijn (INT-array-waarden zijn standaard geïnitialiseerd naar 0), als u dit expliciet wilt doen (bijvoorbeeld bijvoorbeeld als u een array hebt gevuld met de waarde 42), kunt u de vulling ( ) METHODE VAN DE Arrays klasse:
int [] myarray = new int[num_elts];
Arrays.fill(myarray, 42);
Of als je een fan bent van 1-liners, kun je de Collections.nCopies()routine:
Integer[] arr = Collections.nCopies(3, 42).toArray(new Integer[0]);
Zou arr de waarde geven:
[42, 42, 42]
(hoewel het Integeris, en niet int, als je het primitieve type nodig hebt, kun je de Apache Commons ArrayUtils.toPrimitive()routine:
int [] primarr = ArrayUtils.toPrimitive(arr);
Antwoord 3, autoriteit 7%
In Java worden alle elementen (primitieve integer-types byteshort, int, long) geïnitialiseerd op 0 standaard. Je kunt de lus opslaan.
Antwoord 4, autoriteit 4%
Hoe het de prestaties van uw applicatie vermindert….? Lees het volgende.
In Java Language Specificatie kan de Standaard/Initiële Waardevoor elk Object als volgt worden opgegeven.
Voor type byteis de standaardwaardenul, dat wil zeggen, de waarde van (byte) is 0.
Voor type shortis de standaardwaardenul, dat wil zeggen, de waarde van (short) is 0.
Voor type intis de standaardwaardenul, dat wil zeggen 0.
Voor type langis de standaardwaardenul, dat wil zeggen 0L.
Voor type floatis de standaardwaardepositieve nul, dat wil zeggen 0.0f.
Voor type dubbelis de standaardwaardepositief nul, dat wil zeggen 0,0d.
Voor type charis de standaardwaardehet null-teken, dat wil zeggen ‘\u0000‘ .
Voor type booleanis de standaardwaardefalse.
Voor alle referentietypenis de standaardwaardenull.
Door dit alles in overweging te nemen, hoeft u niet te initialiseren met nulwaarden voor de array-elementen, omdat standaard alle array-elementen 0 zijn voor int array.
Omdat een arrayeen containerobject is dat een vast aantal waarden van één type bevat.
Nu is het Type array voor jou int, dus denk eraan dat de standaardwaarde voor alle array-elementen automatisch 0zal zijn omdat het int type vasthoudt.
Nu overweegde arrayvoor String typezodat alle array-elementen een de standaardwaardeis null.
Waarom doe je dat niet……?
u kunt een null-waarde toewijzen door lus te gebruiken zoals u in uw vraag voorstelt.
int arr[] = new int[10];
for(int i=0;i<arr.length;i++)
arr[i] = 0;
Maar als u dat doet, leidt dit tot een nutteloos verlies van de machinecyclus.
En als u in uw toepassing gebruikt, waar u veel arrays hebt en dat doet u dat voor elke array dan beïnvloedt het de toepassingsprestaties up-to aanzienlijk niveau.
Hoe meer gebruik van machinecyclus == & GT; meer tijd om de gegevens == & GT te verwerken; De uitgangstijd zal aanzienlijk worden verhoogd . Zodat uw aanvraaggegevensverwerking als een laag niveau (langzaam op een niveau) kunnen worden beschouwd.
Antwoord 5, Autoriteit 3%
U kunt de lus opslaan, initialisatie is al op 0. zelfs voor een lokale variabele.
, maar corrigeer de plaats waar u de beugels plaatst, voor leesbaarheid (erkende best practice):
int[] arr = new int[10];
Antwoord 6, Autoriteit 2%
Als u float of integer gebruikt, kunt u de standaardwaarde als deze toewijzen …
Integer[] data = new Integer[20];
Arrays.fill(data,new Integer(0));
Antwoord 7
U kunt een nieuwe lege array maken met uw bestaande array-formaat, en u kunt ze aan uw array toevoegen. Dit kan sneller dan andere.
Snipet:
package com.array.zero;
public class ArrayZero {
public static void main(String[] args) {
// Your array with data
int[] yourArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//Creating same sized array with 0
int[] tempArray = new int[yourArray.length];
Assigning temp array to replace values by zero [0]
yourArray = tempArray;
//testing the array size and value to be zero
for (int item : yourArray) {
System.out.println(item);
}
}
}
Resultaat:
0
0
0
0
0
0
0
0
0
Antwoord 8
De int-waarden zijn al nul na initialisatie, zoals iedereen heeft gezegd. Als je een situatie hebt waarin je array-waarden echt op nul moet zetten en dat wilt optimaliseren, gebruik dan System.arraycopy:
static private int[] zeros = new float[64];
...
int[] values = ...
if (zeros.length < values.length) zeros = new int[values.length];
System.arraycopy(zeros, 0, values, 0, values.length);
Dit gebruikt memcpyonder de dekmantel in de meeste of alle JRE-implementaties. Merk op dat het gebruik van een static als deze veilig is, zelfs met meerdere threads, aangezien in het ergste geval meerdere threads tegelijkertijd zerosopnieuw toewijzen, wat geen kwaad kan.
Je zou ook Arrays.fillkunnen gebruiken, zoals sommige anderen al hebben gezegd. Arrays.fillzoumemcpykunnen gebruiken in een slimme JVM, maar is waarschijnlijk slechts een Java-lus en de grenzen die daarbij horen.
Benchmark natuurlijk uw optimalisaties.
Antwoord 9
In c/cpp is er geen kortere weg dan om alle arrays te initialiseren met het nul-subscript.Ex:
int arr[10] = {0};
Maar in Java is er een magisch hulpmiddel genaamd Arrays.fill() dat alle waarden in een array zal vullen met het gehele getal van uw keuze.Ex:
import java.util.Arrays;
public class Main
{
public static void main(String[] args)
{
int ar[] = {2, 2, 1, 8, 3, 2, 2, 4, 2};
Arrays.fill(ar, 10);
System.out.println("Array completely filled" +
" with 10\n" + Arrays.toString(ar));
}
}
Antwoord 10
Initialisatie is niet vereist in het geval van nul omdat de standaardwaarde van int in Java nul is.
Voor andere waarden dan nul biedt java.util.Arrayseen aantal opties, de eenvoudigste is de vulmethode.
int[] arr = new int[5];
Arrays.fill(arr, -1);
System.out.println(Arrays.toString(arr)); //[-1, -1, -1, -1, -1 ]
int [] arr = new int[5];
// fill value 1 from index 0, inclusive, to index 3, exclusive
Arrays.fill(arr, 0, 3, -1 )
System.out.println(Arrays.toString(arr)); // [-1, -1, -1, 0, 0]
We kunnen ook Arrays.setAll() gebruiken als we waarde op voorwaarde willen invullen:
int[] array = new int[20];
Arrays.setAll(array, p -> p > 10 ? -1 : p);
int[] arr = new int[5];
Arrays.setAll(arr, i -> i);
System.out.println(Arrays.toString(arr)); // [0, 1, 2, 3, 4]
Antwoord 11
declareer de array als instantievariabele in de klasse, d.w.z. uit elke methode en JVM geeft het 0 als standaardwaarde. U hoeft zich geen zorgen meer te maken
Antwoord 12
Ja, int-waarden in een array worden op nul geïnitialiseerd. Maar u bent hier niet zeker van. Oracle-documentatie stelt dat dit een slechte codeerpraktijk is.
Antwoord 13
Nog een andere benadering door lambda boven java 8 te gebruiken
Arrays.stream(new Integer[nodelist.size()]).map(e ->
Integer.MAX_VALUE).toArray(Integer[]::new);
Antwoord 14
Je hebt het correct gedefinieerd in je vraag, het is bijna hetzelfde als voor C++. Het enige dat u voor het primitieve gegevenstype hoeft te doen, is de array te initialiseren. Standaardwaarden zijn voor int 0.
int[] intArray = new int[10];
Antwoord 15
int a=7, b=7 ,c=0,d=0;
int dizi[][]=new int[a][b];
for(int i=0;i<a;i++){
for(int q=d;q<b;q++){
dizi[i][q]=c;
System.out.print(dizi[i][q]);
c++;
}
c-=b+1;
System.out.println();
}
resultaat
0123456
-1012345
-2-101234
-3-2-10123
-4-3-2-1012
-5-4-3-2-101
-6-5-4-3-2-10