Wie deklariere und initialisiere ich ein Array in Java?

Sie können entweder die Array-Deklaration oder das Array-Literal verwenden (aber nur, wenn Sie die Variable sofort deklarieren und beeinflussen, können Array-Literale nicht zum erneuten Zuweisen eines Arrays verwendet werden).

Für primitive 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 

Für Klassen ist es zum Beispiel Stringdasselbe:

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

Die dritte Art der Initialisierung ist nützlich, wenn Sie das Array zuerst deklarieren und dann initialisieren. Die Besetzung ist hier notwendig.

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

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 deutlich wird, dass es sich hier um ein Array handelt. Ansonsten kein Unterschied. Ganz und gar 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];

Hier definieren wir Spalten explizit.
Ein anderer Weg:

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

Für den Zugriff:

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 in den offiziellen Java-Tutorials unter Details zu mehrdimensionalen Arrays

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, da es einfacher ist zu erkennen, dass der Typ der Variablen 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 Sun-Tutorial- Site und im JavaDoc .

Ich finde es hilfreich, wenn Sie jeden Teil verstehen:

Type[] name = new Type[5];

Type[]ist die Art der Variable namens Namen ( „name“ genannt wird Kennung ). Das Literal "Typ" ist der Basistyp, und die Klammern bedeuten, dass dies der Array-Typ dieser Basis ist. Array-Typen sind wiederum eigene Typen, mit denen Sie mehrdimensionale Arrays wie Type[][](den Array-Typ von Type []) erstellen können. Das Schlüsselwort newbesagt, dass Speicher für das neue Array 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 Java beispielsweise weiß, dass der Basistyp Type32 Byte benötigt und Sie ein Array der Größe 5 möchten, muss es 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 die Grundelemente Ganzzahlen sind und dass es 5 davon gibt, sodass die Größe des Arrays implizit bestimmt werden kann.

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 dieses dritte zeigt die Eigenschaft der anonymen Array-Objekterstellung, auf die eine Referenzvariable "myIntArray" zeigt. Wenn wir also nur "new int [] {1,2,3}" schreiben; dann kann auf diese Weise ein anonymes Array-Objekt erstellt werden.

Wenn wir nur schreiben:

int[] myIntArray;

Dies ist keine Deklaration des Arrays, aber die folgende Anweisung vervollständigt die obige Deklaration:

myIntArray=new int[3];

Alternative,

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

Das deklariert ein Array mit arrayNameder 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:

Dieser für ein leeres Array:

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

Und dieses für ein initialisiertes Array:

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

Sie können auch mehrdimensionale Arrays wie folgt erstellen:

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

Nehmen Sie intzum Beispiel den primitiven Typ . Es gibt verschiedene Möglichkeiten zum Deklarieren und intArrangieren:

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

wo in all diesen können Sie int i[]anstelle von verwenden int[] i.

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

Beachten Sie, dass in Methodenparametern ...angibt variable arguments. 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 varargswird als normal behandelt int[]. Type...kann nur in Methodenparametern verwendet werden, int... i = new int[] {}wird also nicht kompiliert.

Beachten Sie, dass Sie beim Übergeben von int[]an eine Methode (oder eine andere Type[]) nicht den dritten Weg verwenden können. In der Anweisung int[] i = *{a, b, c, d, etc}*geht der Compiler davon aus, dass das {...}bedeutet an int[]. 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 sein new Type[] {...}.

Mehrdimensionale Arrays

Mehrdimensionale Arrays sind viel schwieriger zu handhaben. Im Wesentlichen ist ein 2D-Array ein Array von Arrays. int[][]bedeutet ein Array von int[]s. Der Schlüssel ist, dass wenn ein int[][]als deklariert ist int[x][y], der maximale Index ist i[x-1][y-1]. Ein Rechteck int[3][5]ist im Wesentlichen :

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

In Java 9

Mit verschiedenen IntStream.iterateund IntStream.takeWhileMethoden:

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 des lokalen Variablentyps :

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

Wenn Sie Arrays mit Reflexionen erstellen möchten, können Sie Folgendes tun:

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

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

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

Bei Objekten müssen Sie sie entweder zuweisen null, um sie mit new Type(..)Klassen wie Stringund zu initialisieren. Dies Integersind 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 Mdimensional 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 Mdimensionalen Arrays räumlich teuer ist. Wenn Sie ein Mdimensionales Array mit Nallen Dimensionen erstellen , ist die Gesamtgröße des Arrays größer als N^M, da jedes Array eine Referenz hat und in der M-Dimension ein (M-1) -dimensionales Array von Referenzen vorhanden ist. Die Gesamtgröße ist wie folgt

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

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

Zum Erstellen von Arrays von Klassenobjekten können Sie die verwenden java.util.ArrayList. 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:

variableNameist ein Verweis auf das Array, was bedeutet, dass durch Manipulieren variableNamemanipuliert wirdarrayName

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 bearbeiten können arrayName(herkömmliche 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 [0, 1E17]:

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

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

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

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

Hier gibt es viele Antworten. Ich füge ein paar knifflige Möglichkeiten hinzu, um Arrays zu erstellen (aus Sicht der 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 von Klammern [] vor dem Variablennamen

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

3. Initialisieren Sie das Array und stellen Sie Daten bereit

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

   Diesmal muss die Größe in der Boxhalterung nicht erwähnt werden. 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

   Ähnliches gilt 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 am Ende eine Boxhalterung anbringen:

    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.

Wenn Sie die obige Syntax verwenden, müssen Sie sicherstellen, dass Sie in Vorwärtsrichtung die Werte in Klammern angeben müssen. Sonst wird es nicht kompiliert. 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 die 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

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

Sie können es auch tun mit java.util.Arrays:

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

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

Dieser ist ziemlich einfach und unkompliziert.

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 hat zwei Grundtypen.

Statisches Array: Array mit fester Größe (seine Größe sollte beim Start deklariert werden und kann später nicht mehr geändert werden)

Dynamisches Array: Hierfür wird keine Größenbeschränkung berücksichtigt. (Reine dynamische Arrays gibt es in Java nicht. Stattdessen wird List am meisten empfohlen.)

Verwenden Sie die folgenden Deklarations- und Initialisierungsanweisungen, um ein statisches Array aus Integer, String, Float usw. zu deklarieren.

    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

Um dynamische Funktionen verwenden zu können, müssen Sie List ... List verwenden. List ist ein reines dynamisches Array, und es ist nicht erforderlich, die Größe zu Beginn zu deklarieren. Unten ist der richtige Weg, um eine Liste in JAVA> zu deklarieren

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

Array deklarieren: int[] arr;

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

Mehrdimensionales Array deklarieren: 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.

Das Initialisieren eines Arrays bedeutet, die Größe des Arrays anzugeben.

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

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

datatype sollte in Kleinbuchstaben sein.

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

Wenn es sich um ein String-Array handelt:

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

Wenn es sich um ein Zeichenarray handelt:

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

Bei float double entspricht das Format des Arrays der Ganzzahl.

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 per Schleife oder Ähnlichem eingeben.

Wenn Sie dies jedoch mit "Methode b" tun, müssen Sie die Werte nicht manuell eingeben.

Das Array kann abhängig von der Definition des Arrays primitive Datentypen sowie Objekte einer Klasse enthalten. Bei primitiven Datentypen werden die tatsächlichen Werte an zusammenhängenden Speicherstellen gespeichert. Bei Objekten einer Klasse werden die tatsächlichen Objekte im Heap-Segment gespeichert.

Eindimensionale Arrays:
Die allgemeine Form einer eindimensionalen Array-Deklaration lautet

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

Instanziieren eines Arrays in Java

var-name = new type [size];

Zum Beispiel

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

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

einander volles Beispiel mit Filmen Klasse 😋

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


            }

        } 

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

Beispiel:

int[] x=new int[10];

oder

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

Beispiel:

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

int[] SingleDimensionalArray = new int[2]

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