valori - string array java




Come posso dichiarare e inizializzare un array in Java? (14)

In Java 9

Utilizzando diversi metodi IntStream.iterate e IntStream.takeWhile :

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

Utilizzo dell'inferenza di tipo variabile locale :

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

Come posso dichiarare e inizializzare un array in Java?


È possibile utilizzare la dichiarazione di matrice o il letterale di matrice (ma solo quando si dichiara e si influisce subito sulla variabile, non è possibile utilizzare valori letterali di matrice 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};

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 dichiari prima la matrice e poi la inizializzi. Il cast è necessario qui.

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

Ci sono due tipi di array.

Una matrice dimensionale

Sintassi per i valori predefiniti:

int[] num = new int[5];

O (meno preferito)

int num[] = new int[5];

Sintassi con i valori forniti (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.

Array 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 Ragged (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 esplicitamente.
Un altro modo:

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

Per l'accesso:

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 frastagliati sono array multidimensionali.
Per spiegazioni, consultare il dettaglio della matrice multidimensionale nelle esercitazioni ufficiali di java


Con l'inferenza del tipo di variabile locale devi solo specificare il tipo una volta:

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

o

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

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

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, come questo:

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

In Java 8 puoi usare così.

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

In alternativa,

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

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


Per creare matrici di oggetti di classe è possibile utilizzare 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 la manipolazione di variableName manipolerà arrayName

per loops:

//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 consente di modificare arrayName (convenzionale per loop):

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

Prendi il tipo primitivo int per esempio. Esistono diversi modi per dichiarare e int array:

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

dove in tutti questi, puoi usare int i[] invece di int[] i .

Con la reflection, 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, varargs è 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 un int[] a un metodo (o qualsiasi altro Type[] ), non è possibile utilizzare la terza via. Nella dichiarazione int[] i = *{a, b, c, d, etc}* , il compilatore assume che {...} significhi un int[] . Ma questo è perché stai dichiarando una variabile. Quando si passa una matrice a un metodo, la dichiarazione deve essere new Type[capacity] o new Type[] {...} .

Array multidimensionali

Gli array multidimensionali sono molto più difficili da gestire. Essenzialmente, un array 2D è una matrice di array. int[][] significa una matrice di int[] s. La chiave è che se un int[][] è dichiarato come int[x][y] , l'indice massimo è i[x-1][y-1] . Essenzialmente, un int[3][5] 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]

Se vuoi creare array usando riflessioni, puoi fare così:

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

Trovo che sia utile se capisci ogni parte:

Type[] name = new Type[5];

Type[] è il tipo della variabile denominata nome ("nome" è chiamato identificatore ). Il "Tipo" letterale è il tipo di base e le parentesi indicano che questo è il tipo di matrice di quella base. I tipi di array sono a loro volta tipi diversi, il che consente di creare matrici multidimensionali come Type[][] (il tipo di matrice Tipo []). La parola chiave new dice di allocare memoria per il nuovo array. Il numero tra la staffa indica quanto grande sarà il nuovo array e quanta memoria allocare. Ad esempio, se Java sa che il tipo di base Type richiede 32 byte e si desidera una matrice di dimensione 5, è necessario allocare internamente 32 * 5 = 160 byte.

Puoi anche creare array con i valori già presenti, come 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 i primitivi sono numeri interi e che ce ne sono 5, quindi la dimensione dell'array può essere determinata implicitamente.


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à una matrice.


int[] SingleDimensionalArray = new int[2]

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




declare