separar - Cómo dividir una cadena en Java




split java netbeans (20)

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 comprobar si la cadena tiene '-' en ella. Si no, lanzaré una excepción. ¿Cómo puedo hacer esto?

https://code.i-harness.com


Aquí hay dos maneras en que dos lo logran.

FORMA 1: Como tiene que dividir dos números por un carácter especial, puede 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());
        }
    }
}

MANERA 2: Usando el método de división de cadenas

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

Asumiendo que

  • Realmente no necesitas expresiones regulares para tu división
  • Por casualidad 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 que proporciona Java de inmediato 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("a.b.c", '.')    = ["a", "b", "c"]
 StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
 StringUtils.split("a:b:c", '.')    = ["a:b:c"]
 StringUtils.split("a b c", ' ')    = ["a", "b", "c"]

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 hacer una división, entonces implementarse o escapar de la expresión regular es una mejor opción.


De la documentación:

public String[] split(String regex,int limit) Divide esta cadena alrededor de 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 termina al final de la cadena. Las subcadenas de la matriz están en el orden en que aparecen 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


Los requisitos dejaron espacio 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.

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

Los buenos candidatos a prueba deben incluir:

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

Al definir los resultados de las pruebas correspondientes, puede especificar el comportamiento.

Por ejemplo, si "-333" debería regresar en [,333] o si es un error. ¿ "333-333-33" puede separar "333-333-33" en [333,333-33] or [333-333,33] o es un error? Y así.


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

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

Y como era de esperar 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() utiliza Pattern.split , y ahora eliminará cadenas vacías al comienzo de la matriz de resultados. Note este change en la documentación para Java 8:

Cuando hay una coincidencia de ancho positivo al principio de la secuencia de entrada, se incluye una subcadena inicial vacía al principio de la matriz resultante. Una coincidencia de ancho cero al principio, sin embargo, nunca produce una subcadena inicial 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 anteriores. También revise esta question similar.


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 (expresión regular) toma una expresión regular como un argumento, recuerde escapar de los caracteres especiales de expresión regular, como punto / punto.


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

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

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

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

String textStr[] = yourString.split("-");

Puedes probar así también

 String concatenated_String="hi^Hello";

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

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

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

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 caracteres especiales si es necesario.

hay 12 caracteres con significados especiales: la barra diagonal inversa \ , el carácter intercalado ^ , el signo de dólar $ , el punto o punto . , la barra vertical o el símbolo de la tubería | , el signo de interrogacion ? , el asterisco o estrella * , el signo más + , el paréntesis de apertura ( , el paréntesis de cierre ) y el corchete de apertura [ , la llave de apertura { , estos caracteres especiales a menudo se llaman "metacaracteres".

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

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

Para probar de antemano si la cadena contiene ciertos caracteres, solo use la String#contains() .

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

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

Si desea conservar el carácter dividido en las partes resultantes, entonces utilice el lookaround positivo . En caso de que desee que el carácter dividido termine en el lado izquierdo, use la apariencia positiva detrás del prefijo ?<= 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, use lookahead positivo prefijando ?= Grupo 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 piezas 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 al procesamiento de la cadena directamente sería utilizar una expresión regular con grupos de captura. Esto tiene la ventaja de que hace que sea sencillo implicar restricciones más sofisticadas en la entrada. Por ejemplo, lo siguiente divide la cadena en dos partes y asegura que ambas constan solo de 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 se fija en esta instancia, se puede compilar por adelantado y almacenar como un miembro estático (inicializado en el tiempo de carga de clase en el ejemplo). La expresión regular es:

(\d+)-(\d+)

Los paréntesis denotan los grupos de captura; Se puede acceder a la cadena que coincide con esa parte de la expresión regular mediante el método Match.group (), como se muestra. Las coincidencias \ d y un solo dígito decimal, y el + significa "coincidir con una o más de la expresión anterior). La - no tiene un significado especial, por lo que solo coincide con ese carácter en la entrada. Tenga en cuenta que debe hacer doble clic en las barras diagonales inversas. al escribir esto como una cadena Java. Algunos otros ejemplos:

([A-Z]+)-([A-Z]+)          // Each part consists of only capital letters 
([^-]+)-([^-]+)            // Each part consists of characters other than -
([A-Z]{2})-(\d+)           // The first part is exactly two capital letters,
                           // the second consists of digits

Una forma de hacerlo es correr a través de la Cadena en un bucle para cada uno y usar el carácter dividido 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

String Split con múltiples personajes 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 JDK 1.7 versiones anteriores y 1.8 versiones anteriores.


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

Si tiene un carácter especial, puede utilizar Patter.quote. Si simplemente tiene un 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 de guión (^) , el error generará ArrayIndexOutOfBoundsException . Para eso tienes que usar Pattern.quote .


String s="004-034556";
for(int i=0;i<s.length();i++)
{
    if(s.charAt(i)=='-')
    {
        System.out.println(s.substring(0,i));
        System.out.println(s.substring(i+1));
    }
}

Como mencionó todo el mundo, split () es la mejor opción que se puede usar en su caso. Un método alternativo puede ser usar subcadena ().


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

string1=004 // sTemp[0];
string2=034556//sTemp[1];

String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

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

Si la longitud de la matriz no es 2, entonces la cadena no tenía el formato: string-string .

Echa un vistazo al método split() en la clase String .

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


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<parts.length;i++) {
      System.out.println(parts[i]);
    }
  }
}




string