Arrays in Java: Ein Referenzhandbuch

1. Einleitung

In diesem Tutorial werden wir uns eingehend mit einem Kernkonzept der Java-Sprache befassen - Arrays.

Wir werden zuerst sehen, was ein Array ist, und dann, wie man sie verwendet. Insgesamt werden wir Folgendes behandeln:

  • Beginnen Sie mit Arrays
  • Array-Elemente lesen und schreiben
  • Schleife über ein Array
  • Transformieren Sie Arrays in andere Objekte wie List oder Streams
  • Arrays sortieren, suchen und kombinieren

2. Was ist ein Array?

Zuerst müssen wir definieren, was ein Array ist. Gemäß der Java-Dokumentation ist ein Array ein Objekt, das eine feste Anzahl von Werten desselben Typs enthält . Die Elemente eines Arrays sind indiziert, dh wir können mit Zahlen ( Indizes genannt ) darauf zugreifen .

Wir können ein Array als eine nummerierte Liste von Zellen betrachten, wobei jede Zelle eine Variable ist, die einen Wert enthält. In Java beginnt die Nummerierung bei 0.

Es gibt Arrays vom primitiven Typ und Arrays vom Objekttyp. Dies bedeutet, dass wir Arrays von int, float, boolean, ... verwenden können, aber auch Arrays von String-, Object- und benutzerdefinierten Typen.

3. Einrichten eines Arrays

Nachdem die Arrays genau definiert sind, wollen wir uns mit ihren Verwendungen befassen.

Wir werden viele Themen behandeln, die uns den Umgang mit Arrays beibringen. Wir werden einige Grundlagen wie das Deklarieren und Initialisieren eines Arrays lernen, aber wir werden auch fortgeschrittenere Themen wie das Sortieren und Suchen von Arrays behandeln.

Beginnen wir zunächst mit der Deklaration und Initialisierung.

3.1. Erklärung

Wir werden mit der Erklärung beginnen. Es gibt zwei Möglichkeiten, ein Array in Java zu deklarieren:

int[] anArray;

oder:

int anOtherArray[];

Ersteres wird häufiger verwendet als Letzteres .

3.2. Initialisierung

Jetzt ist es Zeit zu sehen, wie Arrays initialisiert werden. Auch hier gibt es mehrere Möglichkeiten, ein Array zu initialisieren. Wir werden die wichtigsten hier sehen, aber dieser Artikel behandelt die Initialisierung von Arrays im Detail.

Beginnen wir mit einem einfachen Weg:

int[] anArray = new int[10];

Mit dieser Methode haben wir ein Array von zehn int- Elementen initialisiert . Beachten Sie, dass wir die Größe des Arrays angeben müssen.

Bei Verwendung dieser Methode initialisieren wir jedes Element auf seinen Standardwert , hier 0 . Wenn eine Reihe von Initialisierung Object , sind Elemente null voreingestellt.

Wir werden jetzt einen anderen Weg sehen, der uns die Möglichkeit gibt, Werte direkt beim Erstellen des Arrays festzulegen:

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

Hier haben wir ein Array mit fünf Elementen initialisiert, das die Nummern 1 bis 5 enthält. Wenn Sie diese Methode verwenden, müssen Sie nicht die Länge des Arrays angeben, sondern die Anzahl der Elemente, die dann zwischen den geschweiften Klammern deklariert werden.

4. Zugriff auf Elemente

Lassen Sie uns nun sehen, wie Sie auf die Elemente eines Arrays zugreifen. Wir können dies erreichen, indem wir eine Array-Zellenposition benötigen.

Mit diesem kleinen Codefragment wird beispielsweise 10 auf der Konsole gedruckt:

anArray[0] = 10; System.out.println(anArray[0]);

Beachten Sie, wie wir Indizes verwenden, um auf die Array-Zellen zuzugreifen. Die Zahl zwischen den Klammern ist die spezifische Position des Arrays, auf das wir zugreifen möchten.

Wenn beim Zugriff auf eine Zelle der übergebene Index negativ ist oder über die letzte Zelle hinausgeht, löst Java eine ArrayIndexOutOfBoundException aus .

Wir sollten dann darauf achten, keinen negativen Index oder einen Index zu verwenden, der größer oder gleich der Arraygröße ist .

5. Iterieren über ein Array

Der Zugriff auf Elemente nacheinander kann nützlich sein, aber wir möchten möglicherweise ein Array durchlaufen. Mal sehen, wie wir das erreichen können.

Der erste Weg ist die Verwendung der for- Schleife:

int[] anArray = new int[] {1, 2, 3, 4, 5}; for (int i = 0; i < anArray.length; i++) { System.out.println(anArray[i]); }

Dies sollte die Nummern 1 bis 5 auf die Konsole drucken. Wie wir sehen können, haben wir die Eigenschaft length verwendet . Dies ist eine öffentliche Eigenschaft, die uns die Größe des Arrays angibt.

Natürlich ist es möglich, andere Schleifenmechanismen wie while oder do while zu verwenden . Bei Java-Sammlungen ist es jedoch möglich, Arrays mithilfe der foreach- Schleife zu durchlaufen :

int[] anArray = new int[] {1, 2, 3, 4, 5}; for (int element : anArray) { System.out.println(element); }

This example is equivalent to the previous one, but we got rid of the indices boilerplate code. The foreach loop is an option when:

  • we don't need to modify the array (putting another value in an element won't modify the element in the array)
  • we don't need the indices to do something else

6. Varargs

We've already covered the basics when it comes to the creation and manipulation of arrays. Now, we'll dive into more advanced topics, beginning with varargs. As a reminder, varargs are used to pass an arbitrary number of arguments to a method:

void varargsMethod(String... varargs) {}

This method could take from 0 to an arbitrary number of String arguments. An article covering varargs can be found here.

What we have to know here is that inside the method body, a varargs parameter turns into an array. But, we can also pass an array directly as the argument. Let's see how by reusing the example method declared above:

String[] anArray = new String[] {"Milk", "Tomato", "Chips"}; varargsMethod(anArray);

Will behave the same as:

varargsMethod("Milk", "Tomato", "Chips");

7. Transforming an Array into a List

Arrays are great, but sometimes it can be handier to deal with List instead. We'll see here how to transform an array into a List.

We'll first do it the naïve way, by creating an empty list and iterating over the array to add its elements to the list:

int[] anArray = new int[] {1, 2, 3, 4, 5}; List aList = new ArrayList(); for (int element : anArray) { aList.add(element); }

But there is another way, a little bit more succinct:

Integer[] anArray = new Integer[] {1, 2, 3, 4, 5}; List aList = Arrays.asList(anArray);

The static method Arrays.asList takes a varargs argument and creates a list with the passed values. Unfortunately, this method comes with some drawbacks:

  • It's not possible to use an array of primitive types
  • We can't add or remove elements from the created list, as it'll throw an UnsupportedOperationException

8. From an Array to a Stream

We can now transform arrays into lists, but since Java 8 we have access to the Stream API and we might want to turn our arrays into Stream. Java provides us with the Arrays.stream method for that:

String[] anArray = new String[] {"Milk", "Tomato", "Chips"}; Stream aStream = Arrays.stream(anArray);

When passing an Object array to the method it will return a Stream of the matching type (e.g. Stream for an array of Integer). When passing a primitive one it will return the corresponding primitive Stream.

It's also possible to create the stream only on a subset of the array:

Stream anotherStream = Arrays.stream(anArray, 1, 3);

This will create a Stream with only “Tomato” and “Chips” Strings (the first index being inclusive while the second one is exclusive).

9. Sorting Arrays

Let's now see how to sort an array, that is rearranging its elements in a certain order. The Arrays class provides us with the sort method. A bit like the stream method, sort has a lot of overloadings.

There are overloadings to sort:

  • Primitive type arrays: which are sorted in ascending order
  • Object arrays (those Object must implement the Comparable interface): which are sorted according to the natural order (relying on the compareTo method from Comparable)
  • Generic arrays: which are sorted according to a given Comparator

In addition, it's possible to sort only a specific portion of an array (passing start and end indices to the method).

The algorithms behind the sort method are quick sort and merge sort for primitive and other arrays, respectively.

Let's see how this all work through some examples:

int[] anArray = new int[] {5, 2, 1, 4, 8}; Arrays.sort(anArray); // anArray is now {1, 2, 4, 5, 8} Integer[] anotherArray = new Integer[] {5, 2, 1, 4, 8}; Arrays.sort(anotherArray); // anotherArray is now {1, 2, 4, 5, 8} String[] yetAnotherArray = new String[] {"A", "E", "Z", "B", "C"}; Arrays.sort(yetAnotherArray, 1, 3, Comparator.comparing(String::toString).reversed()); // yetAnotherArray is now {"A", "Z", "E", "B", "C"}

10. Searching in an Array

Searching an array is pretty simple, we can loop over the array and search our element among the array elements:

int[] anArray = new int[] {5, 2, 1, 4, 8}; for (int i = 0; i < anArray.length; i++) { if (anArray[i] == 4) { System.out.println("Found at index " + i); break; } }

Here we searched for number 4 and found it at index 3.

If we have a sorted array though, we can use another solution: the binary search. The principle of binary search is explained in this article.

Fortunately, Java provides us with the Arrays.binarySearch method. We have to give it an array and an element to search.

In case of a generic array, we also have to give it the Comparator that was used to sort the array in the first place. There is again the possibility to call the method on a subset of the array.

Let's see an example of the binary search method usage:

int[] anArray = new int[] {1, 2, 3, 4, 5}; int index = Arrays.binarySearch(anArray, 4); System.out.println("Found at index " + index);

As we stored number 4 in the fourth cell, this will return index 3 as the result. Note that we used an already sorted array.

11. Concatenating Arrays

Finally, let's see how to concatenate two arrays. The idea is to create an array which length is the sum of the two arrays to concatenate. After that we have to add the elements of the first one and then the elements of the second one:

int[] anArray = new int[] {5, 2, 1, 4, 8}; int[] anotherArray = new int[] {10, 4, 9, 11, 2}; int[] resultArray = new int[anArray.length + anotherArray.length]; for (int i = 0; i < resultArray.length; i++) { resultArray[i] = (i < anArray.length ? anArray[i] : anotherArray[i - anArray.length]); }

As we can see, when the index is still lesser than the first array length we add elements from that array. Then we add elements from the second one. We can make use of the Arrays.setAll method to avoid writing a loop:

int[] anArray = new int[] {5, 2, 1, 4, 8}; int[] anotherArray = new int[] {10, 4, 9, 11, 2}; int[] resultArray = new int[anArray.length + anotherArray.length]; Arrays.setAll(resultArray, i -> (i < anArray.length ? anArray[i] : anotherArray[i - anArray.length]));

This method will set all array element according to the given function. This function associates an index with a result.

Hier ist eine dritte Option zum Zusammenführen mit Arrays: System.arraycopy . Diese Methode verwendet ein Quellarray , eine Quellposition, ein Zielarray , eine Zielposition und ein Int , das die Anzahl der zu kopierenden Elemente definiert:

System.arraycopy(anArray, 0, resultArray, 0, anArray.length); System.arraycopy(anotherArray, 0, resultArray, anArray.length, anotherArray.length);

Wie wir sehen können, kopieren wir das erste Array und dann das zweite (nach dem letzten Element des ersten).

12. Schlussfolgerung

In diesem ausführlichen Artikel haben wir grundlegende und einige fortgeschrittene Verwendungen von Arrays in Java behandelt.

Wir haben gesehen, dass Java viele Methoden bietet, um mit Arrays über die Dienstprogrammklasse Arrays umzugehen . Es gibt auch Dienstprogrammklassen zum Bearbeiten von Arrays in Bibliotheken wie Apache Commons oder Guava.

Den vollständigen Code für diesen Artikel finden Sie auf unserem GitHub.