Java Language
Arrays

Einführung

Syntax

• ArrayType[] myArray; // Arrays deklarieren
• ArrayType myArray[]; // Eine andere gültige Syntax (weniger häufig verwendet und nicht empfohlen)
• ArrayType[][][] myArray; // Multi-dimensionale gezackte Arrays deklarieren (repeat [] s)
• ArrayType myVar = myArray[index]; // Zugriff auf (Lese-) Element am Index
• myArray[index] = value; // Assign Wert index des Arrays
• ArrayType[] myArray = new ArrayType[arrayLength]; // Array-Initialisierungssyntax
• int[] ints = {1, 2, 3}; // Array-Initialisierungssyntax mit angegebenen Werten, Länge wird aus der Anzahl der angegebenen Werte abgeleitet: {[value1 [, value2] *]}
• new int[]{4, -5, 6} // Can be used as argument, without a local variable
• int[] ints = new int[3]; // same as {0, 0, 0}
• int[][] ints = {{1, 2}, {3}, null}; // Mehrdimensionale Array-Initialisierung. int [] erweitert Object (und damit auch anyType []), sodass null einen gültigen Wert darstellt.

Parameter

Arrays erstellen und initialisieren

Grundlegende Fälle

int[]   numbers1 = new int[3];                 // Array for 3 int values, default value is 0
int[]   numbers2 = { 1, 2, 3 };                // Array literal of 3 int values
int[]   numbers3 = new int[] { 1, 2, 3 };      // Array of 3 int values initialized
int[][] numbers4 = { { 1, 2 }, { 3, 4, 5 } };  // Jagged array literal
int[][] numbers5 = new int[5][];               // Jagged array, one dimension 5 long
int[][] numbers6 = new int[5][4];              // Multidimensional array: 5x4

Arrays können mit einem beliebigen Grundelement oder Referenztyp erstellt werden.

float[]  boats = new float[5];          // Array of five 32-bit floating point numbers.
double[] header = new double[] { 4.56, 332.267, 7.0, 0.3367, 10.0 };
                                       // Array of five 64-bit floating point numbers.
String[] theory = new String[] { "a", "b", "c" };
                                       // Array of three strings (reference type).
Object[] dArt = new Object[] { new Object(), "We love Stack Overflow.", new Integer(3) };
                                       // Array of three Objects (reference type).

Beachten Sie für das letzte Beispiel, dass Untertypen des deklarierten Array-Typs im Array zulässig sind.

Arrays für benutzerdefinierte Typen können auch ähnlich zu primitiven Typen erstellt werden

UserDefinedClass[] udType = new UserDefinedClass[5];

Arrays, Sammlungen und Streams

// Parameters require objects, not primitives

// Auto-boxing happening for int 127 here
Integer[]       initial        = { 127, Integer.valueOf( 42 ) };
List<Integer>   toList         = Arrays.asList( initial );  // Fixed size! 

// Note: Works with all collections
Integer[]       fromCollection = toList.toArray( new Integer[toList.size()] );

//Java doesn't allow you to create an array of a parameterized type
List<String>[]  list = new ArrayList<String>[2];  // Compilation error!

// Streams - JDK 8+
Stream<Integer> toStream       = Arrays.stream( initial );
Integer[]       fromStream     = toStream.toArray( Integer[]::new );

Intro

Ein Array ist eine Datenstruktur, die eine feste Anzahl von Grundwerten oder Referenzen auf Objektinstanzen enthält.

Jedes Element in einem Array wird als Element bezeichnet, und auf jedes Element wird über seinen numerischen Index zugegriffen. Die Länge eines Arrays wird festgelegt, wenn das Array erstellt wird:

int size = 42;
int[] array = new int[size];

Die Größe eines Arrays wird bei der Initialisierung zur Laufzeit festgelegt. Sie kann nach der Initialisierung nicht geändert werden. Wenn die Größe zur Laufzeit veränderbar sein muss, sollte stattdessen eine Collection Klasse wie ArrayList verwendet werden. ArrayList speichert Elemente in einem Array und unterstützt die Größenänderung, indem ein neues Array zugewiesen und Elemente aus dem alten Array kopiert werden.

Wenn das Array von einem primitiven Typ ist, d

int[] array1 = { 1,2,3 };
int[] array2 = new int[10];

Die Werte werden im Array selbst gespeichert. In Abwesenheit eines Initialisierers (wie in array2 oben) ist der jedem Element zugewiesene Standardwert 0 (Null).

Wenn der Array-Typ eine Objektreferenz ist, wie in

SomeClassOrInterface[] array = new SomeClassOrInterface[10];

dann enthält das Array Verweise auf Objekte vom Typ SomeClassOrInterface . Diese Verweise können sich auf eine Instanz von SomeClassOrInterface oder eine beliebige Unterklasse (für Klassen) oder die implementierende Klasse (für Schnittstellen) von SomeClassOrInterface . Wenn die Array-Deklaration keinen Initialisierer hat, wird jedem Element der Standardwert null zugewiesen.

Da alle Arrays int -indexiert sind, muss die Größe eines Arrays durch ein int angegeben werden. Die Größe des Arrays kann nicht als long :

long size = 23L;
int[] array = new int[size]; // Compile-time error:
                             // incompatible types: possible lossy conversion from
                             // long to int

Arrays verwenden ein auf Null basierendes Indexsystem , das heißt, die Indizierung beginnt bei 0 und endet bei length - 1 0 .

Das folgende Bild stellt beispielsweise ein Array mit der Größe 10 . Hier befindet sich das erste Element am Index 0 und das letzte Element am Index 9 , anstelle des ersten Elements am Index 1 und des letzten Elements am Index 10 (siehe Abbildung unten).

Zugriffe auf Elemente von Arrays erfolgen in konstanter Zeit . Das bedeutet, dass der Zugriff auf das erste Element des Arrays (zeitlich) die gleichen Kosten für den Zugriff auf das zweite Element, das dritte Element usw. verursacht.

Java bietet verschiedene Möglichkeiten zum Definieren und Initialisieren von Arrays, einschließlich Literal- und Konstruktornotationen . Bei der Deklaration von Arrays mit dem new Type[length] -Konstruktor wird jedes Element mit den folgenden Standardwerten initialisiert:

• 0 für primitive numerische Typen : byte , short , int , long , float und double .
• '\u0000' (null character) für den char - Typen.
• false für den boolean Typ.
• null für Referenztypen .

Erstellen und Initialisieren von primitiven Arrays

int[] array1 = new int[] { 1, 2, 3 }; // Create an array with new operator and 
                                      // array initializer.
int[] array2 = { 1, 2, 3 };           // Shortcut syntax with array initializer.
int[] array3 = new int[3];            // Equivalent to { 0, 0, 0 }
int[] array4 = null;                  // The array itself is an object, so it
                                      // can be set as null.

Bei der Deklaration eines Arrays erscheint [] als Teil des Typs am Anfang der Deklaration (nach dem Typnamen) oder als Teil des Deklarators für eine bestimmte Variable (nach Variablenname) oder beides:

int array5[];       /* equivalent to */  int[] array5;
int a, b[], c[][];  /* equivalent to */  int a; int[] b; int[][] c;
int[] a, b[];       /* equivalent to */  int[] a; int[][] b;
int a, []b, c[][];  /* Compilation Error, because [] is not part of the type at beginning
                       of the declaration, rather it is before 'b'. */    
// The same rules apply when declaring a method that returns an array:
int foo()[] { ... } /* equivalent to */  int[] foo() { ... }

Im folgenden Beispiel sind beide Deklarationen korrekt und können ohne Probleme kompiliert und ausgeführt werden. Sowohl die Java Coding Convention als auch der Google Java Style Guide raten jedoch davon ab, dass das Formular mit Klammern hinter dem Variablennamen steht. Die Klammern geben den Array-Typ an und sollten mit der Typbezeichnung angezeigt werden . Dasselbe sollte für Methodenrücksignaturen verwendet werden.

float array[]; /* and */ int foo()[] { ... } /* are discouraged */
float[] array; /* and */ int[] foo() { ... } /* are encouraged */

Der entmutigte Typ ist für übergebende C-Benutzer gedacht , die mit der Syntax für C vertraut sind, das nach dem Variablennamen die Klammern hat.

In Java können Arrays der Größe 0 :

int[] array = new int[0]; // Compiles and runs fine.
int[] array2 = {};        // Equivalent syntax.

Da es sich jedoch um ein leeres Array handelt, können keine Elemente daraus gelesen oder zugewiesen werden:

array[0] = 1;     // Throws java.lang.ArrayIndexOutOfBoundsException.
int i = array2[0]; // Also throws ArrayIndexOutOfBoundsException.

Solche leeren Arrays sind normalerweise als Rückgabewerte nützlich, so dass sich der aufrufende Code nur um den Umgang mit einem Array kümmern muss, anstatt einen potenziellen null , der zu einer NullPointerException führen NullPointerException .

Die Länge eines Arrays muss eine nicht negative ganze Zahl sein:

int[] array = new int[-1]; // Throws java.lang.NegativeArraySizeException

Die Arraygröße kann mithilfe eines öffentlichen letzten Felds namens length :

System.out.println(array.length); // Prints 0 in this case.

Anmerkung : array.length gibt die tatsächliche Größe des Arrays und nicht die Anzahl der array.length zurück, denen ein Wert zugewiesen wurde, im Gegensatz zu ArrayList.size() das die Anzahl der array.length zurückgibt, denen ein Wert zugewiesen wurde.

Erstellen und Initialisieren von mehrdimensionalen Arrays

Die einfachste Methode zum Erstellen eines mehrdimensionalen Arrays ist wie folgt:

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

Es werden zwei int Arrays mit drei Längen erstellt - a[0] und a[1] . Dies ist der klassischen Initialisierung im C-Stil von rechteckigen mehrdimensionalen Arrays sehr ähnlich.

Sie können gleichzeitig erstellen und initialisieren:

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

Im Gegensatz zu C müssen , wenn nur rechteckige mehrdimensionale Arrays unterstützt werden, innere Arrays nicht die gleiche Länge haben oder sogar definiert sein:

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

Hier ist a[0] ein int Array mit einer Länge, wohingegen a[1] ein int Array mit zwei Längen und a[2] null . Arrays wie dieses werden gezackte Arrays oder unregelmäßige Arrays genannt , das heißt Arrays von Arrays. Mehrdimensionale Arrays in Java werden als Arrays von Arrays implementiert, dh array[i][j][k] entspricht ((array[i])[j])[k] . Im Gegensatz zu C # wird das Syntax- array[i,j] in Java nicht unterstützt.

Mehrdimensionale Array-Darstellung in Java

Source - Live auf Ideone

Erstellen und Initialisieren von Referenztyp- Arrays

String[] array6 = new String[] { "Laurel", "Hardy" }; // Create an array with new 
                                                      // operator and array initializer.
String[] array7 = { "Laurel", "Hardy" };              // Shortcut syntax with array 
                                                      // initializer.
String[] array8 = new String[3];                      // { null, null, null }
String[] array9 = null;                               // null

Live auf Ideone

Zusätzlich zu den oben gezeigten String Literalen und Primitiven funktioniert die Abkürzungssyntax für die Array-Initialisierung auch mit kanonischen Object :

Object[] array10 = { new Object(), new Object() };

Da Arrays kovariant sind, kann ein Referenztyparray als Array einer Unterklasse ArrayStoreException werden. Eine ArrayStoreException wird jedoch ausgelöst, wenn Sie versuchen, ein Element auf einen anderen String als einen String :

Object[] array11 = new String[] { "foo", "bar", "baz" };
array11[1] = "qux"; // fine
array11[1] = new StringBuilder(); // throws ArrayStoreException

Die Shortcut-Syntax kann dafür nicht verwendet werden, da die Shortcut-Syntax einen impliziten Typ von Object[] .

Ein Array kann mit null Elementen unter Verwendung von String[] emptyArray = new String[0] initialisiert werden. Ein Array mit der Länge Null wie diesem wird beispielsweise zum Erstellen eines Array aus einer Collection wenn die Methode den Laufzeittyp eines Objekts benötigt.

Sowohl bei primitiven als auch bei Referenztypen initialisiert eine leere Array-Initialisierung (z. B. String[] array8 = new String[3] ) das Array mit dem Standardwert für jeden Datentyp .

Generische Typ- Arrays erstellen und initialisieren

In generischen Klassen können Arrays generischer Typen aufgrund von Typlöschung nicht wie folgt initialisiert werden:

public class MyGenericClass<T> {
    private T[] a;

    public MyGenericClass() {
        a = new T[5]; // Compile time error: generic array creation
    }
}

Sie können stattdessen mit einer der folgenden Methoden erstellt werden: (Beachten Sie, dass diese ungeprüfte Warnungen erzeugen.)

1. Erstellen Sie ein Object Array und geben Sie es in einen generischen Typ um:

   a = (T[]) new Object[5];
   

   Dies ist die einfachste Methode. Da das zugrunde liegende Array jedoch immer noch vom Typ Object[] bietet diese Methode keine Typsicherheit. Daher wird diese Methode zum Erstellen eines Arrays am besten nur innerhalb der generischen Klasse verwendet - nicht öffentlich verfügbar gemacht.

2. Verwenden Sie Array.newInstance mit einem Klassenparameter:

   public MyGenericClass(Class<T> clazz) {
       a = (T[]) Array.newInstance(clazz, 5);
   }
   

   Hier muss die Klasse von T explizit an den Konstruktor übergeben werden. Der Rückgabetyp von Array.newInstance ist immer Object . Diese Methode ist jedoch sicherer, da das neu erstellte Array immer vom Typ T[] ist und daher sicher externalisiert werden kann.

Array nach der Initialisierung füllen

Arrays.fill(array8, "abc");        // { "abc", "abc", "abc" }

Arrays.fill(array8, 1, 2, "aaa");  // Placing "aaa" from index 1 to 2.

int[] array = new int[5];
Arrays.setAll(array, i -> i); // The array becomes { 0, 1, 2, 3, 4 }.

Separate Deklaration und Initialisierung von Arrays

Der Wert eines Index für ein Array-Element muss eine ganze Zahl (0, 1, 2, 3, 4, ...) und weniger als die Länge des Arrays sein (Indizes basieren auf Null). Andernfalls wird eine ArrayIndexOutOfBoundsException ausgelöst:

int[] array9;             // Array declaration - uninitialized
array9 = new int[3];      // Initialize array  - { 0, 0, 0 }
array9[0] = 10;           // Set index 0 value - { 10, 0, 0 }
array9[1] = 20;           // Set index 1 value - { 10, 20, 0 }
array9[2] = 30;           // Set index 2 value - { 10, 20, 30 }

Arrays können mit der Array-Initialisierungs-Verknüpfungssyntax nicht erneut initialisiert werden

Es ist nicht möglich, ein Array über eine Verknüpfungssyntax mit einem Array-Initialisierer erneut zu initialisieren, da ein Array-Initialisierer nur in einer Felddeklaration oder einer Deklaration lokaler Variablen oder als Teil eines Ausdrucks zur Array-Erstellung angegeben werden kann.

Es ist jedoch möglich, ein neues Array zu erstellen und es der Variablen zuzuweisen, die zum Referenzieren des alten Arrays verwendet wird. Während dies dazu führt, dass das Array, auf das diese Variable verweist, neu initialisiert wird, ist der Inhalt der Variablen ein völlig neues Array. Zu diesem Zweck kann der new Operator mit einem Array-Initialisierer verwendet und der Array-Variablen zugewiesen werden:

// First initialization of array
int[] array = new int[] { 1, 2, 3 };

// Prints "1 2 3 ".
for (int i : array) {
    System.out.print(i + " ");
}

// Re-initializes array to a new int[] array.
array = new int[] { 4, 5, 6 };

// Prints "4 5 6 ".
for (int i : array) {
    System.out.print(i + " ");
}

array = { 1, 2, 3, 4 }; // Compile-time error! Can't re-initialize an array via shortcut 
                        // syntax with array initializer.

Live auf Ideone

Erstellen eines Arrays aus einer Sammlung

Zwei Methoden in java.util.Collection erstellen ein Array aus einer Auflistung:

• Object[] toArray()

• <T> T[] toArray(T[] a)

Object[] toArray() kann wie folgt verwendet werden:

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// although set is a Set<String>, toArray() returns an Object[] not a String[]
Object[] objectArray = set.toArray();

<T> T[] toArray(T[] a) kann wie folgt verwendet werden:

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// The array does not need to be created up front with the correct size.
// Only the array type matters. (If the size is wrong, a new array will
// be created with the same type.)
String[] stringArray = set.toArray(new String[0]);  

// If you supply an array of the same size as collection or bigger, it
// will be populated with collection values and returned (new array
// won't be allocated)
String[] stringArray2 = set.toArray(new String[set.size()]);

Der Unterschied zwischen ihnen ist mehr als nur die Eingabe von untypisierten und nicht typisierten Ergebnissen. Ihre Leistung kann auch unterschiedlich sein (für Details lesen Sie bitte diesen Abschnitt zur Leistungsanalyse ):

• Object[] toArray() verwendet arraycopy , was viel schneller ist als die arraycopy die in T[] toArray(T[] a) .
• T[] toArray(new T[non-zero-size]) muss das Array zur Laufzeit auf Null setzen, während T[] toArray(new T[0]) dies nicht tut. Eine solche Vermeidung macht den letzteren schneller als den ersten. Detaillierte Analyse hier: Arrays der Weisheit der Ahnen .

String[] strings = list.stream().toArray(String[]::new);

Beispiele aus zwei Antworten ( 1 , 2 ) bis Konvertierung von 'ArrayList in' String [] 'in Java bei Stapelüberlauf.

Arrays zu einem String

int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr));      // [1, 2, 3, 4, 5]

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
System.out.println(Arrays.deepToString(arr));  // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

public class Cat { /* implicitly extends Object */
    @Override
    public String toString() {
      return "CAT!";
    }
}

Cat[] arr = { new Cat(), new Cat() };
System.out.println(Arrays.toString(arr));        // [CAT!, CAT!]

public class Dog {
    /* implicitly extends Object */
}

Dog[] arr = { new Dog() };
System.out.println(Arrays.toString(arr));        // [Dog@17ed40e0]

Erstellen einer Liste aus einem Array

Die Arrays.asList() -Methode kann verwendet werden, um eine List mit fester Größe zurückzugeben, die die Elemente des angegebenen Arrays enthält. Die resultierende List den gleichen Parametertyp wie der Basistyp des Arrays.

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = Arrays.asList(stringArray);

Hinweis : Diese Liste wird durch das ursprüngliche Array ( eine Ansicht des ursprünglichen Arrays) unterstützt, was bedeutet, dass Änderungen an der Liste das Array ändern und umgekehrt. Änderungen an der Liste, die die Größe (und damit die Arraylänge) ändern würden, lösen jedoch eine Ausnahme aus.

Verwenden Sie zum Erstellen einer Kopie der Liste den Konstruktor von java.util.ArrayList wobei eine Collection als Argument verwendet wird:

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<String>(Arrays.asList(stringArray));

// Using Arrays.asList()

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));

// Using ArrayList.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList(stringArray));

// Using Collections.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, stringArray);

// Using Streams

int[] ints = {1, 2, 3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

String[] stringArray = {"foo", "bar", "baz"};
List<Object> list = Arrays.stream(stringArray).collect(Collectors.toList());

Wichtige Hinweise zur Verwendung der Arrays.asList () - Methode

• Diese Methode gibt List , eine Instanz von Arrays$ArrayList (statische innere Klasse von Arrays ) und nicht java.util.ArrayList . Die resultierende List hat eine feste Größe. Das bedeutet, dass das Hinzufügen oder Entfernen von Elementen nicht unterstützt wird und eine UnsupportedOperationException :

  stringList.add("something"); // throws java.lang.UnsupportedOperationException
  

• Eine neue List kann erstellt werden, indem eine Array-unterstützte List an den Konstruktor einer neuen List . Dadurch wird eine neue Kopie der Daten erstellt, deren Größe veränderbar ist und die nicht vom ursprünglichen Array unterstützt wird:

  List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));
  

• Durch Aufrufen von <T> List<T> asList(T... a) auf einem primitiven Array, beispielsweise einem int[] , wird ein List<int[]> dessen einziges Element das primitive Quellarray anstelle der eigentlichen Elemente ist des Quellarrays.

  Der Grund für dieses Verhalten ist, dass primitive Typen nicht anstelle generischer Typparameter verwendet werden können. In diesem Fall ersetzt das gesamte primitive Array den generischen Typparameter. Um ein primitives Array in eine List zu konvertieren, konvertieren Sie zuerst das primitive Array in ein Array des entsprechenden Wrapper-Typs (dh rufen Sie Arrays.asList für eine Integer[] statt eines int[] ) auf.

  Daher wird dies false gedruckt:

  int[] arr = {1, 2, 3};      // primitive array of int
  System.out.println(Arrays.asList(arr).contains(1));
  

  Demo anzeigen

  Auf der anderen Seite wird dies true gedruckt:

  Integer[] arr = {1, 2, 3};  // object array of Integer (wrapper for int)
  System.out.println(Arrays.asList(arr).contains(1));
  

  Demo anzeigen

  Dies wird auch als true , da das Array als Integer[] interpretiert wird:

  System.out.println(Arrays.asList(1,2,3).contains(1));
  

  Demo anzeigen

Mehrdimensionale und gezackte Arrays

Es ist möglich, ein Array mit mehr als einer Dimension zu definieren. Anstatt auf einen einzelnen Index zuzugreifen, wird auf ein mehrdimensionales Array durch Angabe eines Index für jede Dimension zugegriffen.

Die Deklaration eines mehrdimensionalen Arrays kann durch Hinzufügen von [] für jede Dimension zu einer regulären Array-Deklaration erfolgen. Um beispielsweise ein 2-dimensionales int Array zu int , fügen Sie der Deklaration einen weiteren Satz von Klammern hinzu, beispielsweise int[][] . Dies gilt für 3-dimensionale Arrays ( int[][][] ) und so weiter.

So definieren Sie ein zweidimensionales Array mit drei Zeilen und drei Spalten:

int rows = 3;
int columns = 3;
int[][] table = new int[rows][columns];

Das Array kann mit diesem Konstrukt indiziert werden und ihm Werte zuweisen. Beachten Sie, dass die nicht zugewiesenen Werte die Standardwerte für den Typ eines Arrays sind, in diesem Fall 0 für int .

table[0][0] = 0;
table[0][1] = 1;
table[0][2] = 2;

Es ist auch möglich, eine Dimension auf einmal zu instanziieren und sogar nicht rechteckige Arrays zu erstellen. Diese werden häufiger als gezackte Arrays bezeichnet .

int[][] nonRect = new int[4][];

Es ist wichtig zu beachten, dass es zwar möglich ist, eine beliebige Dimension eines gezackten Arrays zu definieren, die vorherige Ebene muss jedoch definiert werden.

// valid
String[][] employeeGraph = new String[30][];

// invalid
int[][] unshapenMatrix = new int[][10];

// also invalid
int[][][] misshapenGrid = new int[100][][10];

Wie multidimensionale Arrays in Java dargestellt werden

^{Bildquelle: http://math.hws.edu/eck/cs124/javanotes3/c8/s5.html}

Gezackte Array-Intialisierung

Mehrdimensionale Arrays und gezackte Arrays können auch mit einem Literalausdruck initialisiert werden. Im Folgenden wird ein 2x3 int Array deklariert und aufgefüllt:

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

Hinweis : Gezackte Unterfelder können auch null . Mit dem folgenden Code wird beispielsweise ein zweidimensionales int Array deklariert und aufgefüllt, dessen erstes Unterfeld null , das zweite Unterfeld die Länge Null hat, das dritte Unterfeld eine Länge hat und das letzte Unterfeld ein Array mit zwei Längen ist:

int[][] table = {
    null,
    {},
    {1},
    {1,2}
};

Bei mehrdimensionalen Arrays können Arrays mit untergeordneten Dimensionen anhand ihrer Indizes extrahiert werden:

int[][][] arr = new int[3][3][3];
int[][] arr1 = arr[0]; // get first 3x3-dimensional array from arr
int[] arr2 = arr1[0]; // get first 3-dimensional array from arr1
int[] arr3 = arr[0]; // error: cannot convert from int[][] to int[]

ArrayIndexOutOfBoundsException

Die ArrayIndexOutOfBoundsException wird ausgelöst, wenn auf einen nicht vorhandenen Index eines Arrays zugegriffen wird.

Arrays sind nullbasiert, daher ist der Index des ersten Elements 0 und der Index des letzten Elements ist die array.length - 1 minus 1 (dh array.length - 1 ).

Daher muss jede Anforderung eines Arrayelements durch den Index i die Bedingung 0 <= i < array.length , andernfalls wird die ArrayIndexOutOfBoundsException ausgelöst.

Der folgende Code ist ein einfaches Beispiel, in dem eine ArrayIndexOutOfBoundsException ausgelöst wird.

String[] people = new String[] { "Carol", "Andy" };

// An array will be created:
// people[0]: "Carol"
// people[1]: "Andy"

// Notice: no item on index 2. Trying to access it triggers the exception:
System.out.println(people[2]);  // throws an ArrayIndexOutOfBoundsException.

Ausgabe:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at your.package.path.method(YourClass.java:15)

Beachten Sie, dass der illegale Index, auf den zugegriffen wird, auch in der Ausnahme enthalten ist ( 2 im Beispiel). Diese Informationen können hilfreich sein, um die Ursache der Ausnahme zu ermitteln.

Um dies zu vermeiden, überprüfen Sie einfach, ob sich der Index innerhalb der Grenzen des Arrays befindet:

int index = 2;
if (index >= 0 && index < people.length) {
    System.out.println(people[index]);
} 

Länge eines Arrays ermitteln

Arrays sind Objekte, die Platz für die Speicherung von Elementen des angegebenen Typs bieten. Die Größe eines Arrays kann nicht geändert werden, nachdem das Array erstellt wurde.

int[] arr1 = new int[0];
int[] arr2 = new int[2];
int[] arr3 = new int[]{1, 2, 3, 4};
int[] arr4 = {1, 2, 3, 4, 5, 6, 7};

int len1 = arr1.length; // 0
int len2 = arr2.length; // 2
int len3 = arr3.length; // 4
int len4 = arr4.length; // 7

Das length in einem Array speichert die Größe eines Arrays. Es ist ein final Feld und kann nicht geändert werden.

Dieser Code zeigt den Unterschied zwischen der length eines Arrays und der Anzahl der Objekte, die ein Array speichert.

public static void main(String[] args) {
    Integer arr[] = new Integer[] {1,2,3,null,5,null,7,null,null,null,11,null,13};

    int arrayLength = arr.length;
    int nonEmptyElementsCount = 0;

    for (int i=0; i<arrayLength; i++) {
        Integer arrElt = arr[i];
        if (arrElt != null) {
            nonEmptyElementsCount++;
        }
    }

    System.out.println("Array 'arr' has a length of "+arrayLength+"\n"
                            + "and it contains "+nonEmptyElementsCount+" non-empty values");
}

Ergebnis:

Array 'arr' has a length of 13
and it contains 7 non-empty values

Vergleich von Arrays auf Gleichheit

Array-Typen erben ihre Implementierungen von equals() (und hashCode() ) von java.lang.Object. Daher gibt equals() nur beim Vergleich mit demselben Array-Objekt true zurück. Verwenden Sie java.util.Arrays.equals , um Arrays auf Gleichheit basierend auf ihren Werten zu vergleichen, die für alle Array-Typen überlastet ist.

int[] a = new int[]{1, 2, 3};
int[] b = new int[]{1, 2, 3};
System.out.println(a.equals(b)); //prints "false" because a and b refer to different objects
System.out.println(Arrays.equals(a, b)); //prints "true" because the elements of a and b have the same values

Wenn der Elementtyp ein Referenztyp ist, ruft Arrays.equals() equals() für die Array-Elemente auf, um die Gleichheit zu bestimmen. Wenn der Elementtyp selbst ein Array-Typ ist, wird der Identitätsvergleich verwendet. Um multidimensionale Arrays auf Gleichheit zu vergleichen, verwenden Arrays.deepEquals() stattdessen Arrays.deepEquals()

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

Object[] aObject = { a }; // aObject contains one element
Object[] bObject = { b }; // bObject contains one element

System.out.println(Arrays.equals(aObject, bObject)); // false
System.out.println(Arrays.deepEquals(aObject, bObject));// true

Da Sets und Maps equals() und hashCode() , sind Arrays im Allgemeinen nicht als Setelemente oder Map-Schlüssel nützlich. Entweder wickeln sie in eine Hilfsklasse , die implementiert equals() und hashCode() in Bezug auf die Array - Elemente, oder wandeln sie in die List Instanzen und die Listen zu speichern.

Arrays zum Streamen

String[] arr = new String[] {"str1", "str2", "str3"};
Stream<String> stream = Arrays.stream(arr);

int[] intArr = {1, 2, 3};
IntStream intStream = Arrays.stream(intArr);

int[] values = {1, 2, 3, 4};
IntStream intStream = Arrays.stream(values, 2, 4);

Stream<Integer> intStream = Stream.of(1, 2, 3);
Stream<String> stringStream = Stream.of("1", "2", "3");
Stream<Double> doubleStream = Stream.of(new Double[]{1.0, 2.0});

Iteration über Arrays

Sie können über Arrays iterieren, indem Sie entweder for for (erweitert) oder Array-Indizes verwenden:

int[] array = new int[10];

// using indices: read and write
for (int i = 0; i < array.length; i++) {
    array[i] = i;
}

// extended for: read only
for (int e : array) {
    System.out.println(e);
}

Es ist erwähnenswert, dass es keinen direkten Weg gibt, einen Iterator für ein Array zu verwenden, er kann jedoch durch die Arrays-Bibliothek leicht in eine Liste konvertiert werden, um ein Iterable Objekt zu erhalten.

Verwenden Sie für Box-Arrays Arrays.asList :

Integer[] boxed = {1, 2, 3};
Iterable<Integer> boxedIt = Arrays.asList(boxed); // list-backed iterable
Iterator<Integer> fromBoxed1 = boxedIt.iterator();

Verwenden Sie für primitive Arrays (mit Java 8) Streams (speziell in diesem Beispiel - Arrays.stream -> IntStream ):

int[] primitives = {1, 2, 3};
IntStream primitiveStream = Arrays.stream(primitives); // list-backed iterable
PrimitiveIterator.OfInt fromPrimitive1 = primitiveStream.iterator();

Wenn Sie keine Streams verwenden können (keine Java 8), können Sie die Guava- Bibliothek von Google verwenden:

Iterable<Integer> fromPrimitive2 = Ints.asList(primitives);

In zweidimensionalen Arrays oder mehr können beide Techniken auf etwas komplexere Weise verwendet werden.

Beispiel:

int[][] array = new int[10][10];

for (int indexOuter = 0; indexOuter < array.length; indexOuter++) {
    for (int indexInner = 0; indexInner < array[indexOuter].length; indexInner++) {
        array[indexOuter][indexInner] = indexOuter + indexInner;
    }
}

for (int[] numbers : array) {
    for (int value : numbers) {
        System.out.println(value);
    }
}

Es ist nicht möglich, ein Array auf einen nicht einheitlichen Wert zu setzen, ohne eine indexbasierte Schleife zu verwenden.

Natürlich können Sie auch while oder do-while Schleifen verwenden, wenn Sie mit Indizes iterieren.

Ein Hinweis zur Vorsicht: array.length - 1 bei der Verwendung von array.length - 1 sicher, dass der Index zwischen 0 und array.length - 1 (beide inklusive) liegt. Nehmen Sie keine fest codierten Annahmen für die Arraylänge vor. Andernfalls könnte Ihr Code beschädigt werden, wenn sich die Arraylänge ändert, Ihre hartcodierten Werte jedoch nicht.

Beispiel:

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

public void incrementNumbers() {
    // DO THIS :
    for (int i = 0; i < numbers.length; i++) {
        numbers[i] += 1; //or this: numbers[i] = numbers[i] + 1; or numbers[i]++;      
    }
 
    // DON'T DO THIS :
    for (int i = 0; i < 4; i++) {
        numbers[i] += 1;
    }
}

Es ist auch am besten, wenn Sie keine ausgefallenen Berechnungen verwenden, um den Index abzurufen, sondern den Index zur Iteration verwenden und wenn Sie andere Werte benötigen, diese berechnen.

Beispiel:

public void fillArrayWithDoubleIndex(int[] array) {
    // DO THIS :
    for (int i = 0; i < array.length; i++) {
        array[i] = i * 2;
    }
 
    // DON'T DO THIS :
    int doubleLength = array.length * 2;
    for (int i = 0; i < doubleLength; i += 2) {
        array[i / 2] = i;
    }
}

Zugreifen auf Arrays in umgekehrter Reihenfolge

int[] array = {0, 1, 1, 2, 3, 5, 8, 13};
for (int i = array.length - 1; i >= 0; i--) {
   System.out.println(array[i]);
}

Verwenden temporärer Arrays, um die Codewiederholung zu reduzieren

Wenn Sie ein temporäres Array durchlaufen, anstatt Code zu wiederholen, kann der Code sauberer werden. Es kann verwendet werden, wenn dieselbe Operation für mehrere Variablen ausgeführt wird.

// we want to print out all of these
String name = "Margaret";
int eyeCount = 16;
double height = 50.2;
int legs = 9;
int arms = 5;


// copy-paste approach:
System.out.println(name);
System.out.println(eyeCount);
System.out.println(height);
System.out.println(legs);
System.out.println(arms);


// temporary array approach:
for(Object attribute : new Object[]{name, eyeCount, height, legs, arms})
    System.out.println(attribute);

// using only numbers
for(double number : new double[]{eyeCount, legs, arms, height})
    System.out.println(Math.sqrt(number));

Beachten Sie, dass dieser Code nicht in leistungskritischen Abschnitten verwendet werden sollte, da bei jeder Eingabe der Schleife ein Array erstellt wird und dass primitive Variablen in das Array kopiert werden und daher nicht geändert werden können.

Arrays kopieren

Java bietet mehrere Möglichkeiten, ein Array zu kopieren.

für Schleife

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length]; 
for (int i = 0; i < a.length; i++) {
    b[i] = a[i];
}

Beachten Sie, dass bei Verwendung dieser Option mit einem Object-Array anstelle eines primitiven Arrays die Kopie mit einem Verweis auf den ursprünglichen Inhalt anstatt mit einer Kopie davon gefüllt wird.

Object.clone ()

Da Arrays Object s in Java, können Sie Object.clone() .

int[] a = { 4, 1, 3, 2 };
int[] b = a.clone(); // [4, 1, 3, 2]

Beachten Sie, dass die Object.clone Methode für ein Array eine flache Kopie ausführt, dh einen Verweis auf ein neues Array zurückgibt, das auf dieselben Elemente verweist wie das Quellarray.

Arrays.copyOf ()

java.util.Arrays einfache Weise die Kopie eines Arrays auf ein anderes kopieren. Hier ist die grundlegende Verwendung:

int[] a = {4, 1, 3, 2};
int[] b = Arrays.copyOf(a, a.length); // [4, 1, 3, 2]

Beachten Sie, dass Arrays.copyOf auch eine Überladung bereitstellt, mit der Sie den Typ des Arrays ändern können:

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

System.arraycopy ()

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) Kopiert ein Array aus dem angegebenen public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) , beginnend an der angegebenen Position, an die angegebene Position des Zielarrays.

Unten ein Anwendungsbeispiel

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length];
System.arraycopy(a, 0, b, 0, a.length); // [4, 1, 3, 2]

Arrays.copyOfRange ()

Hauptsächlich zum Kopieren eines Teils eines Arrays verwendet, können Sie es auch verwenden, um das gesamte Array in ein anderes zu kopieren:

int[] a = { 4, 1, 3, 2 };
int[] b = Arrays.copyOfRange(a, 0, a.length); // [4, 1, 3, 2]

Casting-Arrays

Arrays sind Objekte, ihr Typ wird jedoch durch den Typ der enthaltenen Objekte definiert. Daher kann man A[] nicht einfach in T[] , sondern jedes A-Mitglied des spezifischen A[] muss in ein T Objekt umgewandelt werden. Allgemeines Beispiel:

public static <T, A> T[] castArray(T[] target, A[] array) {
    for (int i = 0; i < array.length; i++) {
        target[i] = (T) array[i];
    }
    return target;
}

Daher ein A[] -Array gegeben:

T[] target = new T[array.Length];
target = castArray(target, array);

Java SE stellt für diesen Zweck die Methode Arrays.copyOf(original, newLength, newType) zur Verfügung:

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

Entfernen Sie ein Element aus einem Array

Java bietet keine direkte Methode in java.util.Arrays , um ein Element aus einem Array zu entfernen. Um dies durchzuführen, können Sie entweder das ursprüngliche Array in ein neues kopieren, ohne das Element zu entfernen, oder das Array in eine andere Struktur konvertieren, die das Entfernen zulässt.

ArrayList verwenden

Sie können das Array in eine java.util.List konvertieren, das Element entfernen und die Liste wie folgt in ein Array zurückwandeln:

String[] array = new String[]{"foo", "bar", "baz"};

List<String> list = new ArrayList<>(Arrays.asList(array));
list.remove("foo");

// Creates a new array with the same size as the list and copies the list
// elements to it.
array = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(array)); //[bar, baz]

System.arraycopy verwenden

System.arraycopy() kann verwendet werden, um eine Kopie des ursprünglichen Arrays zu erstellen und das gewünschte Element zu entfernen. Unten ein Beispiel:

int[] array = new int[] { 1, 2, 3, 4 }; // Original array.
int[] result = new int[array.length - 1]; // Array which will contain the result.
int index = 1; // Remove the value "2".

// Copy the elements at the left of the index.
System.arraycopy(array, 0, result, 0, index);
// Copy the elements at the right of the index.
System.arraycopy(array, index + 1, result, index, array.length - index - 1);

System.out.println(Arrays.toString(result)); //[1, 3, 4]

Apache Commons verwenden Lang

Um ein Element leicht zu entfernen, können Sie die Apache Commons Lang- Bibliothek und insbesondere die statische Methode removeElement() der Klasse ArrayUtils . Unten ein Beispiel:

int[] array = new int[]{1,2,3,4};
array = ArrayUtils.removeElement(array, 2); //remove first occurrence of 2
System.out.println(Arrays.toString(array)); //[1, 3, 4]

Array-Kovarianz

Objektarrays sind kovariant, was bedeutet, dass Integer eine Unterklasse von Number und Integer[] eine Unterklasse von Number[] . Dies kann intuitiv erscheinen, kann aber zu überraschendem Verhalten führen:

Integer[] integerArray = {1, 2, 3};
Number[] numberArray = integerArray;  // valid
Number firstElement = numberArray[0]; // valid
numberArray[0] = 4L;                  // throws ArrayStoreException at runtime

Obwohl Integer[] eine Unterklasse von Number[] , kann es nur Integer Werte enthalten, und der Versuch, ein Long Element zuzuweisen, löst eine Laufzeitausnahme aus.

Beachten Sie, dass dieses Verhalten nur für Arrays gilt und stattdessen eine generische List verwendet werden kann:

List<Integer> integerList = Arrays.asList(1, 2, 3);
//List<Number> numberList = integerList;  // compile error
List<? extends Number> numberList = integerList;
Number firstElement = numberList.get(0);
//numberList.set(0, 4L);                  // compile error

Es ist nicht notwendig, dass alle Array-Elemente denselben Typ verwenden, sofern sie eine Unterklasse des Array-Typs sind:

interface I {}

class A implements I {}
class B implements I {}
class C implements I {}

I[] array10 = new I[] { new A(), new B(), new C() }; // Create an array with new
                                                     // operator and array initializer.

I[] array11 = { new A(), new B(), new C() };         // Shortcut syntax with array
                                                     // initializer.

I[] array12 = new I[3];                              // { null, null, null }

I[] array13 = new A[] { new A(), new A() };          // Works because A implements I.

Object[] array14 = new Object[] { "Hello, World!", 3.14159, 42 }; // Create an array with
                                                     // new operator and array initializer.

Object[] array15 = { new A(), 64, "My String" };     // Shortcut syntax 
                                                     // with array initializer.

Wie ändern Sie die Größe eines Arrays?

Die einfache Antwort ist, dass Sie das nicht tun können. Nachdem ein Array erstellt wurde, kann seine Größe nicht mehr geändert werden. Stattdessen kann ein Array nur "verkleinert" werden, indem ein neues Array mit der entsprechenden Größe erstellt und die Elemente aus dem vorhandenen Array in das neue Array kopiert werden.

String[] listOfCities = new String[3];   // array created with size 3.
listOfCities[0] = "New York";
listOfCities[1] = "London";
listOfCities[2] = "Berlin";

Nehmen Sie beispielsweise an, dass ein neues Element zu dem wie oben definierten listOfCities Array hinzugefügt werden listOfCities . Dazu müssen Sie:

1. ein neues Array mit Größe 4 erstellen,
2. Kopieren Sie die vorhandenen 3 Elemente des alten Arrays in das neue Array bei den Offsets 0, 1 und 2 und
3. Fügen Sie das neue Element im Offset 3 dem neuen Array hinzu.

Es gibt verschiedene Möglichkeiten, dies zu tun. Vor Java 6 war der prägnanteste Weg:

String[] newArray = new String[listOfCities.length + 1];
System.arraycopy(listOfCities, 0, newArray, 0, listOfCities.length);
newArray[listOfCities.length] = "Sydney";

Ab Java 6 können die Methoden Arrays.copyOf und Arrays.copyOfRange dies einfacher tun:

String[] newArray = Arrays.copyOf(listOfCities, listOfCities.length + 1);
newArray[listOfCities.length] = "Sydney";

Weitere Möglichkeiten zum Kopieren eines Arrays finden Sie im folgenden Beispiel. Beachten Sie, dass Sie bei der Größenänderung eine Array-Kopie mit einer anderen Länge als das Original benötigen.

• Arrays kopieren

Eine bessere Alternative zur Größenänderung von Arrays

Es gibt zwei Hauptnachteile bei der Größenänderung eines Arrays wie oben beschrieben:

• Es ist ineffizient. Um ein Array größer (oder kleiner) zu machen, müssen Sie viele oder alle vorhandenen Array-Elemente kopieren und ein neues Array-Objekt zuordnen. Je größer das Array, desto teurer wird es.
• Sie müssen in der Lage sein, alle "Live" -Variablen zu aktualisieren, die Verweise auf das alte Array enthalten.

Eine Alternative besteht darin, das Array mit einer ausreichend großen Größe zu erstellen, um damit zu beginnen. Dies ist nur möglich, wenn Sie diese Größe genau bestimmen können, bevor Sie das Array zuweisen . Wenn Sie dies nicht tun können, tritt das Problem der Größenänderung des Arrays erneut auf.

Die andere Alternative ist die Verwendung einer Datenstrukturklasse, die von der Java SE-Klassenbibliothek oder einer Bibliothek eines Drittanbieters bereitgestellt wird. Beispielsweise bietet das Java SE-Framework "Collections" eine Reihe von Implementierungen der List , Set und Map APIs mit unterschiedlichen Laufzeiteigenschaften. Die ArrayList Klasse ist den Leistungsmerkmalen eines einfachen Arrays am nächsten (z. B. O (N) -Suchen, O (1) Holen und Festlegen, O (N) zufälliges Einfügen und Löschen), bietet jedoch eine effizientere Größenänderung ohne das Problem der Referenzaktualisierung.

(Die Größenänderungseffizienz für ArrayList auf der Strategie, die Größe des Backing-Arrays bei jeder Größenänderung zu verdoppeln. Für einen typischen Anwendungsfall bedeutet dies, dass Sie die Größe nur gelegentlich ändern. Wenn Sie sich über die Lebensdauer der Liste amortisieren, kostet die Größenänderung Kosten Jede Einfügung ist O(1) . Bei der Größenänderung eines einfachen Arrays kann möglicherweise dieselbe Strategie verwendet werden.)

Ein Element in einem Array finden

Es gibt viele Möglichkeiten, die Position eines Werts in einem Array zu ermitteln. In den folgenden Beispielausschnitten wird davon ausgegangen, dass das Array eines der folgenden ist:

  String[] strings = new String[] { "A", "B", "C" };
  int[] ints = new int[] { 1, 2, 3, 4 };

Außerdem setzt jeder index oder index2 entweder auf den Index des erforderlichen Elements oder auf -1 wenn das Element nicht vorhanden ist.

Arrays.binarySearch (nur für sortierte Arrays)

  int index = Arrays.binarySearch(strings, "A");
  int index2 = Arrays.binarySearch(ints, 1);

Verwenden einer Arrays.asList (nur für nicht primitive Arrays)

  int index = Arrays.asList(strings).indexOf("A");
  int index2 = Arrays.asList(ints).indexOf(1);  // compilation error

Verwenden eines Stream

  int index = IntStream.range(0, strings.length)
                       .filter(i -> "A".equals(strings[i]))
                       .findFirst()
                       .orElse(-1); // If not present, gives us -1.
  // Similar for an array of primitives

Lineare Suche über eine Schleife

  int index = -1;
  for (int i = 0; i < array.length; i++) {
      if ("A".equals(array[i])) {
          index = i;
          break;
      }            
  }
  // Similar for an array of primitives

Lineare Suche mithilfe von Drittanbieter-Bibliotheken wie z. B. org.apache.commons

  int index = org.apache.commons.lang3.ArrayUtils.contains(strings, "A");
  int index2 = org.apache.commons.lang3.ArrayUtils.contains(ints, 1);

Hinweis: Die Verwendung einer direkten linearen Suche ist effizienter als das Umbrechen einer Liste.

Testen, ob ein Array ein Element enthält

Die obigen Beispiele können angepasst werden, um zu testen, ob das Array ein Element enthält, indem einfach getestet wird, ob der berechnete Index größer oder gleich Null ist.

Alternativ gibt es auch einige prägnantere Varianten:

boolean isPresent = Arrays.asList(strings).contains("A");

boolean isPresent = Stream<String>.of(strings).anyMatch(x -> "A".equals(x));

boolean isPresent = false;
for (String s : strings) {
    if ("A".equals(s)) {
        isPresent = true;
        break;
    }
}

boolean isPresent = org.apache.commons.lang3.ArrayUtils.contains(ints, 4);

Arrays sortieren

Mit dem Arrays- API können Arrays einfach sortiert werden.

import java.util.Arrays;

// creating an array with integers
int[] array = {7, 4, 2, 1, 19};
// this is the sorting part just one function ready to be used
Arrays.sort(array);
// prints [1, 2, 4, 7, 19]
System.out.println(Arrays.toString(array));

String-Arrays sortieren:

String ist kein numerisches Datum, sondern definiert seine eigene Reihenfolge, die als lexikographische Reihenfolge oder auch alphabetische Reihenfolge bezeichnet wird. Wenn Sie ein Array von String mithilfe der sort() -Methode sort() , wird das Array in die natürliche Reihenfolge sortiert, die von der Comparable-Schnittstelle definiert wird (siehe unten):

Zunehmende Reihenfolge

String[] names = {"John", "Steve", "Shane", "Adam", "Ben"};
System.out.println("String array before sorting : " + Arrays.toString(names));
Arrays.sort(names); 
System.out.println("String array after sorting in ascending order : " + Arrays.toString(names));

Ausgabe:

String array before sorting : [John, Steve, Shane, Adam, Ben]    
String array after sorting in ascending order : [Adam, Ben, John, Shane, Steve]

Absteigende Reihenfolge

Arrays.sort(names, 0, names.length, Collections.reverseOrder());
System.out.println("String array after sorting in descending order : " + Arrays.toString(names));

Ausgabe:

String array after sorting in descending order : [Steve, Shane, John, Ben, Adam]

Objektarray sortieren

Um ein Objektarray zu sortieren, müssen alle Elemente entweder die Comparable oder Comparator Schnittstelle implementieren, um die Sortierreihenfolge zu definieren.

Wir können entweder sort(Object[]) Methode ein Objekt - Array auf seiner natürlichen Reihenfolge zu sortieren, aber Sie müssen sicherstellen , dass alle Elemente im Array implementieren müssen Comparable .

Darüber hinaus müssen sie auch miteinander vergleichbar sein, z. B. e1.compareTo(e2) keine ClassCastException für die Elemente e1 und e2 im Array ClassCastException . Alternativ können Sie ein Object-Array nach der benutzerdefinierten Reihenfolge sort(T[], Comparator) , indem Sie die sort(T[], Comparator) Methode sort(T[], Comparator) verwenden, wie im folgenden Beispiel gezeigt.

// How to Sort Object Array in Java using Comparator and Comparable
Course[] courses = new Course[4];
courses[0] = new Course(101, "Java", 200);
courses[1] = new Course(201, "Ruby", 300);
courses[2] = new Course(301, "Python", 400);
courses[3] = new Course(401, "Scala", 500);
       
System.out.println("Object array before sorting : " + Arrays.toString(courses));
       
Arrays.sort(courses);
System.out.println("Object array after sorting in natural order : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.PriceComparator());
System.out.println("Object array after sorting by price : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.NameComparator());
System.out.println("Object array after sorting by name : " + Arrays.toString(courses));

Ausgabe:

Object array before sorting : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting in natural order : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by price : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by name : [#101 Java@200 , #301 Python@400 , #201 Ruby@300 , #401 Scala@500 ]

Konvertieren von Arrays zwischen Grundelementen und geschachtelten Typen

Manchmal ist eine Konvertierung von primitiven Typen in geschachtelte Typen erforderlich.

Zur Konvertierung des Arrays können Streams verwendet werden (in Java 8 und höher):

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = 
    Arrays.stream(primitiveArray).boxed().toArray(Integer[]::new);

Bei niedrigeren Versionen kann das primitive Array durchlaufen und explizit in das geschachtelte Array kopiert werden:

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = new Integer[primitiveArray.length];
for (int i = 0; i < primitiveArray.length; ++i) {
    boxedArray[i] = primitiveArray[i]; // Each element is autoboxed here
}

Ebenso kann ein Boxed Array in ein Array seines primitiven Gegenstücks konvertiert werden:

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = 
    Arrays.stream(boxedArray).mapToInt(Integer::intValue).toArray();

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = new int[boxedArray.length];
for (int i = 0; i < boxedArray.length; ++i) {
    primitiveArray[i] = boxedArray[i]; // Each element is outboxed here
}