separar - split java caracteres especiales

Cómo dividir una cadena en Java

Question

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?

Answer 1

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

Answer 2

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.

Answer 3

Con Java 8:

    List<String> stringList = Pattern.compile("-")
            .splitAsStream("004-034556")
            .collect(Collectors.toList());

    stringList.forEach(s -> System.out.println(s));

Answer 4

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

Answer 5

Echa un vistazo al 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í muchos ejemplos de cadena dividida pero poco código optimizado.

Answer 6

La forma más rápida, que también consume menos recursos, 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 ''-''
}

Answer 7

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í.

Answer 8

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.

Answer 9

Para casos de uso simple, String#split() debería hacer el trabajo. Si usa 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);

Answer 10

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.

Answer 11

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

Answer 12

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<String> 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. Divisor de guayaba de Google:

   Iterable<String> result = Splitter.on(",").split("1,2,3,4");

5. Apache Commons StringUtils:

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

Por lo tanto, puede elegir la mejor opción para usted dependiendo de lo que necesite, por ejemplo, tipo de retorno (matriz, lista o iterable).

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

Answer 13

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

Answer 14

Puedes probar así también

 String concatenated_String="hi^Hello";

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

Answer 15

Puedes 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];
    }
}

Si no, 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("-");
    }
}

Answer 16

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

Answer 17

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

Answer 18

Solo quería escribir un algoritmo en lugar de usar las funciones integradas de Java:

public static List<String> split(String str, char c){
    List<String> 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;
}

Answer 19

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

Answer 20

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

Answer 21

Utilice org.apache.commons.lang.StringUtils'' método dividido de org.apache.commons.lang.StringUtils'' que puede dividir cadenas según el carácter o la cadena que desea dividir.

Método de firma:

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

En su caso, desea dividir una cadena cuando hay un "-".

Simplemente puede hacer lo siguiente:

String str = "004-034556";

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

Salida:

004
034556

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

Answer 22

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.

Answer 23

 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 .

Answer 24

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

Answer 25

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 ().

Answer 26

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

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

Answer 27

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

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

Answer 28

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-

Answer 29

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

Answer 30

public class SplitTest {

    public static String[] split(String text, String delimiter) {
        java.util.List<String> parts = new java.util.ArrayList<String>();

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