Operazioni comuni sulle stringhe in Java

1. Introduzione

I valori e le operazioni basati su stringhe sono abbastanza comuni nello sviluppo quotidiano e qualsiasi sviluppatore Java deve essere in grado di gestirli.

In questo tutorial, forniremo un breve cheat sheet delle operazioni String comuni .

Inoltre, faremo luce sulle differenze tra uguale e "==" e tra StringUtils # isBlank e # isEmpty.

2. Trasformare un carattere in una stringa

Un carattere rappresenta un carattere in Java. Ma nella maggior parte dei casi, abbiamo bisogno di una stringa.

Quindi iniziamo trasformando i caratteri in String s :

String toStringWithConcatenation(final char c) { return String.valueOf(c); }

3. Aggiunta di stringhe

Un'altra operazione frequentemente necessaria è l'aggiunta di stringhe con altri valori, come un carattere :

String appendWithConcatenation(final String prefix, final char c) { return prefix + c; }

Siamo in grado di aggiungere altri tipi di base con uno StringBuilder così :

String appendWithStringBuilder(final String prefix, final char c) { return new StringBuilder(prefix).append(c).toString(); }

4. Ottenere un personaggio per indice

Se dobbiamo estrarre un carattere da una stringa, l'API fornisce tutto ciò che vogliamo:

char getCharacterByIndex(final String text, final int index) { return text.charAt(index); }

Poiché una stringa utilizza un carattere [] come struttura dati di supporto, l'indice inizia da zero .

5. Gestione dei valori ASCII

Possiamo facilmente passare da un carattere alla sua rappresentazione numerica (ASCII) eseguendo il cast:

int asciiValue(final char character) { return (int) character; } char fromAsciiValue(final int value) { Assert.isTrue(value >= 0 && value < 65536, "value is not a valid character"); return (char) value; }

Ovviamente, poiché un int è 4 byte senza segno e un carattere è 2 byte senza segno, dobbiamo controllare per assicurarci che stiamo lavorando con valori di carattere legali.

6. Rimozione di tutti gli spazi bianchi

A volte dobbiamo sbarazzarci di alcuni caratteri, più comunemente spazi bianchi. Un buon modo è usare il metodo replaceAll con un'espressione regolare:

String removeWhiteSpace(final String text) { return text.replaceAll("\\s+", ""); }

7. Unione di raccolte a una stringa

Un altro caso d'uso comune è quando abbiamo una sorta di raccolta e vogliamo creare una stringa da essa:

 String fromCollection(final Collection collection) { return collection.stream().map(Objects::toString).collect(Collectors.joining(", ")); }

Si noti che Collectors.joining consente di specificare il prefisso o il suffisso.

8. Divisione di una stringa

O d'altra parte, possiamo dividere una stringa con un delimitatore usando il metodo split :

String[] splitByRegExPipe(final String text)  return text.split("\\

Di nuovo, stiamo usando un'espressione regolare qui, questa volta per dividere con una pipe. Dato che vogliamo usare un carattere speciale, dobbiamo evitarlo.

Un'altra possibilità è usare la classe Pattern :

String[] splitByPatternPipe(final String text) ")); 

9. Elaborazione di tutti i caratteri come flusso

In caso di elaborazione dettagliata, possiamo trasformare una stringa in un IntStream :

IntStream getStream(final String text) { return text.chars(); }

10. Uguaglianza di riferimento e uguaglianza di valore

Sebbene le stringhe sembrino un tipo primitivo, non lo sono.

Pertanto, dobbiamo distinguere tra uguaglianza di riferimento e uguaglianza di valore. L'uguaglianza di riferimento implica sempre l'uguaglianza di valori, ma in generale non il contrario. Il primo, controlliamo con l'operazione '==' e il secondo, con il metodo uguale :

@Test public void whenUsingEquals_thenWeCheckForTheSameValue() { assertTrue("Values are equal", new String("Test").equals("Test")); } @Test public void whenUsingEqualsSign_thenWeCheckForReferenceEquality() { assertFalse("References are not equal", new String("Test") == "Test"); }

Si noti che i letterali sono internati nel pool di stringhe. Pertanto il compilatore può a volte ottimizzarli allo stesso riferimento:

@Test public void whenTheCompileCanBuildUpAString_thenWeGetTheSameReference() { assertTrue("Literals are concatenated by the compiler", "Test" == "Te"+"st"); }

11. Stringa vuota e stringa vuota

C'è una sottile differenza tra isBlank e isEmpty .

Una stringa è vuota se è nulla o ha lunghezza zero. Mentre una stringa è vuota se è nulla o contiene solo spazi vuoti:

@Test public void whenUsingIsEmpty_thenWeCheckForNullorLengthZero() { assertTrue("null is empty", isEmpty(null)); assertTrue("nothing is empty", isEmpty("")); assertFalse("whitespace is not empty", isEmpty(" ")); assertFalse("whitespace is not empty", isEmpty("\n")); assertFalse("whitespace is not empty", isEmpty("\t")); assertFalse("text is not empty", isEmpty("Anything!")); } @Test public void whenUsingIsBlank_thenWeCheckForNullorOnlyContainingWhitespace() { assertTrue("null is blank", isBlank(null)); assertTrue("nothing is blank", isBlank("")); assertTrue("whitespace is blank", isBlank("\t\t \t\n\r")); assertFalse("test is not blank", isBlank("Anything!")); }

12. Conclusione

Le stringhe sono un tipo fondamentale in tutti i tipi di applicazioni. In questo tutorial abbiamo imparato alcune operazioni chiave in scenari comuni.

Inoltre, abbiamo fornito indicazioni per riferimenti più dettagliati.

Infine, il codice completo con tutti gli esempi è disponibile nel nostro repository GitHub.