Come posso dichiarare e inizializzare un array in Java?


2055

Come posso dichiarare e inizializzare un array in Java?


4
Prima di pubblicare una nuova risposta, considera che ci sono già più di 25 risposte per questa domanda. Assicurati che la tua risposta fornisca informazioni che non sono tra le risposte esistenti.
Janniks,

Risposte:


2684

È possibile utilizzare la dichiarazione di matrice o il valore letterale di matrice (ma solo quando si dichiara e si influenza la variabile immediatamente, i valori letterali di matrice non possono essere utilizzati per riassegnare una matrice).

Per i tipi primitivi:

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 

Per le classi, ad esempio String, è lo stesso:

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

Il terzo modo di inizializzare è utile quando si dichiara prima l'array e poi lo si inizializza. Il cast è necessario qui.

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

33
Qual è lo scopo di avere sia il secondo che il terzo modo di farlo?
Quazi Irfan,

123
@iamcreasy Sembra che il secondo modo non funzioni con le dichiarazioni di reso. return {1,2,3}dà un errore, mentre return new int[]{1,2,3}funziona benissimo (presupponendo ovviamente che la tua funzione restituisca un array intero).
Skylar Ittner,

1
@SkylarMT Ma possiamo ancora usare il primo modo di utilizzare con la dichiarazione di ritorno.
Quazi Irfan,

6
@iamcreasy Di recente ho scritto una funzione che ha restituito una matrice di ints. Se si verificava un errore all'interno della funzione, volevo che restituisse un certo valore, ma la funzione doveva restituire un array. In che modo funziona per una dichiarazione di ritorno di una riga? Solo il terzo.
Skylar Ittner,

5
@apadana Nel secondo caso si sta creando un oggetto anonimo che è definito solo nell'ambito compreso (funzione o altro). Dopo averlo restituito al chiamante, non è più valido. Utilizzando la nuova parola chiave, si assegna il nuovo oggetto dall'heap ed è valido al di fuori dell'ambito di definizione.
teukkam,

280

Esistono due tipi di array.

Matrice unidimensionale

Sintassi per i valori predefiniti:

int[] num = new int[5];

O (meno preferito)

int num[] = new int[5];

Sintassi con i valori indicati (inizializzazione variabile / campo):

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

O (meno preferito)

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

Nota: per comodità int [] num è preferibile perché indica chiaramente che stai parlando di array. Altrimenti nessuna differenza. Affatto.

Matrice multidimensionale

Dichiarazione

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

O

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

O

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

Inizializzazione

 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;

O

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

Array irregolare (o array non rettangolare)

 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];

Quindi qui stiamo definendo le colonne in modo esplicito.
Un altro modo:

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

Per accedere:

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

In alternativa:

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

Gli array irregolari sono array multidimensionali.
Per una spiegazione, consultare i dettagli dell'array multidimensionale nei tutorial java ufficiali


Il primo non porterà a un array nullo / vuoto, invece di un array con valori predefiniti?
vipin8169,

Sono d'accordo su questo punto e possiamo aggiungere un'altra funzionalità, possiamo modificare le dimensioni in modo dinamico.
AdamIJK,

Potrei discutere con te sul punto che un array multidimensionale è un "tipo" di array diverso. È semplicemente un termine usato per descrivere un array che contiene altri array. Sia gli array esterni che quelli interni (e quelli intermedi, se esistono) sono solo array regolari.
Tim M.

127
Type[] variableName = new Type[capacity];

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



Type variableName[] = new Type[capacity]; 

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

è anche valido, ma preferisco le parentesi dopo il tipo, perché è più facile vedere che il tipo della variabile è in realtà un array.


22
Sono d'accordo su questo punto. Il tipo di variabile non è "TYPE", ma in realtà un TYPE [], quindi ha senso scriverlo in quel modo per me.
Chet,

3
Lo stile di Google suggerisce anche questo.
Wener

11
Si noti che int[] a, b;non sarà lo stesso int a[], b;, un errore facile da fare se si utilizza quest'ultimo modulo.
Jeroen Vannevel,

39

Esistono vari modi in cui è possibile dichiarare un array in Java:

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

Ulteriori informazioni sono disponibili nel sito del tutorial Sun e in JavaDoc .


31

Trovo che sia utile se capisci ogni parte:

Type[] name = new Type[5];

Type[]è il tipo della variabile chiamata name ("name" è chiamato identificatore ). Il "Tipo" letterale è il tipo di base e le parentesi indicano che questo è il tipo di array di quella base. I tipi di array sono a loro volta tipi propri, che consente di creare array multidimensionali come Type[][](il tipo di array di Tipo []). La parola chiave newdice di allocare memoria per il nuovo array. Il numero tra parentesi indica la dimensione del nuovo array e la quantità di memoria da allocare. Ad esempio, se Java sa che il tipo di base Typerichiede 32 byte e si desidera un array di dimensioni 5, è necessario allocare internamente 32 * 5 = 160 byte.

È inoltre possibile creare matrici con i valori già presenti, ad esempio

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

che non solo crea lo spazio vuoto ma lo riempie di quei valori. Java può dire che le primitive sono numeri interi e che ce ne sono 5, quindi la dimensione dell'array può essere determinata implicitamente.


Quindi non è necessario includere int[] name = new int[5]?
Cookie Monster

31

Quanto segue mostra la dichiarazione di un array, ma l'array non è inizializzato:

 int[] myIntArray = new int[3];

Quanto segue mostra la dichiarazione e l'inizializzazione dell'array:

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

Ora, quanto segue mostra anche la dichiarazione e l'inizializzazione dell'array:

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

Ma questo terzo mostra la proprietà della creazione anonima di oggetti array che è indicata da una variabile di riferimento "myIntArray", quindi se scriviamo solo "new int [] {1,2,3};" allora è così che può essere creato un oggetto array anonimo.

Se scriviamo solo:

int[] myIntArray;

questa non è una dichiarazione di array, ma la seguente dichiarazione rende completa la dichiarazione di cui sopra:

myIntArray=new int[3];

2
Non c'è assolutamente alcuna differenza tra il secondo e il terzo approccio, a parte il fatto che il secondo approccio funziona solo quando si dichiara anche una variabile. Non è chiaro cosa intendi con "mostra la proprietà della creazione anonima di oggetti array", ma in realtà sono equivalenti parti di codice.
Jon Skeet,

4
Inoltre, il primo pezzo fa inizializzare l'array - è garantito per avere il valore 0 per ogni elemento dell'array.
Jon Skeet,

Non c'è davvero alcuna differenza tra il secondo e il terzo approccio?
truthadjustr,

27

In alternativa,

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

Questo dichiara un array chiamato arrayNamedi dimensione 10 (hai elementi da 0 a 9 da usare).


7
Qual è lo standard per cui utilizzare? Ho appena scoperto il primo, e lo trovo terribilmente fuorviante: |
Anti Earth,

2
Per quello che vale il mio prof ha detto che il secondo modo è più tipico in Java e che trasmette meglio ciò che sta succedendo; come matrice correlata al tipo in cui è stata lanciata la variabile.
Celeritas,

2
Per una nota a margine: una lingua che ha più di una semantica per dichiarare una cosa che significa cattiva progettazione del linguaggio.
Muhammad Suleman,

26

Inoltre, se desideri qualcosa di più dinamico, c'è l'interfaccia Elenco. Anche questo non funzionerà, ma è più flessibile:

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

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

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

2
come si chiama "<>" nell'elenco che hai creato?
CyprUS,

@CyprUS Listè una classe generica, ha un tipo come parametro, racchiuso in <>. Ciò aiuta perché è necessario definire un tipo generico una sola volta e quindi è possibile utilizzarlo con più tipi diversi. Per una spiegazione più dettagliata, consultare docs.oracle.com/javase/tutorial/java/generics/types.html
Heimdall,

15

Esistono due modi principali per creare un array:

Questo, per un array vuoto:

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

E questo, per un array inizializzato:

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

Puoi anche creare array multidimensionali, in questo modo:

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

11

Prendi intad esempio il tipo primitivo . Esistono diversi modi per dichiarare e intarray:

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

dove in tutti questi, è possibile utilizzare int i[]invece di int[] i.

Con la riflessione, puoi usare (Type[]) Array.newInstance(Type.class, capacity);

Si noti che nei parametri del metodo, ...indica variable arguments. In sostanza, qualsiasi numero di parametri va bene. È più facile da spiegare con il codice:

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

All'interno del metodo, varargsviene trattato come un normale int[]. Type...può essere utilizzato solo nei parametri del metodo, quindi int... i = new int[] {}non verrà compilato.

Si noti che quando si passa int[]a un metodo (o qualsiasi altro Type[]), non è possibile utilizzare la terza via. Nell'istruzione int[] i = *{a, b, c, d, etc}*, il compilatore presuppone che il {...}mezzo un int[]. Ma questo è perché stai dichiarando una variabile. Quando si passa un array a un metodo, la dichiarazione deve essere new Type[capacity]o new Type[] {...}.

Matrici multidimensionali

Le matrici multidimensionali sono molto più difficili da gestire. In sostanza, un array 2D è un array di array. int[][]indica una matrice di int[]s. La chiave è che se un int[][]viene dichiarato come int[x][y], l'indice massimo è i[x-1][y-1]. In sostanza, un rettangolare 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]


9

Se vuoi creare array usando i riflessi, puoi fare così:

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

Perché vorresti creare un array in quel modo?
Dorian Gray,

9

Dichiarazione di una matrice di riferimenti a oggetti:

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

7

La matrice è un elenco sequenziale di elementi

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

Se è un oggetto, allora è lo stesso concetto

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() }
};

Nel caso di oggetti, è necessario assegnarli a nullper inizializzarli utilizzando new Type(..), classi come Stringe Integersono casi speciali che verranno gestiti come segue

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

In generale è possibile creare array Mdimensionali

int [][]..[] array =
//  ^ M times [] brackets

    {{..{
//  ^ M times { bracket

//            this is array[0][0]..[0]
//                         ^ M times [0]

    }}..}
//  ^ M times } bracket
;

Vale la pena notare che la creazione di un Marray dimensionale è costosa in termini di spazio. Da quando si crea una Mmatrice dimensionale con Nsu tutte le dimensioni, La dimensione totale della matrice è maggiore di N^M, poiché ogni matrice ha un riferimento e nella dimensione M c'è una matrice di riferimenti (M-1). La dimensione totale è la seguente

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

7

In Java 8 puoi usare così.

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

6

Per creare matrici di oggetti Class è possibile utilizzare il java.util.ArrayList. per definire un array:

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

Assegna valori all'array:

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

Leggi dall'array:

ClassName variableName = arrayName.get(index);

Nota:

variableNameè un riferimento all'array che significa che manipolando variableNamemanipoleràarrayName

per i loop:

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

per loop che ti permette di modificare arrayName(convenzionale per loop):

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

5

Dichiarare e inizializzare per Java 8 e versioni successive. Crea un semplice array intero:

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]

Crea un array casuale per numeri interi tra [-50, 50] e per i doppi [0, 1E17]:

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

Sequenza di potenza di due:

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]

Per String [] è necessario specificare un costruttore:

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

Matrici multidimensionali:

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]]

-50 e / o +50 sono effettivamente inclusi? Cioè, l'interno è aperto a una o entrambe le estremità?
Peter Mortensen,

1
-50 è incluso e +50 è escluso. Queste informazioni da java api "data origine (compreso) e rilegato (esclusivo)". Uso la dichiarazione di intervallo dal wiki . Quindi penso che sarà più corretto [-50, 50)
Kirill Podlivaev

3

Un altro modo per dichiarare e inizializzare ArrayList:

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

2

Ci sono molte risposte qui. Sto aggiungendo alcuni modi complicati per creare array (dal punto di vista dell'esame è bene saperlo)

  1. Dichiarare e definire un array

    int intArray[] = new int[3];

    Ciò creerà una matrice di lunghezza 3. Poiché contiene un tipo primitivo, int, tutti i valori sono impostati su 0 per impostazione predefinita. Per esempio,

    intArray[2]; // Will return 0
  2. Utilizzo delle parentesi quadre [] prima del nome della variabile

    int[] intArray = new int[3];
    intArray[0] = 1;  // Array content is now {1, 0, 0}
  3. Inizializzare e fornire dati all'array

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

    Questa volta non è necessario menzionare le dimensioni nella staffa della scatola. Anche una semplice variante di questo è:

    int[] intArray = {1, 2, 3, 4};
  4. Una matrice di lunghezza 0

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

    Simile per array multidimensionali

    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

Usando le parentesi quadre prima della variabile:

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

Va assolutamente bene se si mette una staffa scatola alla fine:

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

Qualche esempio

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

Non è obbligatorio che ogni elemento interno abbia le stesse dimensioni.

    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.

Devi assicurarti che se stai usando la sintassi sopra, che la direzione in avanti devi specificare i valori tra parentesi quadre. Altrimenti non si compila. Qualche esempio:

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

Un'altra caratteristica importante è la covariante

    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

IMPORTANTE: per i tipi di riferimento, il valore predefinito memorizzato nell'array è null.


2

Puoi anche farlo con java.util.Arrays:

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

Out: ["1", "2", "3"]

Questo è piuttosto semplice e diretto.


Non l'ho visto in altre risposte, quindi ho pensato di poterlo aggiungere.
Sylhare,

1
Un elenco non è un array
Tirno

A volte le persone significano array, quando vogliono un elenco.
Sylhare


1

La matrice ha due tipi di base.

Matrice statica: matrice di dimensioni fisse (la sua dimensione deve essere dichiarata all'inizio e non può essere modificata in seguito)

Matrice dinamica: per questo non viene preso in considerazione alcun limite di dimensione. (In Java non esistono array dinamici puri. Invece, List è più incoraggiato)

Per dichiarare un array statico di Integer, string, float, ecc ... usa la dichiarazione qui sotto e le dichiarazioni di inizializzazione.

    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

Per utilizzare le funzionalità dinamiche, devi utilizzare Elenco ... L'elenco è puro array dinamico e non è necessario dichiarare la dimensione all'inizio. Bellow è il modo corretto di dichiarare un elenco in JAVA>

        ArrayList<String> myArray = new ArrayList<String>();
        myArray.add("Value 1: something");
        myArray.add("Value 2: something more");


1
Grazie @Matheus per aver migliorato le mie risposte. Ti chiederei di votare questo, in modo che questo possa raggiungere più utenti.
Zia Muhammad,

0

Dichiara array: int[] arr;

Inizializza matrice: int[] arr = new int[10];10 rappresenta il numero di elementi consentiti nella matrice

Dichiarare matrice multidimensionale: int[][] arr;

Inizializza matrice multidimensionale: int[][] arr = new int[10][17];10 righe e 17 colonne e 170 elementi perché 10 volte 17 è 170.

Inizializzare un array significa specificare le dimensioni di esso.


0

È molto semplice dichiarare e inizializzare un array. Ad esempio, si desidera salvare cinque elementi interi che sono 1, 2, 3, 4 e 5 in un array. Puoi farlo nel modo seguente:

un)

int[] a = new int[5];

o

b)

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

quindi il modello di base è per l'inizializzazione e la dichiarazione con il metodo a) è:

datatype[] arrayname = new datatype[requiredarraysize];

datatype dovrebbe essere in minuscolo.

Quindi il modello di base è per l'inizializzazione e la dichiarazione con il metodo a è:

Se è un array di stringhe:

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

Se è una matrice di caratteri:

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

Per float double, il formato dell'array sarà uguale all'intero.

Per esempio:

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

ma quando dichiari e inizializzi l'array con "metodo a" dovrai inserire i valori manualmente o tramite loop o qualcosa del genere.

Ma quando lo fai con il "metodo b" non dovrai inserire i valori manualmente.


0

La matrice può contenere tipi di dati di primitive e oggetti di una classe a seconda della definizione di matrice. Nel caso di tipi di dati di primitive, i valori effettivi vengono memorizzati in posizioni di memoria contigue. Nel caso di oggetti di una classe, gli oggetti effettivi vengono memorizzati nel segmento di heap.


Matrici unidimensionali:
la forma generale di una dichiarazione di matrice unidimensionale è

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

Creare un'istanza di una matrice in Java

var-name = new type [size];

Per esempio

    int intArray[];    //declaring array
    intArray = new int[20];  // allocating memory to array
    // the below line is equals 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]);

Rif: https://www.geeksforgeeks.org/arrays-in-java/


0

l'altro esempio completo con classe di film 😋

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);


            }

        } 

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

esempio:

int[] x=new int[10];

o

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

esempio:

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

-7
int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]

6
Sebbene questo codice possa rispondere alla domanda, sarebbe meglio spiegare come risolve il problema senza introdurre altri e perché utilizzarlo. Le risposte di solo codice non sono utili a lungo termine.
Bono,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.