Hoe declareer en initialiseer ik een array in Java?

Hoe declareer en initialiseer ik een array in Java?


Antwoord 1, autoriteit 100%

Je kunt ofwel array-declaratie of array-literal gebruiken (maar alleen als je de variabele meteen declareert en beïnvloedt, kunnen array-literalen 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};
// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html
int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort 

Voor klassen, bijvoorbeeld String, is het 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 eerst een array declareert en vervolgens initialiseert, een array doorgeeft als een functieargument of een array retourneert. Het expliciete type is vereist.

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

Antwoord 2, autoriteit 10%

Er zijn twee soorten arrays.

Eendimensionale array

Syntaxis voor standaardwaarden:

int[] num = new int[5];

Of (minder gewenst)

int num[] = new int[5];

Syntaxis met opgegeven waarden (variabele/veldinitialisatie):

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

Of (minder gewenst)

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

Opmerking: voor het gemak heeft int[] num de voorkeur omdat het duidelijk aangeeft dat je het hier over array hebt. 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 voor uitleg multidimensionale arraydetails op de officiële Java-tutorials


Antwoord 3, autoriteit 4%

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 na het type, omdat het gemakkelijker is om te zien dat het type van de variabele eigenlijk een array is.


Antwoord 4

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"};

Je kunt meer informatie vinden in de Sun-tutorial site en de JavaDoc.


Antwoord 5

Ik vind het handig als je elk onderdeel begrijpt:

Type[] name = new Type[5];

Type[] is het type van de variabele genaamd naam (“naam” wordt de identifier genoemd ). Het letterlijke “Type” is het basistype en de haakjes betekenen dat dit het arraytype van dat basistype is. Array-typen zijn op hun beurt weer typen van zichzelf, waardoor je multidimensionale arrays kunt maken, zoals Type[][] (het array-type 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. Als Java bijvoorbeeld weet dat het basistype Type 32 bytes nodig heeft en u een array van grootte 5 wilt, moet het 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 zien dat de primitieven gehele getallen zijn en dat het er 5 zijn, dus de grootte van de array kan impliciet worden bepaald.


Antwoord 6

Het volgende toont de declaratie van een array, maar de array is niet geïnitialiseerd:

 int[] myIntArray = new int[3];

Het volgende toont zowel de declaratie als de initialisatie van de array:

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

Nu toont het volgende ook de declaratie en initialisatie van de array:

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

Maar deze derde toont de eigenschap van het anoniem maken van array-objecten waarnaar wordt verwezen door een referentievariabele “myIntArray”, dus als we gewoon “new int[]{1,2,3};” schrijven dan is dit hoe een anoniem array-object kan worden gemaakt.

Als we gewoon schrijven:

int[] myIntArray;

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

myIntArray=new int[3];

Antwoord 7

Als alternatief,

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

Dat declareert een array met de naam arrayName van grootte 10 (je hebt de elementen 0 tot en met 9 om te gebruiken).


Antwoord 8

Als u iets dynamischers wilt, is er ook de List-interface. Dit zal niet zo goed presteren, maar is flexibeler:

List<String> listOfString = new ArrayList<String>();
listOfString.add("foo");
listOfString.add("bar");
String value = listOfString.get(0);
assertEquals( value, "foo" );

Antwoord 9

Er zijn twee manieren om een ​​array te maken:

Deze, voor een lege array:

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array

En deze, voor een geïnitialiseerde array:

int[] array = {1,2,3,4 ...};

Je kunt ook multidimensionale arrays maken, zoals deze:

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};

Antwoord 10

Neem bijvoorbeeld het primitieve type int. Er zijn verschillende manieren om een ​​int array te declareren:

int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};

waar in al deze, kun je int i[] gebruiken in plaats van int[] i.

Met reflectie kunt u (Type[]) Array.newInstance(Type.class, capacity);

gebruiken

Merk op dat in methodeparameters ... variable arguments aangeeft. In wezen is een willekeurig aantal parameters prima. Het is makkelijker uit te leggen met code:

public static void varargs(int fixed1, String fixed2, int... varargs) {...}
...
varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100}
varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};

Binnen de methode wordt varargs behandeld als een normale int[]. Type... kan alleen worden gebruikt in methodeparameters, dus int... i = new int[] {} zal niet compileren.

Merk op dat wanneer je een int[] doorgeeft aan een methode (of een ander Type[]), je de derde manier niet kunt gebruiken. In het statement int[] i = *{a, b, c, d, etc}* neemt de compiler aan dat de {...} een int[]. Maar dat komt omdat je een variabele declareert. Bij het doorgeven van een array aan een methode moet de declaratie new Type[capacity] of new Type[] {...} zijn.

Multidimensionale arrays

Multidimensionale arrays zijn veel moeilijker om mee om te gaan. In wezen is een 2D-array een array van arrays. int[][] betekent een array van int[]s. De sleutel is dat als een int[][] wordt gedeclareerd als int[x][y], de maximale index i[x-1][y-1]. In wezen is een rechthoekige int[3][5]:

[0, 0] [1, 0] [2, 0]
[0, 1] [1, 1] [2, 1]
[0, 2] [1, 2] [2, 2]
[0, 3] [1, 3] [2, 3]
[0, 4] [1, 4] [2, 4]

Antwoord 11

In Java 9

Andere IntStream.iterate en IntStream.takeWhile methoden:

int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray();
Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray();
Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In Java 10

De Local Variable Type Inference:

var letters = new String[]{"A", "B", "C"};

Antwoord 12

Als u arrays wilt maken met reflecties, kunt u dit als volgt doen:

 int size = 3;
 int[] intArray = (int[]) Array.newInstance(int.class, size ); 

Antwoord 13

In Java 8 kun je zoiets gebruiken.

String[] strs = IntStream.range(0, 15)  // 15 is the size
    .mapToObj(i -> Integer.toString(i))
    .toArray(String[]::new);

Antwoord 14

Een array van objectreferenties declareren:

class Animal {}
class Horse extends Animal {
    public static void main(String[] args) {
        /*
         * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed)
         */
        Animal[] a1 = new Animal[10];
        a1[0] = new Animal();
        a1[1] = new Horse();
        /*
         * Array of Animal can hold Animal and Horse and all subtype of Horse
         */
        Animal[] a2 = new Horse[10];
        a2[0] = new Animal();
        a2[1] = new Horse();
        /*
         * Array of Horse can hold only Horse and its subtype (if any) and not
           allowed supertype of Horse nor other subtype of Animal.
         */
        Horse[] h1 = new Horse[10];
        h1[0] = new Animal(); // Not allowed
        h1[1] = new Horse();
        /*
         * This can not be declared.
         */
        Horse[] h2 = new Animal[10]; // Not allowed
    }
}

Antwoord 15

Array is een opeenvolgende lijst met items

int item = value;
int [] one_dimensional_array = { value, value, value, .., value };
int [][] two_dimensional_array =
{
  { value, value, value, .. value },
  { value, value, value, .. value },
    ..     ..     ..        ..
  { value, value, value, .. value }
};

Als het een object is, dan is het hetzelfde concept

Object item = new Object();
Object [] one_dimensional_array = { new Object(), new Object(), .. new Object() };
Object [][] two_dimensional_array =
{
  { new Object(), new Object(), .. new Object() },
  { new Object(), new Object(), .. new Object() },
    ..            ..               ..
  { new Object(), new Object(), .. new Object() }
};

In het geval van objecten, moet u deze ofwel toewijzen aan null om ze te initialiseren met behulp van new Type(..), klassen zoals String en Integer zijn speciale gevallen die als volgt worden afgehandeld

String [] a = { "hello", "world" };
// is equivalent to
String [] a = { new String({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) };
Integer [] b = { 1234, 5678 };
// is equivalent to
Integer [] b = { new Integer(1234), new Integer(5678) };

Over het algemeen kunt u arrays maken die M-dimensionaal zijn

int [][]..[] array =
//  ^ M times [] brackets
    {{..{
//  ^ M times { bracket
//            this is array[0][0]..[0]
//                         ^ M times [0]
    }}..}
//  ^ M times } bracket
;

Het is vermeldenswaard dat het maken van een M dimensionale array duur is in termen van ruimte. Sinds wanneer u een M dimensionale array maakt met N op alle dimensies, is de totale grootte van de array groter dan N^M, aangezien elke array heeft een referentie, en bij de M-dimensie is er een (M-1)-dimensionale array van referenties. De totale grootte is als volgt

Space = N^M + N^(M-1) + N^(M-2) + .. + N^0
//      ^                              ^ array reference
//      ^ actual data

Antwoord 16

Declareren en initialiseren voor Java 8 en hoger. Maak een eenvoudige integer-array:

int [] a1 = IntStream.range(1, 20).toArray();
System.out.println(Arrays.toString(a1));
// Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Maak een willekeurige array voor gehele getallen tussen [-50, 50] en voor doubles [0, 1E17]:

int [] a2 = new Random().ints(15, -50, 50).toArray();
double [] a3 = new Random().doubles(5, 0, 1e17).toArray();

Power-of-two-reeks:

double [] a4 = LongStream.range(0, 7).mapToDouble(i -> Math.pow(2, i)).toArray();
System.out.println(Arrays.toString(a4));
// Output: [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0]

Voor String[] moet je een constructor specificeren:

String [] a5 = Stream.generate(()->"I will not squeak chalk").limit(5).toArray(String[]::new);
System.out.println(Arrays.toString(a5));

Multidimensionale arrays:

String [][] a6 = List.of(new String[]{"a", "b", "c"} , new String[]{"d", "e", "f", "g"})
    .toArray(new String[0][]);
System.out.println(Arrays.deepToString(a6));
// Output: [[a, b, c], [d, e, f, g]]

Antwoord 17

Voor het maken van arrays van class Objects kun je de java.util.ArrayList gebruiken. om een ​​array te definiëren:

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

Wijs waarden toe aan de array:

arrayName.add(new ClassName(class parameters go here);

Lees uit de array:

ClassName variableName = arrayName.get(index);

Opmerking:

variableName is een verwijzing naar de array, wat betekent dat het manipuleren van variableName arrayName

zal manipuleren

voor loops:

//repeats for every value in the array
for (ClassName variableName : arrayName){
}
//Note that using this for loop prevents you from editing arrayName

for loop waarmee u arrayName kunt bewerken (conventioneel for loop):

for (int i = 0; i < arrayName.size(); i++){
    //manipulate array here
}

Antwoord 18

Als door "array" je bedoelde het gebruik van java.util.Arrays, je kunt het zo doen :

List<String> number = Arrays.asList("1", "2", "3");
Out: ["1", "2", "3"]

Deze is vrij eenvoudig en duidelijk.


Antwoord 19

Een andere manier om ArrayList te declareren en te initialiseren:

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};

Antwoord 20

Er zijn hier veel antwoorden. Ik voeg een paar lastige manieren toe om arrays te maken (vanuit een examen oogpunt is het goed om dit te weten)

  1. Declareer en definieer een array

    int intArray[] = new int[3];
    

    Dit zal een array met lengte 3 creëren. Omdat het een primitief type bevat, int, zijn alle waarden standaard ingesteld op 0. Bijvoorbeeld,

    intArray[2]; // Will return 0
    
  2. Gebruik haakjes [] voor de variabelenaam

    int[] intArray = new int[3];
    intArray[0] = 1;  // Array content is now {1, 0, 0}
    
  3. Initialiseren en gegevens verstrekken aan de array

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

    Dit keer is het niet nodig om de maat te vermelden in de doosbeugel. Zelfs een simpele variant hiervan is:

    int[] intArray = {1, 2, 3, 4};
    
  4. Een array met lengte 0

    int[] intArray = new int[0];
    int length = intArray.length; // Will return length 0
    

    Vergelijkbaar met multidimensionale arrays

    int intArray[][] = new int[2][3];
    // This will create an array of length 2 and
    //each element contains another array of length 3.
    // { {0,0,0},{0,0,0} }
    int lenght1 = intArray.length; // Will return 2
    int length2 = intArray[0].length; // Will return 3
    

Bakhaken gebruiken voor de variabele:

    int[][] intArray = new int[2][3];

Het is absoluut prima als je één beugel aan het einde plaatst:

    int[] intArray [] = new int[2][4];
    int[] intArray[][] = new int[2][3][4]

Enkele voorbeelden

    int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
    int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
    int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}}
    // All the 3 arrays assignments are valid
    // Array looks like {{1,2,3},{4,5,6}}

Het is niet verplicht dat elk binnenelement even groot is.

    int [][] intArray = new int[2][];
    intArray[0] = {1,2,3};
    intArray[1] = {4,5};
    //array looks like {{1,2,3},{4,5}}
    int[][] intArray = new int[][2] ; // This won't compile. Keep this in mind.

Als u de bovenstaande syntaxis gebruikt, moet u ervoor zorgen dat de voorwaartse richting de waarden tussen vierkante haken specificeert. Anders compileert het niet. Enkele voorbeelden:

    int [][][] intArray = new int[1][][];
    int [][][] intArray = new int[1][2][];
    int [][][] intArray = new int[1][2][3];

Een ander belangrijk kenmerk is covariant

    Number[] numArray = {1,2,3,4};   // java.lang.Number
    numArray[0] = new Float(1.5f);   // java.lang.Float
    numArray[1] = new Integer(1);    // java.lang.Integer
   // You can store a subclass object in an array that is declared
   // to be of the type of its superclass.
   // Here 'Number' is the superclass for both Float and Integer.
   Number num[] = new Float[5]; // This is also valid

BELANGRIJK: voor typen waarnaar wordt verwezen, is de standaardwaarde die in de array is opgeslagen null.


Antwoord 21

Een array heeft twee basistypen.

Statische array: array met vaste grootte (de grootte moet aan het begin worden aangegeven en kan later niet worden gewijzigd)

Dynamic Array: hiervoor wordt geen groottelimiet overwogen. (Pure dynamische arrays bestaan ​​niet in Java. In plaats daarvan wordt List het meest aangemoedigd.)

Gebruik de onderstaande declaratie- en initialisatie-instructies om een ​​statische array van Integer, string, float, enz. te declareren.

int[] intArray = new int[10];
String[] intArray = new int[10];
float[] intArray = new int[10];
// Here you have 10 index starting from 0 to 9

Antwoord 22

Met lokale variabele type inferentie hoeft u het type maar één keer op te geven:

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

Of

int[] values = { 1, 2, 3 }

Antwoord 23

int[] x = new int[enter the size of array here];

Voorbeeld:

int[] x = new int[10];

Of

int[] x = {enter the elements of array here];

Voorbeeld:

int[] x = {10, 65, 40, 5, 48, 31};

Antwoord 24

Declare Array: int[] arr;

Array initialiseren: int[] arr = new int[10]; 10 staat voor het aantal toegestane elementen in de array

Declareer multidimensionale array: int[][] arr;

Initialiseer multidimensionale array: int[][] arr = new int[10][17]; 10 rijen en 17 kolommen en 170 elementen omdat 10 keer 17 170 is.

Het initialiseren van een array betekent het specificeren van de grootte ervan.


Antwoord 25

package com.examplehub.basics;
import java.util.Arrays;
public class Array {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        System.out.println("numbers[0] = " + numbers[0]);
        System.out.println("numbers[1] = " + numbers[1]);
        System.out.println("numbers[2] = " + numbers[2]);
        System.out.println("numbers[3] = " + numbers[3]);
        System.out.println("numbers[4] = " + numbers[4]);
        /*
         * Array index is out of bounds
         */
        //System.out.println(numbers[-1]);
        //System.out.println(numbers[5]);
        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        for (int i = 0; i < 5; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }
        /*
         * Length of numbers = 5
         */
        System.out.println("length of numbers = " + numbers.length);
        /*
         * numbers[0] = 1
         * numbers[1] = 2
         * numbers[2] = 3
         * numbers[3] = 4
         * numbers[4] = 5
         */
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }
        /*
         * numbers[4] = 5
         * numbers[3] = 4
         * numbers[2] = 3
         * numbers[1] = 2
         * numbers[0] = 1
         */
        for (int i = numbers.length - 1; i >= 0; i--) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }
        /*
         * 12345
         */
        for (int number : numbers) {
            System.out.print(number);
        }
        System.out.println();
        /*
         * [1, 2, 3, 4, 5]
         */
        System.out.println(Arrays.toString(numbers));
        String[] company = {"Google", "Facebook", "Amazon", "Microsoft"};
        /*
         * company[0] = Google
         * company[1] = Facebook
         * company[2] = Amazon
         * company[3] = Microsoft
         */
        for (int i = 0; i < company.length; i++) {
            System.out.println("company[" + i + "] = " + company[i]);
        }
        /*
         * Google
         * Facebook
         * Amazon
         * Microsoft
         */
        for (String c : company) {
            System.out.println(c);
        }
        /*
         * [Google, Facebook, Amazon, Microsoft]
         */
        System.out.println(Arrays.toString(company));
        int[][] twoDimensionalNumbers = {
                {1, 2, 3},
                {4, 5, 6, 7},
                {8, 9},
                {10, 11, 12, 13, 14, 15}
        };
        /*
         * total rows  = 4
         */
        System.out.println("total rows  = " + twoDimensionalNumbers.length);
        /*
         * row 0 length = 3
         * row 1 length = 4
         * row 2 length = 2
         * row 3 length = 6
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.println("row " + i + " length = " + twoDimensionalNumbers[i].length);
        }
        /*
         * row 0 = 1 2 3
         * row 1 = 4 5 6 7
         * row 2 = 8 9
         * row 3 = 10 11 12 13 14 15
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.print("row " + i + " = ");
            for (int j = 0; j < twoDimensionalNumbers[i].length; j++) {
                System.out.print(twoDimensionalNumbers[i][j] + " ");
            }
            System.out.println();
        }
        /*
         * row 0 = [1, 2, 3]
         * row 1 = [4, 5, 6, 7]
         * row 2 = [8, 9]
         * row 3 = [10, 11, 12, 13, 14, 15]
         */
        for (int i = 0; i < twoDimensionalNumbers.length; i++) {
            System.out.println("row " + i + " = " + Arrays.toString(twoDimensionalNumbers[i]));
        }
        /*
         * 1 2 3
         * 4 5 6 7
         * 8 9
         * 10 11 12 13 14 15
         */
        for (int[] ints : twoDimensionalNumbers) {
            for (int num : ints) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
        /*
         * [1, 2, 3]
         * [4, 5, 6, 7]
         * [8, 9]
         * [10, 11, 12, 13, 14, 15]
         */
        for (int[] ints : twoDimensionalNumbers) {
            System.out.println(Arrays.toString(ints));
        }
        int length = 5;
        int[] array = new int[length];
        for (int i = 0; i < 5; i++) {
            array[i] = i + 1;
        }
        /*
         * [1, 2, 3, 4, 5]
         */
        System.out.println(Arrays.toString(array));
    }
}

Bron van examplehub /java


Antwoord 26

Eén ander volledig voorbeeld met een filmles:

public class A {
    public static void main(String[] args) {
        class Movie {
            String movieName;
            String genre;
            String movieType;
            String year;
            String ageRating;
            String rating;
            public Movie(String [] str)
            {
                this.movieName = str[0];
                this.genre = str[1];
                this.movieType = str[2];
                this.year = str[3];
                this.ageRating = str[4];
                this.rating = str[5];
            }
        }
        String [] movieDetailArr = {"Inception", "Thriller", "MovieType", "2010", "13+", "10/10"};
        Movie mv = new Movie(movieDetailArr);
        System.out.println("Movie Name: "+ mv.movieName);
        System.out.println("Movie genre: "+ mv.genre);
        System.out.println("Movie type: "+ mv.movieType);
        System.out.println("Movie year: "+ mv.year);
        System.out.println("Movie age : "+ mv.ageRating);
        System.out.println("Movie  rating: "+ mv.rating);
    }
}

Antwoord 27

Een array kan zowel primitieven datatypes als objecten van een klasse bevatten, afhankelijk van de definitie van de array. In het geval van primitieven datatypes worden de werkelijke waarden opgeslagen in aaneengesloten geheugenlocaties. In het geval van objecten van een klasse, worden de werkelijke objecten opgeslagen in het heapsegment.

Eendimensionale arrays:

De algemene vorm van een eendimensionale arraydeclaratie is

type var-name[];
OR
type[] var-name;

Een array in Java maken

var-name = new type [size];

Bijvoorbeeld

int intArray[];  // Declaring an array
intArray = new int[20];  // Allocating memory to the array
// The below line is equal to line1 + line2
int[] intArray = new int[20]; // Combining both statements in one
int[] intArray = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// Accessing the elements of the specified array
for (int i = 0; i < intArray.length; i++)
    System.out.println("Element at index " + i + ": "+ intArray[i]);

Ref: Arrays in Java


Antwoord 28

Het is heel eenvoudig om een ​​array te declareren en te initialiseren.
U wilt bijvoorbeeld vijf integer-elementen die 1, 2, 3, 4 en 5 zijn, in een array opslaan. Je kunt het op de volgende manier doen:

a)

int[] a = new int[5];

of

b)

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

dus het basispatroon is voor initialisatie en declaratie volgens methode a) is:

datatype[] arrayname = new datatype[requiredarraysize];

datatype moet in kleine letters zijn.

Dus het basispatroon is voor initialisatie en declaratie met methode a is:

Als het een stringarray is:

String[] a = {"as", "asd", "ssd"};

Als het een tekenreeks is:

char[] a = {'a', 's', 'w'};

Voor float double is het formaat van array hetzelfde als integer.

Bijvoorbeeld:

double[] a = {1.2, 1.3, 12.3};

maar als je de array declareert en initialiseert met “methode a” moet je de waarden handmatig of via een lus of zoiets invoeren.

Maar als u dit doet met “methode b”, hoeft u de waarden niet handmatig in te voeren.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes