Compruebe si la cadena termina con cierto patrón

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?

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.

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

}

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

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

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.

    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