Cómo dividir una cadena en Java

Tengo una cadena, "004-034556" , que quiero dividir en dos cadenas:

 string1=004 string2=034556 

Eso significa que la primera cadena contendrá los caracteres antes de '-' , y la segunda cadena contendrá los caracteres después de '-' . También quiero verificar si la cadena tiene '-' en ella. Si no, lanzaré una excepción. ¿Cómo puedo hacer esto?

Simplemente use el método apropiado: String#split() .

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

Tenga en cuenta que esto requiere una expresión regular , así que recuerde escapar de los caracteres especiales si es necesario.

hay 12 caracteres con significados especiales: la barra invertida \ , la línea ^ , el signo de dólar $ , el punto o el punto . , el símbolo de barra o tubo vertical | , el signo de interrogación ? , el asterisco o estrella * , el signo más + , el paréntesis de apertura ( , el paréntesis de cierre ) y el corchete de apertura [ , el corchete inicial { , Estos caracteres especiales a menudo se llaman “metacaracteres”.

Por lo tanto, si desea dividir, por ejemplo, punto / punto . lo que significa ” cualquier carácter ” en la expresión regular, use la barra invertida \ para escapar del carácter especial individual como tan split("\\.") , o use la clase de carácter [] para representar caracteres literales como esa split("[.]") , o use Pattern#quote() para escapar de toda la cadena como tan split(Pattern.quote(".")) .

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

Para probar de antemano si la cadena contiene cierto (s) carácter (es), simplemente use String#contains() .

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

Tenga en cuenta que esto no toma una expresión regular. Para eso, use String#matches() lugar.

Si desea conservar el carácter dividido en las partes resultantes, utilice la apariencia positiva . En caso de que desee que el carácter dividido termine en el lado izquierdo, use un aspecto positivo precediendo el grupo ?<= En el patrón.

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

En caso de que desee que el carácter dividido termine en el lado derecho, utilice la búsqueda anticipada positiva al anteponer ?= Group en el patrón.

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

Si desea limitar el número de partes resultantes, puede proporcionar el número deseado como segundo argumento del método split() .

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

Una alternativa para procesar la cadena directamente sería usar una expresión regular con grupos de captura. Esto tiene la ventaja de que facilita la implicación de restricciones más sofisticadas en la entrada. Por ejemplo, lo siguiente divide la cadena en dos partes y se asegura de que ambas consisten solo en dígitos:

 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"); } } 

Como el patrón está arreglado en esta instancia, puede comstackrse por adelantado y almacenarse como un miembro estático (inicializado en el tiempo de carga de la clase en el ejemplo). La expresión regular es:

 (\d+)-(\d+) 

Los paréntesis denotan los grupos de captura; la cadena que coincide con esa parte de la expresión regular se puede acceder mediante el método Match.group (), como se muestra. La \ d coincide con un solo dígito decimal, y el + significa “coincide con una o más de las expresiones anteriores.” El – no tiene ningún significado especial, por lo que solo coincide con ese carácter en la entrada. Tenga en cuenta que es necesario escapar dos veces de las barras diagonales inversas al escribir esto como una cadena de Java. Algunos otros ejemplos:

 ([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"); 

Esto dividirá tu cadena en 2 partes. El primer elemento de la matriz será la parte que contiene las cosas antes de - , y el segundo elemento de la matriz contendrá la parte de la cadena después de - .

Si la longitud de la matriz no es 2, entonces la cadena no estaba en el formato: string-string .

Mira el método split() en la clase 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("-"); 

debería hacer lo que quieras La clase de cadena tiene muchos métodos para operar con cadena.

Los requisitos dejaban lugar para la interpretación. Recomiendo escribir un método,

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

que encapsulan esta función. Por supuesto, puede usar String.split (..) como se menciona en las otras respuestas para la implementación.

Debería escribir algunas pruebas unitarias para las cadenas de entrada y los resultados y el comportamiento deseados.

Los buenos candidatos para la prueba deben incluir:

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

Con la definición de los resultados de prueba correspondientes, puede especificar el comportamiento.

Por ejemplo, si "-333" debe regresar en [,333] o si es un error. ¿Puede "333-333-33" separarse en [333,333-33] or [333-333,33] o es un error? Y así.

Asumiendo que

  • realmente no necesitas expresiones regulares para tu división
  • ya usas apache commons lang en tu aplicación

La forma más fácil es usar StringUtils # split (java.lang.String, char) . Eso es más conveniente que el proporcionado por Java de forma inmediata si no necesita expresiones regulares. Como dice su manual, funciona así:

 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"] 

Yo recomendaría usar commong-lang, ya que generalmente contiene muchas cosas que se pueden usar. Sin embargo, si no lo necesita para nada más que dividirlo, implementarlo o escaparse de la expresión regular es una mejor opción.

Use el método de división de org.apache.commons.lang.StringUtils, que puede dividir cadenas en función del carácter o cadena que desee dividir.

Firma del método:

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

En su caso, quiere dividir una cadena cuando hay un “-“.

Simplemente puede hacer lo siguiente:

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

Salida:

 004 034556 

Suponga que, si no existe en su cadena, devuelve la cadena dada y no obtendrá ninguna excepción.

Puedes probar así también

  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)); 

String Split con múltiples caracteres 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]); } } } 

Salida:

 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 

Pero no espere el mismo resultado en todas las versiones de JDK. He visto un error que existe en algunas versiones de JDK donde se ha ignorado la primera cadena nula. Este error no está presente en la última versión de JDK, pero existe en algunas versiones entre versiones finales de JDK 1.7 y 1.8 versiones anteriores.

Para casos de uso simple, String.split() debería hacer el trabajo. Si usas guayaba, también hay una clase Splitter que permite el encadenamiento de diferentes operaciones de cadena y admite 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); } } 

Puede dividir una cadena por un salto de línea usando la siguiente instrucción:

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

Puede dividir una cadena por un guión / carácter usando la siguiente instrucción:

 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 

La forma más rápida, que también consume el menor recurso podría ser:

 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 '-' } 

Una forma de hacerlo es ejecutar el String en un bucle for-each y usar el carácter de división requerido.

 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); } } 

Salida:

 The split parts of the String are: 004 034556 

No use la clase StringTokenizer ya que es una clase heredada que se conserva por razones de compatibilidad, y su uso se desaconseja en el nuevo código. Y podemos hacer uso del método de división según lo sugerido por otros también.

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

Y como se espera, se imprimirá:

 [004, 034556] 

En esta respuesta, también quiero señalar un cambio que ha tenido lugar para el método de split en Java 8 . El método String # split () hace uso de Pattern.split , y ahora eliminará las cadenas vacías al comienzo de la matriz de resultados. Observe este cambio en la documentación para Java 8:

Cuando hay una coincidencia de ancho positivo al comienzo de la secuencia de entrada, se incluye una subcadena principal vacía al comienzo de la matriz resultante. Sin embargo, una coincidencia de ancho cero al principio nunca produce dicha subcadena principal vacía.

Significa para el siguiente ejemplo:

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

obtendremos tres cadenas: [0, 0, 4] y no cuatro como fue el caso en Java 7 y antes. También mira esta pregunta similar.

Puede usar 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]; } } 

De lo contrario, puedes usar 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("-"); } } 

Aquí hay dos maneras en que dos lo logran.

FORMA 1: Como debes dividir dos números con un carácter especial, puedes usar expresiones regulares

 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()); } } } 

FORMA 2: Usar el método de división de cuerdas

 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); } } } 

Simplemente puede usar StringTokenizer para dividir una cadena en dos o más partes, independientemente de si hay algún tipo de delimitadores:

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

Mira el método split() en la clase String en 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++; } 

Aquí hay muchos ejemplos para una cadena dividida pero con un pequeño código optimizado.

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

Para resumir: hay al menos cinco formas de dividir una cadena en Java:

  1. String.split ():

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

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

     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", ","); 

De modo que puede elegir la mejor opción para usted según lo que necesite, p. Ej., Tipo de devolución (matriz, lista o iterable).

Aquí hay una gran descripción de estos métodos y los ejemplos más comunes (cómo dividir por punto, barra, signo de interrogación, etc.)

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

Como todos mencionaron, split () es la mejor opción que puede usarse en su caso. Un método alternativo puede ser el uso de subcadena ().

Para dividir una cadena, use String.split(regex) :

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

Salida:

 004 034556 

Solo quería escribir un algoritmo en lugar de usar las funciones incorporadas de 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; } 

Para dividir una cadena, usa String.split (regex). Revise los siguientes ejemplos:

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

Salida

 004 034556 

Nota Esta división (regex) toma una expresión regular como argumento, recuerde escapar de los caracteres especiales de expresiones regulares, como punto / punto.

De la documentación:

public String[] split(String regex,int limit) Divide esta cadena alrededor de las coincidencias de la expresión regular dada . La matriz devuelta por este método contiene cada subcadena de esta cadena que termina con otra subcadena que coincide con la expresión dada o finaliza al final de la cadena. Las subcadenas en la matriz están en el orden en que ocurren en esta cadena. Si la expresión no coincide con ninguna parte de la entrada, la matriz resultante tiene solo un elemento , a saber , esta cadena.

Básicamente puedes hacer algo como esto:

 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); } 

Salida:

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

Si tiene un personaje especial, puede usar Patter.quote. Si simplemente tiene el guión (-), entonces puede acortar el código:

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

Si intenta agregar otro carácter especial en lugar del guión (^) , el error generará ArrayIndexOutOfBoundsException . Para eso tienes que usar Pattern.quote .