Wie kann ich deklarieren und initialisieren Sie ein array in Java?

StackOverflow https://stackoverflow.com/questions/1200621

  •  05-07-2019
  •  | 
  •  

Frage

Wie kann ich deklarieren und initialisieren Sie ein array in Java?

War es hilfreich?

Lösung

Sie entweder wörtliche Verwendung Array-Deklaration oder Array kann (aber nur, wenn Sie erklären, und die Variable beeinflussen direkt, Array-Literale können nicht für die Neuzuweisung 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};

Für die Klassen, zum Beispiel String, es ist das gleiche: 

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

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

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

Andere Tipps

Es gibt zwei Arten von Arrays.

Eindimensionale Arrays

Syntax für Standardwerte:

int[] num = new int[5];

Oder (weniger bevorzugt)

int num[] = new int[5];

Syntax mit angegebenen Werte (variable/Feld-Initialisierung):

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

Oder (weniger bevorzugt)

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

Hinweis:Für die Bequemlichkeit int[] num ist vorzuziehen, da es klar sagt, dass Sie reden hier über array.Sonst 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 ein 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, hier sind wir definieren die Spalten explizit.
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]);
}

Alternativ:

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

Ragged arrays mehrdimensionale arrays.
Für die Erklärung finden Sie unter mehrdimensionale array-detail auf 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 ziehe die Klammern nach dem Typ, weil es einfacher ist zu sehen, dass der Typ der Variablen ist eigentlich ein Array.

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

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

Sie finden weitere Informationen in der Sun Tutorial Website und die JavaDoc .

Im Folgenden wird die Deklaration eines Arrays, aber das Array ist nicht initialisiert: 

 int[] myIntArray = new int[3];

Im Folgenden wird die Erklärung sowie die Initialisierung des Arrays: 

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

Nun wird die folgende zeigt auch die Erklärung sowie die Initialisierung des Arrays: 

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

Aber das dritter zeigt die Eigenschaft, anonymer Array-Objekterstellung, die durch eine Referenzgröße „myIntArray“ gerichtet ist, so dass, wenn wir schreiben nur „new int [] {1,2,3};“ dann ist dies, wie anonymes Array-Objekt erstellt werden kann.

Wenn wir nur schreiben: 

int[] myIntArray;

Das ist nicht Erklärung Array, aber die folgende Aussage macht die obige Erklärung vollständig: 

myIntArray=new int[3];

Ich finde es hilfreich, wenn Sie jeden Teil verstehen: 

Type[] name = new Type[5];

Type[] ist die type des Variable genannt Name ( "name" ist der Kennung genannt). Die wörtliche „Typ“ ist der Basistyp, und die Klammern bedeuten die Array-Typ dieser Basis ist. Array-Typen sind wiederum Arten von ihrer eigenen, die Sie mehrdimensionale Arrays wie Type[][] (der Array-Typ vom Typ []) machen können. Das Schlüsselwort new sagt Speicher für das neue Array zuzuordnen. Die Zahl zwischen dem Träger sagt, wie groß das neue Array sein wird und wie viel Speicher zuzuweisen. wenn Java weiß zum Beispiel, dass der Basistyp Type 32 Bytes nimmt, und Sie wollen eine Reihe von Größe 5, muss es intern 32 * 5 = 160 Byte zuzuweisen.

Sie können auch Arrays erstellen mit den Werten schon da, wie 

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

das schafft nicht nur den leeren Raum, sondern füllt sie mit diesen Werten. Java kann sagen, dass die Primitive ganze Zahlen sind, und dass es 5 von ihnen, so dass die Größe des Arrays kann implizit bestimmt werden.

Alternativ 

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

, die ein Array deklariert arrayName der Größe namens 10 (Sie haben die Elemente 0 bis 9 verwenden).

Auch im Fall, dass Sie etwas mehr Dynamik gibt es die Liste Schnittstelle. Dies wird nicht so gut, führt aber ist 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, um ein Array zu machen:

Dieses, für ein leeres Array: 

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

Und dieser, für eine initialisierte Array: 

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

Sie können auch mehrdimensionale Arrays machen, wie folgt aus: 

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

Nehmen Sie den primitiven Typ int zum Beispiel. Es gibt mehrere Möglichkeiten zu erklären und int Array: 

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

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

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

Beachten Sie, dass der Verfahrensparameter, ... zeigt variable arguments. Im Wesentlichen ist eine beliebige Anzahl von Parametern in Ordnung. Es ist einfacher, mit dem Code 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};

Im Innern des Verfahrens varargs wird als normaler int[] behandelt. Type... kann nur in Methodenparameter verwendet werden, so int... i = new int[] {} nicht kompiliert.

Beachten Sie, dass, wenn ein int[] ein Verfahren (oder einem anderen Type[]) vorbei, Sie nicht die dritte Art und Weise nutzen können. In der Erklärung int[] i = *{a, b, c, d, etc}*, nimmt der Compiler, dass der {...} ein int[] bedeutet. Aber das ist, weil Sie eine Variable deklarieren. Wenn eine Anordnung auf ein Verfahren zum Übergeben, entweder die Erklärung new Type[capacity] oder new Type[] {...} sein muss.

Mehrdimensionale Arrays

Mehrdimensionale Arrays sind viel schwieriger zu behandeln. Im Wesentlichen wird ein 2D-Array ist ein Array von Arrays. int[][] bedeutet eine Anordnung 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 ein rechteckiger int[3][5] ist: 

[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 erstellen mit Reflexionen, dann können Sie wie folgt tun: 

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

Deklarieren ein Array 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 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

die Verwendung von Lokale Variablentyp Inference : 

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

Array ist eine sequentielle Liste der Elemente 

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 entweder zuweisen null sie mit new Type(..) zu initialisieren, Klassen wie String und Integer sind Sonderfälle, die wie folgt behandelt werden wird 

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 der Regel können Sie Arrays erstellen, das ist M dimensional 

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 ein M dimensionales Array zu schaffen, in Bezug auf Raum teuer ist. Da, wenn Sie ein M dimensionales Array mit N auf allen Dimensionen schaffen, wobei die Gesamtgröße des Arrays größer ist als N^M, da jedes Array eine Referenz besitzt, und bei der M-Dimension gibt es einen (M-1) -dimensionalen Array von Referenzen. Die Gesamtgröße ist wie folgt 

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

Für Arrays der Klasse Objekte erstellen, können Sie die java.util.ArrayList verwenden. ein Array zu definieren: 

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

Werte zuweisen Array: 

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

aus dem Array lesen: 

ClassName variableName = arrayName.get(index);

Hinweis:

variableName ist eine Referenz auf das Array was bedeutet, dass die Manipulation variableName arrayName manipulieren

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, die Sie arrayName (konventionelle for-Schleife) bearbeiten können: 

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

In Java 8 können Sie wie folgt verwenden. 

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

Deklarieren und initialisieren für Java 8 und höher. Erstellen Sie einen einfachen 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 eine zufällige Anordnung für ganze Zahlen zwischen [-50, 50] und für die Doppel [0, 1E17]: 

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

Power-of-two-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 [] Sie müssen 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]]

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

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

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

Diese ist ziemlich einfach und unkompliziert. Ich habe es nicht in anderen Antworten sehen also dachte ich, es könnte hinzufügen.

Eine weitere Möglichkeit Arraylist zu deklarieren und initialisieren: 

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

Mit lokaler Variablen Typinferenz Sie nur angeben eingeben müssen einmal: 

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

oder 

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

Viele Antworten hier. Hinzufügen paar knifflige Weise Arrays zu erstellen (Aus einer Prüfung Standpunkt sein guten, dies zu wissen)

  1. deklariert und ein Array definieren 

    int intArray[] = new int[3];

Das ist ein Array mit der Länge 3. erstellen Wie es int Urtyp alle Werte auf 0 gesetzt durch default.For Beispiel

hält 
    intArray[2]; // will return 0

  1. Box Klammern [] vor dem Variablennamen 

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

  2. Initialisieren und Daten-Array liefern 

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

    diesmal keine Notwendigkeit, die Größe in Kastenhalter zu erwähnen. Selbst einfache Variante dieser ist 

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

  3. Ein Array der Länge 0 

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

    Ähnliche 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

    Mit Box Klammern vor Variable 

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

    seine absolut in Ordnung, wenn Sie am Ende eines Kastenhalter 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 der gleichen Größe ist. 

    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, wenn Sie über Syntax verwenden, Vorwärtsrichtung müssen Sie die Werte in Feld angeben brackets.Else es nicht kompiliert werden. 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 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

IMP. Bei referenzierten Typen Standardwert Array gespeichert ist null

Deklarieren Array: int[] arr;

Initialisiere Array: int[] arr = new int[10]; 10 stellt die Anzahl der Elemente in dem Array erlaubt

Deklarieren mehrdimensionales Array: int[][] arr;

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

Initialisieren eines Arrays bedeutet die Größe der es angibt. 

int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top