Vraag Hoe declareer en initialiseer ik een array in Java?


Hoe declareer en initialiseer ik een array in Java?


1613
2017-07-29 14:22


oorsprong


antwoorden:


U kunt array-declaratie of array-lettertype gebruiken (maar alleen wanneer u de variabele meteen declareert en beïnvloedt, kunnen array-literals niet worden gebruikt voor het opnieuw toewijzen van een array).

Voor primitieve typen:

int[] myIntArray = new int[3];
int[] myIntArray = {1,2,3};
int[] myIntArray = new int[]{1,2,3};

Voor klassen, bijvoorbeeld String, het is hetzelfde:

String[] myStringArray = new String[3];
String[] myStringArray = {"a","b","c"};
String[] myStringArray = new String[]{"a","b","c"};

De derde manier van initialiseren is handig wanneer u de array eerst declareert en vervolgens initialiseert. De cast is hier noodzakelijk.

String[] myStringArray;
myStringArray = new String[]{"a","b","c"};

2188
2017-07-09 21:59



Er zijn twee soorten array.
 

One Dimensional Array

Syntaxis voor standaardwaarden:

int[] num = new int[5];

Of (minder geprefereerd)

int num[] = new int[5];

Syntaxis met gegeven waarden (variabele / veldinitialisatie):

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

Of (minder geprefereerd)

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

Opmerking: voor het gemak heeft int [] num de voorkeur omdat het duidelijk aangeeft dat u het hier hebt over array. Anders geen verschil. Helemaal niet.

Multidimensionale array

Verklaring

int[][] num = new int[5][2];

Of

int num[][] = new int[5][2];

Of

int[] num[] = new int[5][2];

initialisatie

 num[0][0]=1;
 num[0][1]=2;
 num[1][0]=1;
 num[1][1]=2;
 num[2][0]=1;
 num[2][1]=2;
 num[3][0]=1;
 num[3][1]=2;
 num[4][0]=1;
 num[4][1]=2;

Of

 int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };

Ragged Array (of niet-rechthoekige array)

 int[][] num = new int[5][];
 num[0] = new int[1];
 num[1] = new int[5];
 num[2] = new int[2];
 num[3] = new int[3];

Dus hier definiëren we kolommen expliciet.
Een andere manier: 

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

Voor toegang:

for (int i=0; i<(num.length); i++ ) {
    for (int j=0;j<num[i].length;j++)
        System.out.println(num[i][j]);
}

Alternatief:

for (int[] a : num) {
  for (int i : a) {
    System.out.println(i);
  }
}

Ragged-arrays zijn multidimensionale arrays.
Zie multidimensionale array-details op voor uitleg de officiële java-zelfstudies


220
2017-07-29 14:29



Type[] variableName = new Type[capacity];

Type[] variableName = {comma-delimited values};



Type variableName[] = new Type[capacity]; 

Type variableName[] = {comma-delimited values};

is ook geldig, maar ik geef de voorkeur aan de haakjes achter het type, omdat het gemakkelijker is om te zien dat het type van de variabele eigenlijk een array is.


116
2017-07-29 14:28



Er zijn verschillende manieren waarop u een array in Java kunt declareren:

float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};

U kunt meer informatie vinden in de Sun-zelfstudie site en de JavaDoc.


32
2017-07-29 14:29



Ik vind het handig als je elk onderdeel begrijpt:

Type[] name = new Type[5];

Type[] is de type van de veranderlijk naam genaamd ("naam" heet de identifier). Het letterlijke "Type" is het basistype en de haakjes betekenen dat dit het matrixtype van die basis is. Array-typen zijn weer eigen typen, waarmee u multidimensionale arrays kunt maken Type[][] (het arraytype van Type []). Het sleutelwoord new zegt om geheugen toe te wijzen voor de nieuwe array. Het getal tussen de haakjes geeft aan hoe groot de nieuwe array zal zijn en hoeveel geheugen moet worden toegewezen. Bijvoorbeeld, als Java weet dat het basistype Type neemt 32 bytes, en u wilt een array van maat 5, het moet intern 32 * 5 = 160 bytes toewijzen.

U kunt ook arrays maken met de waarden die er al zijn, zoals

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

die niet alleen de lege ruimte creëert, maar deze ook vult met die waarden. Java kan vertellen dat de primitieven gehele getallen zijn en dat er 5 van zijn, dus de grootte van de array kan impliciet worden bepaald.


26
2018-06-04 06:02



Hieronder ziet u de declaratie van een array, maar de array is niet geïnitialiseerd:

 int[] myIntArray = new int[3];

Het volgende toont de verklaring evenals de initialisatie van de array:

int[] myIntArray = {1,2,3};

Het volgende toont nu ook de verklaring en initialisatie van de array:

int[] myIntArray = new int[]{1,2,3};

Maar deze derde toont de eigenschap van het maken van een anonieme array-object die wordt aangegeven door een verwijzingsvariabele "myIntArray", dus als we alleen "new int [] {1,2,3};" dan is dit hoe een anoniem array-object kan worden gemaakt.

Als we schrijven:

int[] myIntArray;

dit is geen array-verklaring, maar de volgende verklaring maakt bovenstaande verklaring compleet:

myIntArray=new int[3];

26
2017-07-29 14:25



Alternatief,

// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];

Dat verklaart een array genaamd arrayName van maat 10 (je hebt elementen 0 tot en met 9 om te gebruiken).


22
2017-07-29 15:56



Ook als u iets meer dynamisch wilt, is er de lijst-interface. Dit gaat minder goed, maar is flexibeler:

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );

22
2018-01-28 19:19