Java Split está comiendo mis personajes

regex string

Question

Tengo una cadena como esta String str = "la$le//$li$lo" .

Quiero dividirlo para obtener la siguiente salida "la","le//$li","lo" . / $ Es un $ escapado por lo que debe dejarse en la salida.

Pero cuando hago str.split("[^////]//$") y obtengo "l","le//$l","lo" .

De lo que obtengo mi expresión regular es unir $ yi $ y eliminarlos luego. ¿Alguna idea de cómo recuperar mis personajes?

Gracias

Answer 1

La razón por la que se eliminan $ yi $ es que la expresión regular [^//]/$ coincide con cualquier carácter que no sea ''/' seguido de ''$''. Necesitas utilizar regular-expressions.info/Lookarounds

Este es el mismo problema que tienen las personas que tratan de encontrar q no es seguido por u.

Un primer corte en la expresión regular correcta es /(?<!//)/$/ ( "(?<!////)//$" en java)

class Test {
 public static void main(String[] args) {
  String regexp = "(?<!////)//$";
  System.out.println( java.util.Arrays.toString( "1a$1e//$li$lo".split(regexp) ) );
 }
}

Rendimientos:
[1a, 1e/$li, lo]

Answer 2

Puede intentar reemplazar primero "/ $" con otra cadena, como la codificación de URL para $ ("% 24"), y luego dividir:

String splits[] = str.replace("/$","%24").split("[^////]//$");
for(String str : splits){
   str = str.replace("%24","/$");
}

Más generalmente, si str está construido por algo como

str = a + "$" + b + "$" + c

Luego puedes URLEcodificar a, b y c antes de agregarlos juntos

import java.net.URLEncoder.encode;
...
str = encode(a) + "$" + encode(b) + "$" + encode(c)

Answer 3

Utilice aserciones coincidentes de ancho cero:

    String str = "la$le//$li$lo";
    System.out.println(java.util.Arrays.toString(
        str.split("(?<!////)//$")
    )); // prints "[la, le/$li, lo]"

La expresión regular es esencialmente

(?<!//)/$

Utiliza una mirada negativa para afirmar que no hay un / precedente.

Ver también

• regular-expressions.info/Lookarounds

Más ejemplos de división en aserciones.

División simple de oraciones, manteniendo los signos de puntuación:

    String str = "Really?Wow!This.Is.Awesome!";
    System.out.println(java.util.Arrays.toString(
        str.split("(?<=[.!?])")
    )); // prints "[Really?, Wow!, This., Is., Awesome!]"

Dividir una cadena larga en partes de longitud fija, utilizando /G

    String str = "012345678901234567890";
    System.out.println(java.util.Arrays.toString(
        str.split("(?<=//G.{4})")
    )); // prints "[0123, 4567, 8901, 2345, 6789, 0]"

Usando un combo lookbehind / lookahead:

    String str = "HelloThereHowAreYou";
    System.out.println(java.util.Arrays.toString(
        str.split("(?<=[a-z])(?=[A-Z])")
    )); // prints "[Hello, There, How, Are, You]"

Preguntas relacionadas

• ¿Se puede usar expresiones regulares de anchura cero en división de cadenas?
• Backreferences en lookbehind
• ¿Cómo convierto CamelCase en nombres legibles por humanos en Java?

Answer 4

import java.util.regex.*;
public class Test {
    public static void main(String... args) {
        String str = "la$le//$li$lo";
        Pattern p = Pattern.compile("(.+?)([^////]//$)");
        Matcher m = p.matcher(str);
        while (m.find()) {
            System.out.println(m.group(1));
            System.out.println(m.group(2));
        }
    }
}

da

l
a$
le/$l
i$