dividida cadena no devolver resultados vacíos

Question

Estoy intentando utilizar

"value1:value2::value3".split(":"); 

El problema es que yo quiero que incluye los resultados en blanco.

Devuelve: [value1, value2, value3]
que debe ser: [value1, value2, , value3]

¿Alguien sabe la expresión regular para solucionar este problema?

Ok He encontrado la causa del problema. De hecho, me estoy leyendo un archivo de texto y contiene esta línea:

123:;~\&:ST02:M:test:M:4540145::type;12:51253:D:2.2:567766::AL:::::::2.2b 

cuando proceso esta línea de leer el archivo de texto que produce el resultado erróneo mencionado anteriormente, que es que no incluye ningún resultado vacíos en los casos Me gusta esto: :::::.

Pero cuando uso la línea anterior en un programa de prueba, no se compila y obtengo una "secuencia de escape no válida". Creo que es debido a la "\ &".

¿Existe una solución a este problema mediante el uso de una expresión regular?

Answer 1

split sí incluye partidos vacíos en el resultado, echar un vistazo a la docs here. Sin embargo, de forma predeterminada, las cadenas vacías finales (las que se encuentran al final de la matriz) se descartan. Si desea incluir estos también, intente split(":", -1).

Answer 2

Honestamente no veo el gran atractivo de la división. StringTokenizer funciona igual de bien para la mayoría de las cosas como esta y enviará fácilmente los tokens (para que pueda ver que no había nada entre ::).

Solo desearía que funcionara un poco mejor con el bucle mejorado, pero aparte de eso, no estaría de más intentarlo.

Creo que hay un truco de expresiones regulares para que tus tokens coincidentes vuelvan también, pero llevo 20 años sin aprender a usar expresiones regulares y nunca ha sido la mejor respuesta a ningún problema que he abordado (No es que lo haría de hecho lo sé, ya que nunca lo uso, pero las soluciones no regexp generalmente son demasiado fáciles de superar).

Answer 3

Creo que un StringTokenizer podría funcionar mejor para usted, YMMV.

Answer 4

Funciona para mí.

class t { 
    public static void main(String[] _) { 
     String t1 = "value1:value2::value3"; 
     String[] t2 = t1.split(":"); 
     System.out.println("t2 has "+t2.length+" elements"); 
     for (String tt : t2) System.out.println("\""+tt+"\""); 
    } 
} 

da la salida

$ java t 
t2 has 4 elements 
"value1" 
"value2" 
"" 
"value3" 

Answer 5

utilizan un límite negativo en su estado de división:

String str = "val1:val2::val3"; 
String[] st = str.split(":", -1); 
for (int i = 0; i< st.length; i++) 
    System.out.println(st[i]); 

Resultados:

val1 
val2 

val3 

Answer 6

public static void main(String[] args){ 
    String[] arr = "value1:value2::value3".split(":"); 
    for(String elm:arr){ 
    System.out.println("'"+elm+"',"); 
    } 
    System.out.println(arr.length); 
} 

grabados

'value1', 
'value2', 
'', 
'value3', 
4 

que es exactamente lo que quiere. Tu error está en otro lugar ...

Answer 7

Eso debería funcionar pero dale una oportunidad a StringTokenizer si todavía tienes problemas.

Answer 8

Usando Guava 's de clase Splitter:

Iterable<String> split = Splitter.on(':').split("value1:value2::value3"); 

Splitter no omite resultados vacíos por defecto, aunque se puede hacer que uno que lo haga. Aunque por lo que dicen otros, parece que lo que estás haciendo debería funcionar también.

Answer 9

Esto funciona,

import java.io.BufferedReader; 
import java.io.FileReader; 
import java.io.File; 
import java.io.IOException; 

public class split { 
public static void main(String[] args) 
{ 
    String data = null; 
    try { 
    BufferedReader br = new BufferedReader(new FileReader(new File("split.csv"))); 
    while((data=br.readLine())!=null) 
    { 
     System.out.println("line:"+data); 
     String[] cols = data.split(":",-1); 
     System.out.println("count:"+cols.length); 
     for(int x=0;x<cols.length;++x) 
     { 
      System.out.println("["+x+"] =("+cols[x]+")"); 
     } 
    } 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
} 
} 

Aquí es un archivo de prueba,

a:b:c:d:e 
a:b:c:d: 
a:b:c:: 
a:b::: 
a:::: 
:::: 
::::e 
:::d:e 
::c:d:e 
:b:c:d:e 
a:b:c:d:e