Elaborazione di array con Apache Commons Lang 3

1. Panoramica

La libreria Apache Commons Lang 3 fornisce il supporto per la manipolazione delle classi principali delle API Java. Questo supporto include metodi per la gestione di stringhe, numeri, date, concorrenza, riflessione di oggetti e altro.

In questo breve tutorial, ci concentreremo sull'elaborazione di array con l'utilissima classe di utilità ArrayUtils .

2. Dipendenza da Maven

Per utilizzare la libreria Commons Lang 3, è sufficiente estrarla dal repository Maven centrale utilizzando la seguente dipendenza:

 org.apache.commons commons-lang3 3.5 

Puoi trovare l'ultima versione di questa libreria qui.

3. ArrayUtils

La classe ArrayUtils fornisce metodi di utilità per lavorare con gli array. Questi metodi tentano di gestire l'input con grazia impedendo la generazione di un'eccezione quando viene passato un valore null .

Questa sezione illustra alcuni metodi definiti nella classe ArrayUtils . Nota che tutti questi metodi possono funzionare con qualsiasi tipo di elemento.

Per comodità, i loro gusti sovraccarichi sono anche definiti per la gestione di array contenenti tipi primitivi.

4. aggiungi e aggiungi tutto

Il metodo add copia un dato array e inserisce un dato elemento in una data posizione nel nuovo array. Se la posizione non è specificata, il nuovo elemento viene aggiunto alla fine della matrice.

Il seguente frammento di codice inserisce il numero zero nella prima posizione dell'array oldArray e verifica il risultato:

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

Se la posizione non è specificata, l'elemento aggiuntivo viene aggiunto alla fine di oldArray :

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

Il metodo addAll aggiunge tutti gli elementi alla fine di un dato array. Il frammento seguente illustra questo metodo e conferma il risultato:

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. remove e removeAll

Il metodo remove rimuove un elemento in una posizione specificata da un dato array. Tutti gli elementi successivi vengono spostati a sinistra. Nota che questo è vero per tutte le operazioni di rimozione.

Questo metodo restituisce un nuovo array invece di apportare modifiche a quello originale:

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

Il metodo removeAll rimuove tutti gli elementi nelle posizioni specificate da un dato 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 e removeElements

Il metodo removeElement rimuove la prima occorrenza di un elemento specificato da un dato array.

Invece di lanciare un'eccezione, l'operazione di rimozione viene ignorata se tale elemento non esiste nell'array dato:

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

Il metodo removeElements rimuove le prime occorrenze di elementi specificati da un dato array.

Invece di generare un'eccezione, l'operazione di rimozione viene ignorata se un elemento specificato non esiste nell'array dato:

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

7. L' API removeAllOccurences

Il metodo removeAllOccurences rimuove tutte le occorrenze dell'elemento specificato dalla matrice data.

Invece di lanciare un'eccezione, l'operazione di rimozione viene ignorata se tale elemento non esiste nell'array dato:

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

8. Il contiene API

Il metodo contiene controlla se esiste un valore in un dato array. Ecco un esempio di codice, inclusa la verifica del risultato:

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. L' API inversa

Il metodo reverse inverte l'ordine degli elementi all'interno di un intervallo specificato di un dato array. Questo metodo apporta modifiche all'array passato invece di restituirne uno nuovo.

Diamo uno sguardo veloce:

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

Se non viene specificato un intervallo, l'ordine di tutti gli elementi viene invertito:

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

10. The shift API

The shift method shifts a series of elements in a given array a number of positions. This method makes changes to the passed-in array instead of returning a new one.

The following code fragment shifts all elements between the elements at index 1 (inclusive) and index 4 (exclusive) one position to the right and confirms the result:

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

If the range boundaries are not specified, all elements of the array are shifted:

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

11. The subarray API

The subarray method creates a new array containing elements within a specified range of the given array. The following is an example of an assertion of the result:

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.

Come sempre, l'implementazione di tutti gli esempi e frammenti di codice sopra riportati può essere trovata nel progetto GitHub.