Si j'ai une ficelle comme:
This.is.a.great.place.too.work.
ou:
This/is/a/great/place/too/work/
que mon programme devrait me donner que la phrase est valide et qu'il a "travail".
Si j'ai :
This.is.a.great.place.too.work.hahahha
ou:
This/is/a/great/place/too/work/hahahah
alors mon programme ne devrait pas me dire qu'il y a un "travail" dans la phrase.
Donc, je regarde les chaînes Java pour trouver un mot à la fin de la phrase ayant. , ou, ou/avant. Comment puis-je atteindre cet objectif?
C’est très simple, l’objet String
a une méthode endsWith
.
D'après votre question, il semble que vous souhaitiez utiliser /
, ,
ou .
en tant que jeu de délimiteurs.
Alors:
String str = "This.is.a.great.place.to.work.";
if (str.endsWith(".work.") || str.endsWith("/work/") || str.endsWith(",work,"))
// ...
Vous pouvez également le faire avec la méthode matches
et une expression rationnelle assez simple:
if (str.matches(".*([.,/])work\\1$"))
Utilisation de la classe de caractères [.,/]
en spécifiant un point, une barre oblique ou une virgule et une référence arrière, \1
, qui correspond à l’une des variantes remplacées, le cas échéant.
Vous pouvez tester si une chaîne se termine par work suivi d'un caractère comme celui-ci:
theString.matches(".*work.$");
Si le caractère de fin est optionnel vous pouvez utiliser ceci:
theString.matches(".*work.?$");
Pour vous assurer que le dernier caractère est un point .
ou une barre oblique /
, vous pouvez utiliser ceci:
theString.matches(".*work[./]$");
Pour tester work suivi d'un optionnel point ou barre oblique, vous pouvez utiliser ceci:
theString.matches(".*work[./]?$");
Pour tester travail entouré par des périodes ou barres obliques, vous pouvez procéder comme suit:
theString.matches(".*[./]work[./]$");
Si les jetons avant et après work doivent être identiques , vous pouvez le faire:
theString.matches(".*([./])work\\1$");
Votre exigence exacte n'est pas définie avec précision, mais je pense que ce serait quelque chose comme ceci:
theString.matches(".*work[,./]?$");
En d'autres termes:
,
.
OU/
Explication de divers objets 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 (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(t));
}
}
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);
}
}
Vous pouvez utiliser la méthode de sous-chaîne:
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);
Bien sûr, vous pouvez utiliser la classe StringTokenizer
pour scinder la chaîne avec '.' ou '/', et vérifiez si le dernier mot est "travail".
Vous pouvez utiliser endsWith method pour résoudre ce problème.
Tout d’abord, nous allons essayer de donner un exemple simple avec la méthode endswith
public class Test {
public static void main(String args[]) {
String Str = new String("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 true dans la console . Selon votre question,
public class Test {
public static void main(String args[]) {
String Str = new String("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 éléments suivants ont fonctionné: Int dotIndex = inputfilename.lastIndexOf (".");
Bizarre! C'est avec la version Java Openjdk version "1.8.0_131" Environnement d'exécution OpenJDK (version 1.8.0_131-8u131-b11-0ubuntu1.16.10.2-b11) Serveur OpenJDK 64 bits VM (build 25.131-b11, mode mixte)
De plus, la page de document Java officielle pour regex (à partir de laquelle une des réponses ci-dessus figure) ne semble pas spécifier comment rechercher le "." personnage. Parce que ".", "\." Et "[.]" N'ont pas fonctionné pour moi et je ne vois aucune autre option spécifiée en dehors de celles-ci.