Compruebe si la cadena termina con cierto patrón

6 minutos de lectura

avatar de usuario
el aprendiz

Si tengo una cadena como:

This.is.a.great.place.too.work.

o:

This/is/a/great/place/too/work/

que mi programa debería darme que la oración es válida y tiene “trabajo”.

Si tengo :

This.is.a.great.place.too.work.hahahha

o:

This/is/a/great/place/too/work/hahahah

entonces mi programa no debería darme que hay un “trabajo” en la oración.

Así que estoy mirando las cadenas de Java para encontrar una palabra al final de la oración que tenga . o , o / antes de eso. ¿Cómo puedo conseguir esto?

  • Tiene algunas excelentes respuestas a continuación, @Learner; debe seleccionar uno y marcarlo como la respuesta.

    – james.garriss

    23 de agosto de 2013 a las 16:16


avatar de usuario
pb2q

Esto es realmente simple, el String objeto tiene un endsWith método.

Según tu pregunta, parece que quieres /, , o . como conjunto delimitador.

Asi que:

String str = "This.is.a.great.place.to.work.";

if (str.endsWith(".work.") || str.endsWith("/work/") || str.endsWith(",work,"))
     // ... 

También puedes hacer esto con el matches método y una expresión regular bastante simple:

if (str.matches(".*([.,/])work\\1$"))

Usando la clase de personaje [.,/] especificando un punto, una barra inclinada o una coma, y ​​una referencia inversa, \1 que coincida con cualquiera de los suplentes encontrados, si los hubiere.

  • Parece que ninguna de estas respuestas cuenta para un carácter adicional al final como OP especificó.

    – Varatis

    7 de septiembre de 2012 a las 2:42

  • Gracias pb2q que responde por pregunta ya que no sé cuál es el carácter final (mi problema es que al final solo habrá un carácter (,/$ ..) o puede que no sea Pero no será una palabra. Entonces en java puede me explicas cuanto es 1$

    – El aprendiz

    7 de septiembre de 2012 a las 2:59

  • @TheLearner dos cosas separadas al final de expresiones regulares: la primera es \1que es una referencia inversa, que se refiere a cualquier carácter que coincida con el conjunto de caracteres [,./] antes en la expresión regular; rodeamos ese conjunto con parens para agruparlo como referenciable: ([,./]). Y el $ solo significa fin de la línea.

    – pb2q

    7 de septiembre de 2012 a las 3:00

avatar de usuario
jahroy

Puedes probar si una cadena termina con trabaja seguido de un carácter como este:

theString.matches(".*work.$");

Si el carácter final es Opcional puedes usar esto:

theString.matches(".*work.?$");

Para asegurarse de que el último carácter es un punto . o una barra / puedes usar esto:

theString.matches(".*work[./]$");

para probar trabaja seguido de un Opcional punto o barra inclinada puede usar esto:

theString.matches(".*work[./]?$");

para probar trabaja rodeado por periodos o barras, podrías hacer esto:

theString.matches(".*[./]work[./]$");

Si el fichas antes y despues trabaja deben coincidir entre sípodrías hacer esto:

theString.matches(".*([./])work\\1$");

Su requisito exacto no está definido con precisión, pero creo que sería algo como esto:

theString.matches(".*work[,./]?$");

En otras palabras:

  • cero o más caracteres
  • seguido por trabaja
  • seguido de cero o uno , . O /
  • seguido por el final de la entrada

Explicación de varios elementos de expresiones regulares:

.               --  any character
*               --  zero or more of the preceeding expression
$               --  the end of the line/input
?               --  zero or one of the preceeding expression
[./,]           --  either a period or a slash or a comma
[abc]           --  matches a, b, or c
[abc]*          --  zero or more of (a, b, or c)
[abc]?          --  zero or one of (a, b, or c)

enclosing a pattern in parentheses is called "grouping"

([abc])blah\\1  --  a, b, or c followed by blah followed by "the first group"

Aquí hay un arnés de prueba para jugar:

class TestStuff {

    public static void main (String[] args) {

        String[] testStrings = { 
                "work.",
                "work-",
                "workp",
                "/foo/work.",
                "/bar/work",
                "baz/work.",
                "baz.funk.work.",
                "funk.work",
                "jazz/junk/foo/work.",
                "funk/punk/work/",
                "/funk/foo/bar/work",
                "/funk/foo/bar/work/",
                ".funk.foo.bar.work.",
                ".funk.foo.bar.work",
                "goo/balls/work/",
                "goo/balls/work/funk"
        };

        for (String t : testStrings) {
            print("word: " + t + "  --->  " + matchesIt
        }
    }

    public static boolean matchesIt(String s) {
        return s.matches(".*([./,])work\\1?$");
    }

    public static void print(Object o) {
        String s = (o == null) ? "null" : o.toString();
        System.out.println(o);
    }

}

  • Esto ayudó mucho, gracias por la respuesta informativa.

    – g4ost

    29 de enero de 2019 a las 18:42

avatar de usuario
cerditodorado

Por supuesto que puedes usar el StringTokenizer clase para dividir la cadena con ‘.’ o “https://stackoverflow.com/”, y verifica si la última palabra es “trabajo”.

avatar de usuario
Scooter

Puede utilizar el método de subcadena:

   String aString = "This.is.a.great.place.too.work.";
   String aSubstring = "work";
   String endString = aString.substring(aString.length() - 
        (aSubstring.length() + 1),aString.length() - 1);
   if ( endString.equals(aSubstring) )
       System.out.println("Equal " + aString + " " + aSubstring);
   else
       System.out.println("NOT equal " + aString + " " + aSubstring);

avatar de usuario
introducciones pector

Probé todas las cosas diferentes mencionadas aquí para obtener el índice de la . carácter en un nombre de archivo que termina con .[0-9][0-9]*p.ej srcfile.1, srcfile.12, etc. Nada funcionó. Finalmente, lo siguiente funcionó:
int dotIndex = inputfilename.lastIndexOf(".");

¡Extraño! Esto es con Java -versión:

openjdk version "1.8.0_131"
OpenJDK Runtime Environment (build 1.8.0_131-8u131-b11-0ubuntu1.16.10.2-b11)
OpenJDK 64-Bit Server VM (build 25.131-b11, mixed mode)

Además, la página oficial de documentación de Java para regex (del cual hay una cita en una de las respuestas anteriores) no parece especificar cómo buscar el . personaje. Porque \., \\.y [.] no funcionó para mí, y no veo ninguna otra opción especificada además de estas.

  • Resulta “\\”. en una expresión regular (expresión regular) funciona, si está buscando el carácter de punto. La dificultad surgió para mí debido a la API no uniforme de Java String: para la tarea de ubicar/extraer el número de versión de una cadena de nombre de archivo, consideraría los métodos String .endsWith(), .contains() y, por último, . partidos. Resulta que cada uno toma un tipo de argumento diferente, por lo que las cosas pueden volverse confusas: .endsWith(String), .contains(CharSequence) y .matches(regex)!

    – Introducciones Pector

    13 de junio de 2018 a las 6:59


avatar de usuario
cc9999

    String input1 = "This.is.a.great.place.too.work.";
    String input2 = "This/is/a/great/place/too/work/";
    String input3 = "This,is,a,great,place,too,work,";
    String input4 = "This.is.a.great.place.too.work.hahahah";
    String input5 = "This/is/a/great/place/too/work/hahaha";
    String input6 = "This,is,a,great,place,too,work,hahahha";
    
    String regEx = ".*work[.,/]";
    
    System.out.println(input1.matches(regEx)); // true
    System.out.println(input2.matches(regEx)); // true
    System.out.println(input3.matches(regEx)); // true
    System.out.println(input4.matches(regEx)); // false
    System.out.println(input5.matches(regEx)); // false
    System.out.println(input6.matches(regEx)); // false

  • Resulta “\\”. en una expresión regular (expresión regular) funciona, si está buscando el carácter de punto. La dificultad surgió para mí debido a la API no uniforme de Java String: para la tarea de ubicar/extraer el número de versión de una cadena de nombre de archivo, consideraría los métodos String .endsWith(), .contains() y, por último, . partidos. Resulta que cada uno toma un tipo de argumento diferente, por lo que las cosas pueden volverse confusas: .endsWith(String), .contains(CharSequence) y .matches(regex)!

    – Introducciones Pector

    13 de junio de 2018 a las 6:59


¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad