Come dividere una stringa in Java

Ho una stringa, "004-034556" , che voglio dividere in due stringhe:

 string1=004 string2=034556 

Ciò significa che la prima stringa conterrà i caratteri prima di '-' , e la seconda stringa conterrà i caratteri dopo '-' . Voglio anche controllare se la stringa ha '-' in essa. In caso contrario, farò un’eccezione. Come posso fare questo?

Basta usare il metodo appropriato: String#split() .

 String string = "004-034556"; String[] parts = string.split("-"); String part1 = parts[0]; // 004 String part2 = parts[1]; // 034556 

Nota che questo richiede un’espressione regolare , quindi ricorda di sfuggire ai caratteri speciali se necessario.

ci sono 12 personaggi con significati speciali: il backslash \ , il caret ^ , il simbolo del dollaro $ , il punto o punto . , il simbolo barra o tubo verticale | , il punto interrogativo ? , l’asterisco o stella * , il segno più + , la parentesi aperta ( , la parentesi chiusa ) e la parentesi quadra aperta [ , la parentesi graffa aperta { , Questi caratteri speciali sono spesso chiamati “metacaratteri”.

Quindi, se vuoi dividere per esempio punto / punto . che significa ” qualsiasi carattere ” nella regex, usa o backslash \ per sfuggire al singolo carattere speciale come ” split("\\.") , o usa la class di caratteri [] per rappresentare i caratteri letterali come ” split("[.]") , o usare Pattern#quote() per sfuggire all’intera stringa come se fosse split(Pattern.quote(".")) .

 String[] parts = string.split(Pattern.quote(".")); // Split on period. 

Per verificare in anticipo se la stringa contiene determinati caratteri, basta usare String#contains() .

 if (string.contains("-")) { // Split it. } else { throw new IllegalArgumentException("String " + string + " does not contain -"); } 

Nota, questo non richiede un’espressione regolare. Per questo, usa invece String#matches() .

Se desideri conservare il carattere suddiviso nelle parti risultanti, utilizza una soluzione positiva . Nel caso in cui si desideri che il carattere diviso si trovi nella parte sinistra, utilizzare la ricerca positiva precedendo il prefisso ?< = Gruppo sul modello.

 String string = "004-034556"; String[] parts = string.split("(?< =-)"); String part1 = parts[0]; // 004- String part2 = parts[1]; // 034556 

Nel caso in cui si desideri che il carattere di suddivisione finisca nel lato destro, utilizzare il lookahead positivo precedendo il prefisso ?= Gruppo sul modello.

 String string = "004-034556"; String[] parts = string.split("(?=-)"); String part1 = parts[0]; // 004 String part2 = parts[1]; // -034556 

Se si desidera limitare il numero di parti risultanti, è ansible fornire il numero desiderato come metodo secondo argomento di split() .

 String string = "004-034556-42"; String[] parts = string.split("-", 2); String part1 = parts[0]; // 004 String part2 = parts[1]; // 034556-42 

Un’alternativa all’elaborazione della stringa direttamente sarebbe quella di utilizzare un’espressione regolare con i gruppi di cattura. Ciò ha il vantaggio che rende semplice implicare vincoli più sofisticati sull’input. Ad esempio, il seguente divide la stringa in due parti e garantisce che entrambe consistano solo di cifre:

 import java.util.regex.Pattern; import java.util.regex.Matcher; class SplitExample { private static Pattern twopart = Pattern.compile("(\\d+)-(\\d+)"); public static void checkString(String s) { Matcher m = twopart.matcher(s); if (m.matches()) { System.out.println(s + " matches; first part is " + m.group(1) + ", second part is " + m.group(2) + "."); } else { System.out.println(s + " does not match."); } } public static void main(String[] args) { checkString("123-4567"); checkString("foo-bar"); checkString("123-"); checkString("-4567"); checkString("123-4567-890"); } } 

Poiché il modello è fisso in questa istanza, può essere compilato in anticipo e memorizzato come membro statico (inizializzato nel tempo di caricamento della class nell’esempio). L’espressione regolare è:

 (\d+)-(\d+) 

Le parentesi indicano i gruppi di cattura; la stringa che corrisponde a quella parte della regexp può essere letta dal metodo Match.group (), come mostrato. Le corrispondenze \ d e le cifre decimali singole e + indicano “corrispondono a una o più delle espressioni precedenti.” Il – non ha alcun significato speciale, quindi corrisponde solo a quel carattere nell’input. Si noti che è necessario eseguire il doppio escape dei backslash quando si scrive questo come una stringa Java. Alcuni altri esempi:

 ([AZ]+)-([AZ]+) // Each part consists of only capital letters ([^-]+)-([^-]+) // Each part consists of characters other than - ([AZ]{2})-(\d+) // The first part is exactly two capital letters, // the second consists of digits 
 String[] result = yourString.split("-"); if (result.length != 2) throw new IllegalArgumentException("String not in correct format"); 

Questo dividerà la stringa in 2 parti. Il primo elemento dell’array sarà la parte che contiene il materiale prima del - , e il secondo elemento dell’array conterrà la parte della stringa dopo il - .

Se la lunghezza dell’array non è 2, la stringa non era nel formato: string-string .

Controlla il metodo split() nella class String .

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int-

 // This leaves the regexes issue out of question // But we must remember that each character in the Delimiter String is treated // like a single delimiter public static String[] SplitUsingTokenizer(String subject, String delimiters) { StringTokenizer strTkn = new StringTokenizer(subject, delimiters); ArrayList arrLis = new ArrayList(subject.length()); while(strTkn.hasMoreTokens()) arrLis.add(strTkn.nextToken()); return arrLis.toArray(new String[0]); } 
 String[] out = string.split("-"); 

dovrebbe fare la cosa che vuoi La class stringa ha molti metodi per operare con la stringa.

I requisiti lasciavano spazio all’interpretazione. Raccomando di scrivere un metodo,

 public final static String[] mySplit(final String s) 

che incapsulano questa funzione. Ovviamente puoi usare String.split (..) come menzionato nelle altre risposte per l’implementazione.

Dovresti scrivere alcuni test unitari per le stringhe di input e i risultati e il comportamento desiderati.

I buoni candidati al test dovrebbero includere:

  - "0022-3333" - "-" - "5555-" - "-333" - "3344-" - "--" - "" - "553535" - "333-333-33" - "222--222" - "222--" - "--4555" 

Con la definizione dei risultati del test, è ansible specificare il comportamento.

Ad esempio, se "-333" dovrebbe tornare in [,333] o se si tratta di un errore. Può "333-333-33" essere separato in [333,333-33] or [333-333,33] o si tratta di un errore? E così via.

Supponendo che

  • non hai davvero bisogno di espressioni regolari per la tua divisione
  • ti capita di usare già apache commons lang nella tua app

Il modo più semplice è usare StringUtils # split (java.lang.String, char) . Questo è più conveniente di quello fornito da Java, pronto all’uso, se non hai bisogno di espressioni regolari. Come dice il suo manuale, funziona così:

 A null input String returns null. StringUtils.split(null, *) = null StringUtils.split("", *) = [] StringUtils.split("abc", '.') = ["a", "b", "c"] StringUtils.split("a..bc", '.') = ["a", "b", "c"] StringUtils.split("a:b:c", '.') = ["a:b:c"] StringUtils.split("abc", ' ') = ["a", "b", "c"] 

Vorrei raccomandare l’uso di commong-lang, poiché di solito contiene un sacco di cose che è utilizzabile. Tuttavia, se non ti serve per nient’altro che una divisione, implementare te stesso o sfuggire alla regex è un’opzione migliore.

Utilizza il metodo split org.apache.commons.lang.StringUtils che può dividere le stringhe in base al carattere o alla stringa che desideri dividere.

Firma del metodo:

 public static String[] split(String str, char separatorChar); 

Nel tuo caso, vuoi dividere una stringa quando c’è un “-“.

Puoi semplicemente fare come segue:

 String str = "004-034556"; String split[] = StringUtils.split(str,"-"); 

Produzione:

 004 034556 

Supponi che se - non esiste nella tua stringa, restituisca la stringa data, e non otterrai alcuna eccezione.

Puoi provare anche in questo modo

  String concatenated_String="hi^Hello"; String split_string_array[]=concatenated_String.split("\\^"); 

Con Java 8:

  List stringList = Pattern.compile("-") .splitAsStream("004-034556") .collect(Collectors.toList()); stringList.forEach(s -> System.out.println(s)); 

Dividere le stringhe con più caratteri usando Regex

 public class StringSplitTest { public static void main(String args[]) { String s = " ;String; String; String; String, String; String;;String;String; String; String; ;String;String;String;String"; //String[] strs = s.split("[,\\s\\;]"); String[] strs = s.split("[,\\;]"); System.out.println("Substrings length:"+strs.length); for (int i=0; i < strs.length; i++) { System.out.println("Str["+i+"]:"+strs[i]); } } } 

Produzione:

 Substrings length:17 Str[0]: Str[1]:String Str[2]: String Str[3]: String Str[4]: String Str[5]: String Str[6]: String Str[7]: Str[8]:String Str[9]:String Str[10]: String Str[11]: String Str[12]: Str[13]:String Str[14]:String Str[15]:String Str[16]:String 

Ma non aspettarti lo stesso output su tutte le versioni di JDK. Ho visto un bug che esiste in alcune versioni di JDK in cui la prima stringa nulla è stata ignorata. Questo bug non è presente nell'ultima versione di JDK, ma esiste in alcune versioni tra le versioni successive di JDK 1.7 e le prime 1.8.

Per casi di utilizzo semplice, String.split() dovrebbe eseguire il lavoro. Se si utilizza guava, esiste anche una class Splitter che consente il concatenamento di diverse operazioni con le stringhe e supporta CharMatcher :

 Splitter.on('-') .trimResults() .omitEmptyStrings() .split(string); 
 public class SplitTest { public static String[] split(String text, String delimiter) { java.util.List parts = new java.util.ArrayList(); text += delimiter; for (int i = text.indexOf(delimiter), j=0; i != -1;) { String temp = text.substring(j,i); if(temp.trim().length() != 0) { parts.add(temp); } j = i + delimiter.length(); i = text.indexOf(delimiter,j); } return parts.toArray(new String[0]); } public static void main(String[] args) { String str = "004-034556"; String delimiter = "-"; String result[] = split(str, delimiter); for(String s:result) System.out.println(s); } } 

È ansible dividere una stringa per un’interruzione di riga utilizzando la seguente istruzione:

 String textStr[] = yourString.split("\\r?\\n"); 

Puoi dividere una stringa con un trattino / carattere usando la seguente frase:

 String textStr[] = yourString.split("-"); 
 import java.io.*; public class BreakString { public static void main(String args[]) { String string = "004-034556-1234-2341"; String[] parts = string.split("-"); for(int i=0;i 

Il modo più veloce, che consuma anche la minima risorsa potrebbe essere:

 String s = "abc-def"; int p = s.indexOf('-'); if (p >= 0) { String left = s.substring(0, p); String right = s.substring(p + 1); } else { // s does not contain '-' } 

Un modo per farlo consiste nell’eseguire la stringa in un ciclo for-each e utilizzare il carattere di divisione richiesto.

 public class StringSplitTest { public static void main(String[] arg){ String str = "004-034556"; String split[] = str.split("-"); System.out.println("The split parts of the String are"); for(String s:split) System.out.println(s); } } 

Produzione:

 The split parts of the String are: 004 034556 

Si prega di non utilizzare la class StringTokenizer in quanto è una class precedente che viene mantenuta per ragioni di compatibilità e il suo utilizzo è sconsigliato nel nuovo codice. E possiamo usare il metodo split come suggerito anche da altri.

 String[] sampleTokens = "004-034556".split("-"); System.out.println(Arrays.toString(sampleTokens)); 

E come previsto, stamperà:

 [004, 034556] 

In questa risposta voglio anche sottolineare una modifica che si è verificata per il metodo split in Java 8 . Il metodo String # split () utilizza Pattern.split e ora rimuoverà le stringhe vuote all’inizio dell’array dei risultati. Si noti questa modifica nella documentazione per Java 8:

Quando all’inizio della sequenza di input è presente una corrispondenza di larghezza positiva, all’inizio della matrice risultante viene inclusa una sottostringa principale vuota. Una corrispondenza di larghezza zero all’inizio tuttavia non produce mai una sottostringa così vuota.

Significa per il seguente esempio:

 String[] sampleTokensAgain = "004".split(""); System.out.println(Arrays.toString(sampleTokensAgain)); 

otterremo tre stringhe: [0, 0, 4] e non quattro come nel caso di Java 7 e precedenti. Controlla anche questa domanda simile.

Puoi usare Split ():

 import java.io.*; public class Splitting { public static void main(String args[]) { String Str = new String("004-034556"); String[] SplittoArray = Str.split("-"); String string1 = SplittoArray[0]; String string2 = SplittoArray[1]; } } 

Altrimenti, è ansible utilizzare StringTokenizer:

 import java.util.*; public class Splitting { public static void main(String[] args) { StringTokenizer Str = new StringTokenizer("004-034556"); String string1 = Str.nextToken("-"); String string2 = Str.nextToken("-"); } } 

Ecco due modi per raggiungerlo.

MODO 1: Poiché devi dividere due numeri con un carattere speciale, puoi usare regex

 import java.util.regex.Matcher; import java.util.regex.Pattern; public class TrialClass { public static void main(String[] args) { Pattern p = Pattern.compile("[0-9]+"); Matcher m = p.matcher("004-034556"); while(m.find()) { System.out.println(m.group()); } } } 

WAY 2: utilizzo del metodo split split

 public class TrialClass { public static void main(String[] args) { String temp = "004-034556"; String [] arrString = temp.split("-"); for(String splitString:arrString) { System.out.println(splitString); } } } 

Puoi semplicemente usare StringTokenizer per dividere una stringa in due o più parti, indipendentemente dal fatto che esistano o meno dei delimitatori:

 StringTokenizer st = new StringTokenizer("004-034556", "-"); while(st.hasMoreTokens()) { System.out.println(st.nextToken()); } 

Controlla il metodo split() nella class String su javadoc.

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split(java.lang.String)

 String data = "004-034556-1212-232-232"; int cnt = 1; for (String item : data.split("-")) { System.out.println("string "+cnt+" = "+item); cnt++; } 

Qui ci sono molti esempi per la stringa divisa, ma ho un piccolo codice ottimizzato.

 String str="004-034556" String[] sTemp=str.split("-");// '-' is a delimiter string1=004 // sTemp[0]; string2=034556//sTemp[1]; 

Per riassumere: ci sono almeno cinque modi per dividere una stringa in Java:

  1. String.split ():

     String[] parts ="10,20".split(","); 
  2. Pattern.compile (regexp) .splitAsStream (ingresso):

     List strings = Pattern.compile("\\|") .splitAsStream("010|020202") .collect(Collectors.toList()); 
  3. StringTokenizer (class legacy):

     StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", "."); while(strings.hasMoreTokens()){ String substring = strings.nextToken(); System.out.println(substring); } 
  4. Google Guava Splitter:

     Iterable result = Splitter.on(",").split("1,2,3,4"); 
  5. Apache Commons StringUtils:

     String[] strings = StringUtils.split("1,2,3,4", ","); 

Quindi puoi scegliere l’opzione migliore per te in base a ciò che ti serve, ad esempio il tipo di ritorno (array, elenco o iterabile).

Ecco una grande panoramica di questi metodi e degli esempi più comuni (come dividere per punto, barra, punto interrogativo, ecc.)

 String s="004-034556"; for(int i=0;i 

Come menzionato da tutti, split () è l'opzione migliore che può essere utilizzata nel tuo caso. Un metodo alternativo può utilizzare la sottostringa ().

Per dividere una stringa, utilizzare String.split(regex) :

 String phone = "004-034556"; String[] output = phone.split("-"); System.out.println(output[0]); System.out.println(output[1]); 

Produzione:

 004 034556 

Volevo solo scrivere un algoritmo invece di utilizzare le funzioni integrate di Java:

 public static List split(String str, char c){ List list = new ArrayList<>(); StringBuilder sb = new StringBuilder(); for (int i = 0; i < str.length(); i++){ if(str.charAt(i) != c){ sb.append(str.charAt(i)); } else{ if(sb.length() > 0){ list.add(sb.toString()); sb = new StringBuilder(); } } } if(sb.length() >0){ list.add(sb.toString()); } return list; } 

Per dividere una stringa, usa String.split (regex). Esamina i seguenti esempi:

 String data = "004-034556"; String[] output = data.split("-"); System.out.println(output[0]); System.out.println(output[1]); 

Produzione

 004 034556 

Nota Questa divisione (regex) prende una espressione regolare come argomento, ricorda di evitare i caratteri speciali di espressioni regolari, come punto / punto.

Dalla documentazione:

public String[] split(String regex,int limit) Divide questa stringa attorno alle corrispondenze dell’espressione regolare data . La matrice restituita da questo metodo contiene ciascuna sottostringa di questa stringa terminata da un’altra sottostringa che corrisponde all’espressione specificata o terminata alla fine della stringa. Le sottostringhe nell’array sono nell’ordine in cui si verificano in questa stringa. Se l’espressione non corrisponde a nessuna parte dell’input, l’array risultante ha solo un elemento , ovvero questa stringa.

Fondamentalmente puoi fare qualcosa del genere:

 String s = "123-456-789-123"; // The String to be split String[] array = s.split("-"); // Split according to the hyphen and put them in an array for(String subString : array){ // Cycle through the array System.out.println(subString); } 

Produzione:

 123 456 789 123 
  String string = "004^034556-34"; String[] parts = string.split(Pattern.quote("^")); 

Se hai un personaggio speciale, puoi usare Patter.quote. Se hai semplicemente dash (-), puoi abbreviare il codice:

  String string = "004-34"; String[] parts = string.split("-"); 

Se si tenta di aggiungere un altro carattere speciale al posto di dash (^), l’errore genererà ArrayIndexOutOfBoundsException . Per questo devi usare Pattern.quote .