Rimuovi o sostituisci parte di una stringa in Java

1. Panoramica

In questo tutorial, esamineremo vari mezzi per rimuovere o sostituire parte di una stringa in Java.

Esploreremo la rimozione e / o la sostituzione di una sottostringa utilizzando un'API String , quindi utilizzando un'API StringBuilder e infine utilizzando la classe StringUtils della libreria Apache Commons.

Come bonus, esamineremo anche la sostituzione di una parola esatta utilizzando l'API String e la classe RegExUtils di Apache Commons .

2. String API

Uno dei metodi più semplici e diretti per sostituire una sottostringa consiste nell'usare la classe replace, replaceAll o replaceFirst of a String.

Il metodo replace () accetta due argomenti: target e testo sostitutivo:

String master = "Hello World Baeldung!"; String target = "Baeldung"; String replacement = "Java"; String processed = master.replace(target, replacement); assertTrue(processed.contains(replacement)); assertFalse(processed.contains(target));

Lo snippet di cui sopra produrrà questo output:

Hello World Java!

Se è richiesta un'espressione regolare nella scelta della destinazione, il metodo di scelta dovrebbe essere replaceAll () o replaceFirst () . Come suggerisce il nome, replaceAll () sostituirà ogni occorrenza corrispondente, mentre replaceFirst () sostituirà la prima occorrenza corrispondente:

String master2 = "Welcome to Baeldung, Hello World Baeldung"; String regexTarget = "(Baeldung)$"; String processed2 = master2.replaceAll(regexTarget, replacement); assertTrue(processed2.endsWith("Java"));

Il valore di process2 sarà:

Welcome to Baeldung, Hello World Java

È perché la regex fornita come regexTarget corrisponderà solo all'ultima occorrenza di Baeldung. In tutti gli esempi forniti sopra, possiamo usare una sostituzione vuota e rimuoverà efficacemente un bersaglio da un master .

3. API StringBuilder

Possiamo anche manipolare il testo in Java usando la classe StringBuilder . I due metodi qui sono delete () e replace () .

Possiamo costruire un'istanza di StringBuilder da una stringa esistente e quindi utilizzare i metodi menzionati per eseguire la manipolazione della stringa come desiderato:

String master = "Hello World Baeldung!"; String target = "Baeldung"; String replacement = "Java"; int startIndex = master.indexOf(target); int stopIndex = startIndex + target.length(); StringBuilder builder = new StringBuilder(master);

Ora possiamo rimuovere il target con delete () :

builder.delete(startIndex, stopIndex); assertFalse(builder.toString().contains(target));

Possiamo anche usare il replace () per aggiornare il master:

builder.replace(startIndex, stopIndex, replacement); assertTrue(builder.toString().contains(replacement));

Un'apparente differenza tra l'utilizzo di StringBuilder e l' API String è che dobbiamo ottenere noi stessi l'indice di inizio e di arresto della stringa di destinazione .

4. Classe StringUtils

Un altro metodo che prenderemo in considerazione è la libreria Apache Commons.

Innanzitutto, aggiungiamo la dipendenza richiesta al nostro progetto:

 org.apache.commons commons-lang3 3.8.1 

L'ultima versione della libreria può essere trovata qui.

La classe StringUtils ha metodi per sostituire una sottostringa di una stringa :

String master = "Hello World Baeldung!"; String target = "Baeldung"; String replacement = "Java"; String processed = StringUtils.replace(master, target, replacement); assertTrue(processed.contains(replacement));

Esiste una variante sovraccaricata di replace () che accetta un parametro max intero , che determina il numero di occorrenze da sostituire. Possiamo anche usare replaceIgnoreCase () se la distinzione tra maiuscole e minuscole non è un problema :

String master2 = "Hello World Baeldung!"; String target2 = "baeldung"; String processed2 = StringUtils.replaceIgnoreCase(master2, target2, replacement); assertFalse(processed2.contains(target));

5. Sostituzione di parole esatte

In questo ultimo esempio, impareremo come sostituire una parola esatta all'interno di una stringa .

Il modo più semplice per eseguire questa sostituzione è utilizzare un'espressione regolare con confini di parola.

L'espressione regolare del confine di parola è \ b . Racchiudere la parola desiderata all'interno di questa espressione regolare corrisponderà solo alle occorrenze esatte.

Per prima cosa, vediamo come utilizzare questa espressione regolare con l'API String:

String sentence = "A car is not the same as a carriage, and some planes can carry cars inside them!"; String regexTarget = "\\bcar\\b"; String exactWordReplaced = sentence.replaceAll(regexTarget, "truck");

La stringa exactWordReplaced contiene:

"A truck is not the same as a carriage, and some planes can carry cars inside them!"

Verrà sostituita solo la parola esatta. Si noti che la barra all'indietro deve sempre essere preceduta da caratteri di escape quando si lavora con espressioni regolari in Java.

Un modo alternativo per eseguire questa sostituzione è utilizzare la classe RegExUtils dalla Apache Commons Library, che può essere aggiunta come dipendenza come abbiamo visto nella sezione precedente:

String regexTarget = "\\bcar\\b"; String exactWordReplaced = RegExUtils.replaceAll(sentence, regexTarget, "truck"); 

Sebbene entrambi i metodi produrranno lo stesso risultato, decidere quale utilizzare dipenderà dal nostro scenario specifico.

6. Conclusione

In conclusione, abbiamo esplorato più di un modo per rimuovere e sostituire una sottostringa in Java. Il metodo migliore da applicare dipende ancora in gran parte dalla situazione e dal contesto attuali.

Come al solito, il codice sorgente completo è disponibile su Github.