Array-Verarbeitung mit Apache Commons Lang 3

1. Übersicht

Die Apache Commons Lang 3-Bibliothek bietet Unterstützung für die Manipulation von Kernklassen der Java-APIs. Diese Unterstützung umfasst Methoden zum Behandeln von Zeichenfolgen, Zahlen, Datumsangaben, Parallelität, Objektreflexion und mehr.

In diesem kurzen Tutorial konzentrieren wir uns auf die Array-Verarbeitung mit der sehr nützlichen ArrayUtils- Dienstprogrammklasse.

2. Maven-Abhängigkeit

Um die Commons Lang 3-Bibliothek zu verwenden, ziehen Sie sie einfach mit der folgenden Abhängigkeit aus dem zentralen Maven-Repository:

 org.apache.commons commons-lang3 3.5 

Die neueste Version dieser Bibliothek finden Sie hier.

3. ArrayUtils

Die ArrayUtils- Klasse bietet Dienstprogrammmethoden für die Arbeit mit Arrays. Diese Methoden versuchen, die Eingabe ordnungsgemäß zu verarbeiten, indem sie verhindern, dass eine Ausnahme ausgelöst wird, wenn ein Nullwert übergeben wird.

Dieser Abschnitt zeigt einige Methoden, die in der ArrayUtils- Klasse definiert sind. Beachten Sie, dass alle diese Methoden mit jedem Elementtyp funktionieren können.

Der Einfachheit halber sind ihre überladenen Aromen auch für die Handhabung von Arrays definiert, die primitive Typen enthalten.

4. add und addAll

Die add- Methode kopiert ein bestimmtes Array und fügt ein bestimmtes Element an einer bestimmten Position in das neue Array ein. Wenn die Position nicht angegeben wird, wird das neue Element am Ende des Arrays hinzugefügt.

Das folgende Codefragment fügt die Zahl Null an der ersten Position des oldArray- Arrays ein und überprüft das Ergebnis:

int[] oldArray = { 2, 3, 4, 5 }; int[] newArray = ArrayUtils.add(oldArray, 0, 1); int[] expectedArray = { 1, 2, 3, 4, 5 }; assertArrayEquals(expectedArray, newArray);

Wenn die Position nicht angegeben wird, wird das zusätzliche Element am Ende von oldArray hinzugefügt :

int[] oldArray = { 2, 3, 4, 5 }; int[] newArray = ArrayUtils.add(oldArray, 1); int[] expectedArray = { 2, 3, 4, 5, 1 }; assertArrayEquals(expectedArray, newArray);

Die addAll- Methode fügt alle Elemente am Ende eines bestimmten Arrays hinzu. Das folgende Fragment veranschaulicht diese Methode und bestätigt das Ergebnis:

int[] oldArray = { 0, 1, 2 }; int[] newArray = ArrayUtils.addAll(oldArray, 3, 4, 5); int[] expectedArray = { 0, 1, 2, 3, 4, 5 }; assertArrayEquals(expectedArray, newArray);

5. entfernen und entfernenAlle

Die Methode remove entfernt ein Element an einer bestimmten Position aus einem bestimmten Array. Alle nachfolgenden Elemente werden nach links verschoben. Beachten Sie, dass dies für alle Entfernungsvorgänge gilt.

Diese Methode gibt ein neues Array zurück, anstatt Änderungen am ursprünglichen Array vorzunehmen:

int[] oldArray = { 1, 2, 3, 4, 5 }; int[] newArray = ArrayUtils.remove(oldArray, 1); int[] expectedArray = { 1, 3, 4, 5 }; assertArrayEquals(expectedArray, newArray);

Die removeAll- Methode entfernt alle Elemente an bestimmten Positionen aus einem bestimmten Array:

int[] oldArray = { 1, 2, 3, 4, 5 }; int[] newArray = ArrayUtils.removeAll(oldArray, 1, 3); int[] expectedArray = { 1, 3, 5 }; assertArrayEquals(expectedArray, newArray);

6. removeElement und removeElements

Die removeElement- Methode entfernt das erste Vorkommen eines angegebenen Elements aus einem bestimmten Array.

Anstatt eine Ausnahme auszulösen, wird die Entfernungsoperation ignoriert, wenn ein solches Element im angegebenen Array nicht vorhanden ist:

int[] oldArray = { 1, 2, 3, 3, 4 }; int[] newArray = ArrayUtils.removeElement(oldArray, 3); int[] expectedArray = { 1, 2, 3, 4 }; assertArrayEquals(expectedArray, newArray);

Die removeElements- Methode entfernt die ersten Vorkommen angegebener Elemente aus einem bestimmten Array.

Anstatt eine Ausnahme auszulösen, wird der Entfernungsvorgang ignoriert, wenn ein bestimmtes Element im angegebenen Array nicht vorhanden ist:

int[] oldArray = { 1, 2, 3, 3, 4 }; int[] newArray = ArrayUtils.removeElements(oldArray, 2, 3, 5); int[] expectedArray = { 1, 3, 4 }; assertArrayEquals(expectedArray, newArray);

7. Die removeAllOccurences- API

Die Methode removeAllOccurences entfernt alle Vorkommen des angegebenen Elements aus dem angegebenen Array.

Anstatt eine Ausnahme auszulösen, wird die Entfernungsoperation ignoriert, wenn ein solches Element im angegebenen Array nicht vorhanden ist:

int[] oldArray = { 1, 2, 2, 2, 3 }; int[] newArray = ArrayUtils.removeAllOccurences(oldArray, 2); int[] expectedArray = { 1, 3 }; assertArrayEquals(expectedArray, newArray);

8. Die enthält API

Die Methode enthält prüft, ob in einem bestimmten Array ein Wert vorhanden ist. Hier ist ein Codebeispiel, einschließlich der Überprüfung des Ergebnisses:

int[] array = { 1, 3, 5, 7, 9 }; boolean evenContained = ArrayUtils.contains(array, 2); boolean oddContained = ArrayUtils.contains(array, 7); assertEquals(false, evenContained); assertEquals(true, oddContained);

9. Die umgekehrte API

Die umgekehrte Methode kehrt die Elementreihenfolge innerhalb eines bestimmten Bereichs eines bestimmten Arrays um. Diese Methode nimmt Änderungen am übergebenen Array vor, anstatt ein neues zurückzugeben.

Werfen wir einen kurzen Blick darauf:

int[] originalArray = { 1, 2, 3, 4, 5 }; ArrayUtils.reverse(originalArray, 1, 4); int[] expectedArray = { 1, 4, 3, 2, 5 }; assertArrayEquals(expectedArray, originalArray);

Wenn kein Bereich angegeben ist, wird die Reihenfolge aller Elemente umgekehrt:

int[] originalArray = { 1, 2, 3, 4, 5 }; ArrayUtils.reverse(originalArray); int[] expectedArray = { 5, 4, 3, 2, 1 }; assertArrayEquals(expectedArray, originalArray);

10. Die Shift- API

Die Verschiebungsmethode verschiebt eine Reihe von Elementen in einem gegebenen Array um eine Anzahl von Positionen. Diese Methode nimmt Änderungen am übergebenen Array vor, anstatt ein neues zurückzugeben.

Das folgende Codefragment verschiebt alle Elemente zwischen den Elementen bei Index 1 (einschließlich) und Index 4 (exklusiv) um eine Position nach rechts und bestätigt das Ergebnis:

int[] originalArray = { 1, 2, 3, 4, 5 }; ArrayUtils.shift(originalArray, 1, 4, 1); int[] expectedArray = { 1, 4, 2, 3, 5 }; assertArrayEquals(expectedArray, originalArray);

Wenn die Bereichsgrenzen nicht angegeben sind, werden alle Elemente des Arrays verschoben:

int[] originalArray = { 1, 2, 3, 4, 5 }; ArrayUtils.shift(originalArray, 1); int[] expectedArray = { 5, 1, 2, 3, 4 }; assertArrayEquals(expectedArray, originalArray);

11. Die Subarray- API

Die Subarray- Methode erstellt ein neues Array, das Elemente innerhalb eines bestimmten Bereichs des angegebenen Arrays enthält. Das Folgende ist ein Beispiel für eine Behauptung des Ergebnisses:

int[] oldArray = { 1, 2, 3, 4, 5 }; int[] newArray = ArrayUtils.subarray(oldArray, 2, 7); int[] expectedArray = { 3, 4, 5 }; assertArrayEquals(expectedArray, newArray);

Notice that when the passed-in index is greater than the length of the array, it is demoted to the array length rather than having the method throw an exception. Similarly, if a negative index is passed in, it is promoted to zero.

12. The swap API

The swap method swaps a series of elements at specified positions in the given array.

The following code fragment swaps two groups of elements starting at the indexes 0 and 3, with each group containing two elements:

int[] originalArray = { 1, 2, 3, 4, 5 }; ArrayUtils.swap(originalArray, 0, 3, 2); int[] expectedArray = { 4, 5, 3, 1, 2 }; assertArrayEquals(expectedArray, originalArray);

If no length argument is passed in, only one element at each position is swapped:

int[] originalArray = { 1, 2, 3, 4, 5 }; ArrayUtils.swap(originalArray, 0, 3); int[] expectedArray = { 4, 2, 3, 1, 5 }; assertArrayEquals(expectedArray, originalArray);

13. Conclusion

This tutorial introduces the core array processing utility in Apache Commons Lang 3 – ArrayUtils.

Wie immer finden Sie die Implementierung aller oben angegebenen Beispiele und Codefragmente im GitHub-Projekt.