vérifier si la chaîne se termine par un certain motif

C’est très simple, l’object Ssortingng a une méthode endsWith .

De votre question, il semble que vous voulez soit / ,, ou . comme le délimiteur défini.

Alors:

 Ssortingng str = "This.is.a.great.place.to.work."; if (str.endsWith(".work.") || str.endsWith("/work/") || str.endsWith(",work,")) // ... 

Vous pouvez aussi le faire avec la méthode des matches et une expression rationnelle assez simple:

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

En utilisant la classe de caractères [.,/] spécifiant un point, une barre oblique ou une virgule, et une référence arrière, \1 qui correspond à celle des alternatives trouvées, le cas échéant.

Vous pouvez tester si une chaîne se termine par un travail suivi d’un caractère comme celui-ci:

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

Si le caractère de fin est facultatif, vous pouvez utiliser ceci:

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

Pour vous assurer que le dernier caractère est une période . ou une barre oblique / vous pouvez utiliser ceci:

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

Pour tester le travail suivi d’une période facultative ou d’une barre oblique, vous pouvez utiliser ceci:

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

Pour tester un travail entouré de points ou de barres obliques, vous pouvez le faire:

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

Si les jetons avant et après le travail doivent correspondre , vous pouvez le faire:

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

Votre exigence exacte n’est pas précisément définie, mais je pense que ce serait quelque chose comme ceci:

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

En d’autres termes:

• zéro ou plusieurs caractères
• suivi de travail
• suivi de zéro ou un . OU /
• suivi de la fin de l’entrée

Explication de divers éléments de regex:

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

Voici un harnais de test pour jouer avec:

 class TestStuff { public static void main (Ssortingng[] args) { Ssortingng[] testSsortingngs = { "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 (Ssortingng t : testSsortingngs) { print("word: " + t + " ---> " + matchesIt(t)); } } public static boolean matchesIt(Ssortingng s) { return s.matches(".*([./,])work\\1?$"); } public static void print(Object o) { Ssortingng s = (o == null) ? "null" : o.toSsortingng(); System.out.println(o); } } 

Bien sûr, vous pouvez utiliser la classe SsortingngTokenizer pour diviser la chaîne avec ‘.’ ou ‘/’ et vérifiez si le dernier mot est “work”.

Vous pouvez utiliser la méthode de la sous-chaîne:

  Ssortingng aSsortingng = "This.is.a.great.place.too.work."; Ssortingng aSubssortingng = "work"; Ssortingng endSsortingng = aSsortingng.subssortingng(aSsortingng.length() - (aSubssortingng.length() + 1),aSsortingng.length() - 1); if ( endSsortingng.equals(aSubssortingng) ) System.out.println("Equal " + aSsortingng + " " + aSubssortingng); else System.out.println("NOT equal " + aSsortingng + " " + aSubssortingng); 

Vous pouvez utiliser la méthode endsWith pour résoudre ce problème.

Tout d’abord, nous allons essayer de simplifier l’exemple avec la méthode endswith

 public class Test { public static void main(Ssortingng args[]) { Ssortingng Str = new Ssortingng("This is really not immutable"); retVal = Str.endsWith( "immutable" ); System.out.println("Returned Value = " + retVal ); } } 

Str dernière valeur est “immuable”. Ensuite, vous pouvez voir vrai dans la console. Selon votre question,

 public class Test { public static void main(Ssortingng args[]) { Ssortingng Str = new Ssortingng("This/is/a/great/place/too/work/hahahah"); boolean retVal; retVal = Str.endsWith( "work/hahahah" ); System.out.println("Returned Value = " + retVal ); if(retVal == true){ System.out.println("Its work"); } } 

}

J’ai essayé toutes les choses mentionnées ici pour obtenir l’index du “.” caractère dans un nom de fichier qui se termine par. [0-9] [0-9] *, par exemple srcfile.1, srcfile.12, etc. Rien n’a fonctionné. Enfin, les points suivants ont fonctionné: int dotIndex = inputfilename.lastIndexOf (“.”);

Bizarre! Ceci est avec java -version openjdk version “1.8.0_131” OpenJDK Runtime Environment (version 1.8.0_131-8u131-b11-0ubuntu1.16.10.2-b11) OpenJDK 64 bits Serveur VM (version 25.131-b11, mode mixte)

En outre, la page de documentation Java officielle de regex (à partir de laquelle il existe une citation dans l’une des réponses ci-dessus) ne semble pas indiquer comment rechercher le “.” personnage. Parce que “.”, “\.” Et “[.]” Ne fonctionnaient pas pour moi, et je ne vois aucune autre option spécifiée en dehors de celles-ci.