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.