Cuerda partida con | separador en Java

Question

que tiene una cadena que es así: 1|"value"|;

que quieren dividir esta cadena y han elegido | como separador.

Mi código es el siguiente:

String[] separated = line.split("|"); 

Lo que se ve es una matriz que contiene todos los caracteres como una sola entrada:

separated[0] = "" 
separated[1] = "1" 
separated[2] = "|" 
separated[3] = """ 
separated[4] = "v" 
separated[5] = "a" 
... 

¿Alguien sabe por qué? No se puede dividir una cadena con |?

Answer 1

| se trata como un OR en RegEx. Por lo que necesita para escapar de ella:

String[] separated = line.split("\\|"); 

Answer 2

Prueba esto: String[] separated = line.split("\\|");

Mi respuesta es mejor. Corregí la ortografía de "separado" :)

Además, ¿la razón de esto funciona? | significa "O" en expresiones regulares. Tienes que escapar de eso.

Answer 3

String.split() usa expresiones regulares, por lo que debe escapar de '|' como .split ("\\ |");

Answer 4

Tienes que escapar del | porque tiene un significado especial en una expresión regular. Eche un vistazo al método split(..).

String[] sep = line.split("\\|"); 

El segundo \ se utiliza para escapar de la | y la primera \ se utiliza para escapar de la segunda \ :).

Answer 5

Escape the pipe. Funciona.

String.split("\\|"); 

El tubo es un carácter especial en el significado de expresiones regulares O

Answer 6

El parámetro a split método es una expresión regular, como se puede leer here. Como | tiene un significado especial en las expresiones regulares, necesita escapar de él. Después, el código tiene este aspecto (como han demostrado ya):

String[] separated = line.split("\\|"); 

Answer 7

no va a funcionar de esta manera, porque usted tiene que escapar del techo | primero. El siguiente código de ejemplo, que se encuentra en (http://www.rgagnon.com/javadetails/java-0438.html) muestra un ejemplo.

public class StringSplit { 
    public static void main(String args[]) throws Exception{ 
    String testString = "Real|How|To"; 
    // bad 
    System.out.println(java.util.Arrays.toString(
     testString.split("|") 
    )); 
    // output : [, R, e, a, l, |, H, o, w, |, T, o] 

    // good 
    System.out.println(java.util.Arrays.toString(
     testString.split("\\|") 
    )); 
    // output : [Real, How, To] 
    } 
} 

Answer 8

| significa O en expresiones regulares, deberías escapar de él. Además, un solo '\', obtienes '\ |' no significa nada en la cadena de Java. Por lo tanto, también debería escapar del '\' en sí mismo, lo que produce '\ |'.

¡Buena suerte!

Answer 9

public class StringUtil { 

    private static final String HT = "\t"; 
    private static final String CRLF = "\r\n"; 

    // This class cannot be instantiated 
    private StringUtil() { 
    } 

    /** 
    * Split the string into an array of strings using one of the separator in 
    * 'sep'. 
    * 
    * @param s 
    *   the string to tokenize 
    * @param sep 
    *   a list of separator to use 
    * 
    * @return the array of tokens (an array of size 1 with the original string 
    *   if no separator found) 
    */ 
    public static String[] split(final String s, final String sep) { 
    // convert a String s to an Array, the elements 
    // are delimited by sep 
    final Vector<Integer> tokenIndex = new Vector<Integer>(10); 
    final int len = s.length(); 
    int i; 

    // Find all characters in string matching one of the separators in 'sep' 
    for (i = 0; i < len; i++) 
     if (sep.indexOf(s.charAt(i)) != -1) 
     tokenIndex.addElement(new Integer(i)); 

    final int size = tokenIndex.size(); 
    final String[] elements = new String[size + 1]; 

    // No separators: return the string as the first element 
    if (size == 0) 
     elements[0] = s; 
    else { 
     // Init indexes 
     int start = 0; 
     int end = (tokenIndex.elementAt(0)).intValue(); 
     // Get the first token 
     elements[0] = s.substring(start, end); 

     // Get the mid tokens 
     for (i = 1; i < size; i++) { 
     // update indexes 
     start = (tokenIndex.elementAt(i - 1)).intValue() + 1; 
     end = (tokenIndex.elementAt(i)).intValue(); 
     elements[i] = s.substring(start, end); 
     } 
     // Get last token 
     start = (tokenIndex.elementAt(i - 1)).intValue() + 1; 
     elements[i] = (start < s.length()) ? s.substring(start) : ""; 
    } 

    return elements; 
    } 

} 

Answer 10

puede reemplazar el tubo con otro personaje como '#' antes de spliting, prueba este

String[] seperated = line.replace('|','#').split("#");