Pregunta Cómo dividir una cadena en Java


Tengo una cuerda, "004-034556", que quiero dividirme en dos cadenas:

string1=004
string2=034556

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


1278
2017-08-14 03:01


origen


Respuestas:


Solo usa 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 recuerda escapar caracteres especiales si necesario.

ahí son 12 caracteres con significados especiales: la barra invertida \, el cursor ^, el signo de dólar $, el punto o punto ., el símbolo de barra vertical o tubo |, el signo de interrogación ?, el asterisco o la 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 personaje"en expresiones regulares, usa cualquiera barra invertida \ escapar del personaje especial individual como tal split("\\."), o usar clase de personaje [] representar caracteres literales como tal split("[.]"), o usar Pattern#quote() para escapar de la cadena completa como tal split(Pattern.quote(".")).

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

Para probar de antemano si la cadena contiene cierto carácter (s), solo 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, usa String#matches() en lugar.

Si desea conservar el carácter dividido en las partes resultantes, haga uso de mirada positiva. En caso de que desee que el carácter dividido termine en el lado izquierdo, use un aspecto positivo 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 la búsqueda anticipada positiva mediante el prefijo ?= 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 partes resultantes, puede proporcionar el número deseado como segundo argumento de split() método.

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

2349
2017-08-14 03:05



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 compilarse 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:

([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

68
2017-08-14 11:28



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 en la matriz será la parte que contiene las cosas antes de la -, y el segundo elemento de la matriz contendrá la parte de su cadena después del -.

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

Revisar la split() método en el String clase.

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


39
2017-08-14 03:06



// 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<String> arrLis = new ArrayList<String>(subject.length());

   while(strTkn.hasMoreTokens())
      arrLis.add(strTkn.nextToken());

   return arrLis.toArray(new String[0]);
}

26
2017-11-16 06:30



String[] out = string.split("-");

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


23
2017-08-14 03:06



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" debería regresar en [,333] o si es un error Poder "333-333-33" separarse en [333,333-33] or [333-333,33] o es un error? Y así.


17
2017-08-14 06:57



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

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.


15
2018-03-25 06:43