Wie deklariere und initialisiere ich ein Array in Java?

Es gibt zwei Arten von Arrays.

Eindimensionales Array

Syntax für Standardwerte:

int[] num = new int[5];

Oder (weniger bevorzugt)

int num[] = new int[5];

Syntax mit angegebenen Werten (Variablen-/Feldinitialisierung):

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

Oder (weniger bevorzugt)

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

Hinweis: Der Einfachheit halber ist int [] num vorzuziehen, da hier eindeutig angegeben ist, dass es sich um ein Array handelt. Ansonsten kein Unterschied. Überhaupt nicht.

Mehrdimensionales Array

Erklärung

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

Oder

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

Oder

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

Initialisierung

 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;

Oder

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

Ragged Array (oder nicht rechteckiges 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];

Also definieren wir hier explizit Spalten.
Ein anderer Weg:

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

Für den Zugriff auf:

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

Alternative:

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

Ragged Arrays sind mehrdimensionale Arrays.
Erläuterungen finden Sie im Abschnitt zu mehrdimensionalen Arrays unter die offiziellen Java Tutorials

Type[] variableName = new Type[capacity];

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



Type variableName[] = new Type[capacity]; 

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

ist auch gültig, aber ich bevorzuge die Klammern nach dem Typ, weil es einfacher ist zu sehen, dass der Variablentyp tatsächlich ein Array ist.

Es gibt verschiedene Möglichkeiten, ein Array in Java zu deklarieren:

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

Weitere Informationen finden Sie auf der Site Sun Tutorial und in JavaDoc .

Das Folgende zeigt die Deklaration eines Arrays, aber das Array ist nicht initialisiert:

 int[] myIntArray = new int[3];

Das Folgende zeigt die Deklaration sowie die Initialisierung des Arrays:

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

Das Folgende zeigt nun auch die Deklaration sowie die Initialisierung des Arrays:

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

Aber diese dritte zeigt die Eigenschaft der Erzeugung anonymer Array-Objekte, auf die eine Referenzvariable "myIntArray" verweist. Wenn wir also nur "new int [] {1,2,3};" dann kann auf diese Weise ein anonymes Array-Objekt erzeugt werden.

Wenn wir nur schreiben:

int[] myIntArray;

dies ist keine Array-Deklaration, aber die folgende Anweisung vervollständigt die obige Deklaration:

myIntArray=new int[3];

Ich finde es hilfreich, wenn Sie jeden Teil verstehen:

Type[] name = new Type[5];

Type[] ist der Typ der Variable gerufenen Bezeichnung ("Name" heißt Bezeichner). Das Literal "Type" ist der Basistyp, und die Klammern bedeuten, dass dies der Array-Typ dieser Basis ist. Array-Typen sind wiederum eigene Typen, sodass Sie mehrdimensionale Arrays wie Type[][] (den Array-Typ von Type []) erstellen können. Das Schlüsselwort new gibt an, dass dem neuen Array Speicher zugewiesen werden soll. Die Zahl in der Klammer gibt an, wie groß das neue Array sein wird und wie viel Speicher zugewiesen werden soll. Wenn beispielsweise Java weiß, dass der Basistyp Type 32 Byte belegt und Sie ein Array der Größe 5 wünschen, muss er intern 32 * 5 = 160 Byte zuweisen.

Sie können auch Arrays mit den bereits vorhandenen Werten erstellen, z

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

das schafft nicht nur den leeren Raum, sondern füllt ihn mit diesen Werten. Java kann erkennen, dass es sich bei den Primitiven um Ganzzahlen handelt und dass es 5 davon gibt, sodass die Größe des Arrays implizit bestimmt werden kann.

Alternative,

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

Das deklariert ein Array mit dem Namen arrayName der Größe 10 (Sie müssen die Elemente 0 bis 9 verwenden).

Für den Fall, dass Sie etwas Dynamischeres wünschen, gibt es die List-Oberfläche. Dies funktioniert nicht so gut, ist aber flexibler:

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

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

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

Es gibt zwei Möglichkeiten, ein Array zu erstellen:

Diese für ein leeres Array:

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

Und dies für ein initialisiertes Array:

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

Sie können auch mehrdimensionale Arrays erstellen:

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

Nehmen wir zum Beispiel den primitiven Typ int. Es gibt verschiedene Möglichkeiten, das Array und int zu deklarieren:

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

in all diesen Fällen können Sie int i[] anstelle von int[] i verwenden.

Mit Reflection können Sie (Type[]) Array.newInstance(Type.class, capacity); verwenden.

Beachten Sie, dass in Methodenparametern ...variable arguments angibt. Im Wesentlichen ist eine beliebige Anzahl von Parametern in Ordnung. Mit Code ist es einfacher zu erklären:

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

Innerhalb der Methode wird varargs als normaler int[] behandelt. Type... kann nur in Methodenparametern verwendet werden, daher wird int... i = new int[] {} nicht kompiliert.

Beachten Sie, dass Sie den dritten Weg nicht verwenden können, wenn Sie einen int[] an eine Methode (oder einen anderen Type[]) übergeben. In der Anweisung int[] i = *{a, b, c, d, etc}* geht der Compiler davon aus, dass {...} ein int[] bedeutet. Das liegt aber daran, dass Sie eine Variable deklarieren. Wenn Sie ein Array an eine Methode übergeben, muss die Deklaration entweder new Type[capacity] oder new Type[] {...} lauten.

Mehrdimensionale Arrays

Mehrdimensionale Arrays sind viel schwieriger zu behandeln. Ein 2D-Array ist im Wesentlichen ein Array von Arrays. int[][] bedeutet ein Array von int[]s. Der Schlüssel ist, dass, wenn ein int[][] als int[x][y] deklariert wird, der maximale Index i[x-1][y-1] ist. Im Wesentlichen ist ein rechteckiger 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]

Wenn Sie Arrays mit Reflexionen erstellen möchten, können Sie dies folgendermaßen tun:

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

In Java 9

Mit verschiedenen IntStream.iterate und 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

Verwenden der Inferenz lokaler Variablentypen :

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

Deklarieren eines Arrays von Objektreferenzen:

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

In Java 8 können Sie dies verwenden.

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

Array ist eine sequentielle Liste von Elementen

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

Wenn es ein Objekt ist, dann ist es dasselbe Konzept

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

Objekte müssen entweder null zugewiesen werden, um sie mit new Type(..) zu initialisieren. Klassen wie String und Integer sind Sonderfälle, die wie folgt behandelt werden

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

Im Allgemeinen können Sie Arrays erstellen, die M dimensional sind

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

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

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

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

Es ist erwähnenswert, dass das Erstellen eines M dimensionalen Arrays räumlich teuer ist. Seitdem Sie ein M dimensionales Array mit N für alle Dimensionen erstellen, ist die Gesamtgröße des Arrays größer als N^M, da jedes Array einen Verweis hat. dimension gibt es ein (M-1) -dimensionales Array von Referenzen. Die Gesamtgröße ist wie folgt

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

Zum Erstellen von Arrays von Klassenobjekten können Sie den Java.util.ArrayList verwenden. So definieren Sie ein Array:

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

Weisen Sie dem Array Werte zu:

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

Lesen Sie aus dem Array:

ClassName variableName = arrayName.get(index);

Hinweis:

variableName ist eine Referenz auf das Array, was bedeutet, dass die Manipulation von variableName die Manipulation von arrayName bewirkt.

für Schleifen:

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

for-Schleife, mit der Sie arrayName bearbeiten können (konventionelle for-Schleife):

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

Deklarieren und initialisieren Sie für Java 8 und höher. Erstellen Sie ein einfaches 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]

Erstellen Sie ein zufälliges Array für ganze Zahlen zwischen [-50, 50] und für doppelte Zahlen [0, 1E17]:

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

Potenz-Zwei-Sequenz:

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]

Für String [] müssen Sie einen Konstruktor angeben:

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

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

Du kannst es auch mit Java.util.Arrays machen:

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

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

Dieser ist hübsch einfach und unkompliziert. Ich habe es in anderen Antworten nicht gesehen, also dachte ich, ich könnte es hinzufügen.

Eine andere Möglichkeit, ArrayList zu deklarieren und zu initialisieren:

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

Viele Antworten hier. Hinzufügen einiger kniffliger Methoden zum Erstellen von Arrays (Aus Sicht von Prüfung ist es gut, dies zu wissen)

1. deklarieren und definieren Sie ein Array

   int intArray[] = new int[3];
   

dadurch wird ein Array der Länge 3 erstellt. Da es den primitiven Typ int enthält, werden alle Werte standardmäßig auf 0 gesetzt. Zum Beispiel

    intArray[2]; // will return 0

2. Verwenden Sie Klammern [] vor dem Variablennamen

   int[] intArray = new int[3];
   intArray[0] = 1;  // array content now {1,0,0}
   

3. Initialisieren Sie das Array und stellen Sie die Daten bereit

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

   diesmal brauchen Sie die Größe in der Kastenhalterung nicht zu erwähnen. Auch eine einfache Variante davon ist

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

4. Ein Array der Länge 0

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

   Ähnlich für mehrdimensionale 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
   

   Verwenden von Klammern vor der Variablen

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

   es ist absolut in Ordnung, wenn Sie eine Kastenhalterung am Ende setzen

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

Einige Beispiele

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

Es ist nicht zwingend erforderlich, dass jedes innere Element dieselbe Größe hat.

    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.

Sie müssen sicherstellen, dass bei Verwendung der obigen Syntax in Vorwärtsrichtung die Werte in Klammern angegeben werden. Andernfalls wird die Kompilierung nicht durchgeführt. Einige Beispiele :

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

Ein weiteres wichtiges Merkmal ist Kovariante

    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

IMP: Für referenzierte Typen ist der im Array gespeicherte Standardwert null.

Bei der Inferenz lokaler Variablentypen müssen Sie den Typ nur einmal angeben:

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

oder

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

Array deklarieren: int[] arr;

Array initialisieren: int[] arr = new int[10]; 10 steht für die Anzahl der Elemente, die im Array zulässig sind

Deklariere mehrdimensionales Array: int[][] arr;

Mehrdimensionales Array initialisieren: int[][] arr = new int[10][17]; 10 Zeilen und 17 Spalten und 170 Elemente, da 10 mal 17 170 ist.

Beim Initialisieren eines Arrays muss dessen Größe angegeben werden.

Es ist sehr einfach, ein Array zu deklarieren und zu initialisieren. Sie möchten beispielsweise 5 ganzzahlige Elemente, die 1,2,3,4,5 sind, in einem Array speichern, damit Sie dies folgendermaßen tun können:

ein)

int[] a =new int[5];

oder b)

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

das Grundmuster für die Initialisierung und Deklaration nach Methode a lautet also:

datatype[] arrayname = new datatype[requiredarraysize];

der Datentyp sollte in Kleinbuchstaben angegeben werden. Das Grundmuster ist also für die Initialisierung und Deklaration durch Methode a: Wenn es sich um ein String-Array handelt:

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

wenn es sich um ein Zeichen-Array handelt:

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

für float double ist das Format des Arrays dasselbe wie für integer. zum Beispiel:

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

wenn Sie das Array jedoch mit "Methode a" deklarieren und initialisieren, müssen Sie die Werte manuell oder über eine Schleife oder Ähnliches eingeben. Wenn Sie dies jedoch mit "Methode b" tun, müssen Sie die Werte nicht manuell eingeben.