string separar - Cómo dividir una cadena en Java




netbeans especiales (25)

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?


Answers

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.


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.


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


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.


Puedes probar así también

 String concatenated_String="hi^Hello";

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

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

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


Con Java 8:

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

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

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


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.


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

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

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

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-


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



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

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

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

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

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

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.


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

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

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

La siguiente función también funciona y no depende de ninguna otra función; utiliza solo la manipulación de cadenas nativas de PHP. Personalmente, no lo recomiendo, pero puedes ver cómo funciona:

<?php

if (!function_exists('is_str_contain')) {
  function is_str_contain($string, $keyword)
  {
    if (empty($string) || empty($keyword)) return false;
    $keyword_first_char = $keyword[0];
    $keyword_length = strlen($keyword);
    $string_length = strlen($string);

    // case 1
    if ($string_length < $keyword_length) return false;

    // case 2
    if ($string_length == $keyword_length) {
      if ($string == $keyword) return true;
      else return false;
    }

    // case 3
    if ($keyword_length == 1) {
      for ($i = 0; $i < $string_length; $i++) {

        // Check if keyword's first char == string's first char
        if ($keyword_first_char == $string[$i]) {
          return true;
        }
      }
    }

    // case 4
    if ($keyword_length > 1) {
      for ($i = 0; $i < $string_length; $i++) {
        /*
        the remaining part of the string is equal or greater than the keyword
        */
        if (($string_length + 1 - $i) >= $keyword_length) {

          // Check if keyword's first char == string's first char
          if ($keyword_first_char == $string[$i]) {
            $match = 1;
            for ($j = 1; $j < $keyword_length; $j++) {
              if (($i + $j < $string_length) && $keyword[$j] == $string[$i + $j]) {
                $match++;
              }
              else {
                return false;
              }
            }

            if ($match == $keyword_length) {
              return true;
            }

            // end if first match found
          }

          // end if remaining part
        }
        else {
          return false;
        }

        // end for loop
      }

      // end case4
    }

    return false;
  }
}

Prueba:

var_dump(is_str_contain("test", "t")); //true
var_dump(is_str_contain("test", "")); //false
var_dump(is_str_contain("test", "test")); //true
var_dump(is_str_contain("test", "testa")); //flase
var_dump(is_str_contain("a----z", "a")); //true
var_dump(is_str_contain("a----z", "z")); //true 
var_dump(is_str_contain("mystringss", "strings")); //true 




java string