Expression régulière pour faire correspondre au moins 3 caractères séquentiels consécutifs et caractères identiques consécutifs
J'ai besoin d'expressions régulières pour correspondre aux cas ci-dessous.
- 3 caractères ou chiffres consécutifs ou plus; par exemple. 123, abc, 789, pqr, etc.
- 3 caractères ou chiffres identiques consécutifs ou plus; par exemple. 111, aaa, bbb, 222, etc.
Je ne pense pas que vous puissiez utiliser regex pour le premier cas. Le second cas est simple:
Pattern pattern = Pattern.compile("([a-z\\d])\\1\\1", Pattern.CASE_INSENSITIVE);
Puisque \\1 représente une partie appariée par le groupe 1, cela correspond à toute séquence de trois caractères identiques situés dans la plage a-z ou sous forme de chiffres (\d).
pour la deuxième question:
\\b([a-zA-Z0-9])\\1\\1+\\b
explication:
\\b : zero-length Word boundary
( : start capture group 1
[a-zA-Z0-9] : a letter or a digit
) : end group
\\1 : same character as group 1
\\1+ : same character as group 1 one or more times
\\b : zero-length Word boundary
À ma connaissance, le premier cas n'est en effet pas possible. Le moteur de regex ne sait rien de l'ordre des nombres naturels ou de l'alphabet. Mais il est au moins possible de différencier entre 3 chiffres ou plus et 3 lettres ou plus, par exemple:
[a-z]{3,}|[A-Z]{3,}|\d{3,}
Cela correspond à abcd, ABCDE ou 123 mais ne correspond pas à ab2d, A5c4 ou 12z, par exemple. Selon ce qui précède, le deuxième cas peut être correctement présenté dans une version plus courte sous la forme suivante:
(\w)\1{2,}
Je ne suis pas d'accord, le cas 1 est possible, mais vous devez lui indiquer les séquences à associer ... ce qui est un peu long et ennuyeux:
/(abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)+/ig
3 caractères consécutifs ou plus consécutifs/numéros ex - 123, abc, 789, pqr, etc.
Pas possible avec des expressions régulières.
Au moins 3 caractères/chiffres identiques consécutifs ex-111, aaa, bbb. 222 etc.
Utilisez un motif de (?i)(?:([a-z0-9])\\1{2,})*.
Si vous voulez vérifier toute la chaîne, utilisez Matcher.matches() . Pour trouver des correspondances dans une chaîne, utilisez Matcher.find() .
Voici un exemple de code:
final String ps = "(?i)(?:([a-z0-9])\\1{2,})*";
final String psLong =
"(?i)\t\t\t# Case insensitive flag\n"
+ "(?:\t\t\t\t# Begin non-capturing group\n"
+ " (\t\t\t\t# Begin capturing group\n"
+ " [a-z0-9]\t\t# Match an alpha or digit character\n"
+ " )\t\t\t\t# End capturing group\n"
+ " \\1\t\t\t\t# Back-reference first capturing group\n"
+ " {2,}\t\t\t# Match previous atom 2 or more times\n"
+ ")\t\t\t\t# End non-capturing group\n"
+ "*\t\t\t\t# Match previous atom zero or more characters\n";
System.out.println("***** PATTERN *****\n" + ps + "\n" + psLong
+ "\n");
final Pattern p = Pattern.compile(ps);
for (final String s : new String[] {"aa", "11", "aaa", "111",
"aaaaaaaaa", "111111111", "aaa111bbb222ccc333",
"aaaaaa111111bbb222"})
{
final Matcher m = p.matcher(s);
if (m.matches()) {
System.out.println("Success: " + s);
} else {
System.out.println("Fail: " + s);
}
}
Et le résultat est:
***** PATTERN *****
(?i)(?:([a-z0-9])\1{2,})*
(?i) # Case insensitive flag
(?: # Begin non-capturing group
( # Begin capturing group
[a-z0-9] # Match an alpha or digit character
) # End capturing group
\1 # Back-reference first capturing group
{2,} # Match previous atom 2 or more times
) # End non-capturing group
* # Match previous atom zero or more characters
Fail: aa
Fail: 11
Success: aaa
Success: 111
Success: aaaaaaaaa
Success: 111111111
Success: aaa111bbb222ccc333
Success: aaaaaa111111bbb222
Merci à tous pour m'aider.
Pour le premier cas - 3 caractères/chiffres consécutifs ou plus; par exemple. 123, abc, 789, pqr, etc. J'ai utilisé la logique de code ci-dessous. Pls partager vos commentaires à ce sujet.
public static boolean validateConsecutiveSeq(String epin) {
char epinCharArray[] = epin.toCharArray();
int asciiCode = 0;
boolean isConSeq = false;
int previousAsciiCode = 0;
int numSeqcount = 0;
for (int i = 0; i < epinCharArray.length; i++) {
asciiCode = epinCharArray[i];
if ((previousAsciiCode + 1) == asciiCode) {
numSeqcount++;
if (numSeqcount >= 2) {
isConSeq = true;
break;
}
} else {
numSeqcount = 0;
}
previousAsciiCode = asciiCode;
}
return isConSeq;
}
La regex correspondant à trois nombres ou alphabets consécutifs est "([0-9] | [aA-zZ])\1\1"
Si vous avez une limite inférieure (3) et une limite supérieure, regexString peut être généré comme suit
public class RegexBuilder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
int seqStart = 3;
int seqEnd = 5;
buildRegex(sb, seqStart, seqEnd);
System.out.println(sb);
}
private static void buildRegex(StringBuilder sb, int seqStart, int seqEnd) {
for (int i = seqStart; i <= seqEnd; i++) {
buildRegexCharGroup(sb, i, '0', '9');
buildRegexCharGroup(sb, i, 'A', 'Z');
buildRegexCharGroup(sb, i, 'a', 'z');
buildRegexRepeatedString(sb, i);
}
}
private static void buildRegexCharGroup(StringBuilder sb, int seqLength,
char start, char end) {
for (char c = start; c <= end - seqLength + 1; c++) {
char ch = c;
if (sb.length() > 0) {
sb.append('|');
}
for (int i = 0; i < seqLength; i++) {
sb.append(ch++);
}
}
}
private static void buildRegexRepeatedString(StringBuilder sb, int seqLength) {
sb.append('|');
sb.append("([a-zA-Z\\d])");
for (int i = 1; i < seqLength; i++) {
sb.append("\\1");
}
}
}
Sortie
012|123|234|345|456|567|678|789|ABC|BCD|CDE|DEF|EFG|FGH|GHI|HIJ|IJK|JKL|KLM|LMN|MNO|NOP|OPQ|PQR|QRS|RST|STU|TUV|UVW|VWX|WXY|XYZ|abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|([a-z\d])\1\1|0123|1234|2345|3456|4567|5678|6789|ABCD|BCDE|CDEF|DEFG|EFGH|FGHI|GHIJ|HIJK|IJKL|JKLM|KLMN|LMNO|MNOP|NOPQ|OPQR|PQRS|QRST|RSTU|STUV|TUVW|UVWX|VWXY|WXYZ|abcd|bcde|cdef|defg|efgh|fghi|ghij|hijk|ijkl|jklm|klmn|lmno|mnop|nopq|opqr|pqrs|qrst|rstu|stuv|tuvw|uvwx|vwxy|wxyz|([a-z\d])\1\1\1|01234|12345|23456|34567|45678|56789|ABCDE|BCDEF|CDEFG|DEFGH|EFGHI|FGHIJ|GHIJK|HIJKL|IJKLM|JKLMN|KLMNO|LMNOP|MNOPQ|NOPQR|OPQRS|PQRST|QRSTU|RSTUV|STUVW|TUVWX|UVWXY|VWXYZ|abcde|bcdef|cdefg|defgh|efghi|fghij|ghijk|hijkl|ijklm|jklmn|klmno|lmnop|mnopq|nopqr|opqrs|pqrst|qrstu|rstuv|stuvw|tuvwx|uvwxy|vwxyz|([a-z\d])\1\1\1\1
3 caractères ou chiffres consécutifs ou plus; par exemple. 123, abc, 789, pqr, etc.
(?:(?:0(?=1)|1(?=2)|2(?=3)|3(?=4)|4(?=5)|5(?=6)|6(?=7)|7(?=8)|8(?=9)){2,}\d|(?:a(?=b)|b(?=c)|c(?=d)|d(?=e)|e(?=f)|f(?=g)|g(?=h)|h(?=i)|i(?=j)|j(?=k)|k(?=l)|l(?=m)|m(?=n)|n(?=o)|o(?=p)|p(?=q)|q(?=r)|r(?=s)|s(?=t)|t(?=u)|u(?=v)|v(?=w)|w(?=x)|x(?=y)|y(?=z)){2,}[\p{Alpha}])3 caractères ou chiffres identiques consécutifs ou plus; par exemple. 111, aaa, bbb, 222, etc.
([\p{Alnum}])\1{2,}
Tous mis ensemble:
([a-zA-Z0-9])\1\1+ | (abc | bcd | cde | def | efg | fgh | ghi | hij | ijk | jkl | klm | lmn | mno | nop | opq | pqr | qrs | rst | stu | tuv | uvw | vwx | wxy | xyz | 012 | 123 | 234 | 345 | 456 | 567 | 678 | 789) +
3 caractères ou chiffres consécutifs ou plus; par exemple. 123, abc, 789, pqr, etc.
(abc | bcd | cde | def | efg | fgh | ghi | hij | ijk | jkl | klm | lmn | mno | nop | opq | pqr | qrs | rst | tuv | uvw | vwx | wxy | xy | 012 | 123 | 234 | 345 | 456 | 567 | 678 | 789) +
3 caractères ou chiffres identiques consécutifs ou plus; par exemple. 111, aaa, bbb, 222, etc.
([a-zA-Z0-9])\1\1+
Tous mis ensemble:
([a-zA-Z0-9])\1\1+ | (abc | bcd | cde | def | efg | fgh | ghi | hij | ijk | jkl | klm | lmn | mno | nop | opq | pqr | qrs | rst | stu | tuv | uvw | vwx | wxy | xyz | 012 | 123 | 234 | 345 | 456 | 567 | 678 | 789) +
3 caractères ou chiffres consécutifs ou plus; par exemple. 123, abc, 789, pqr, etc.
(abc | bcd | cde | def | efg | fgh | ghi | hij | ijk | jkl | klm | lmn | mno | nop | opq | pqr | qrs | rst | tuv | uvw | vwx | wxy | xy | 012 | 123 | 234 | 345 | 456 | 567 | 678 | 789) +
3 caractères ou chiffres identiques consécutifs ou plus; par exemple. 111, aaa, bbb, 222, etc.
([a-zA-Z0-9])\1\1+
Cela fonctionne aussi:
(? :( ?: 0 (? = 1) | 1 (? = 2) | 2 (? = 3) | 3 (? = 4) | 4 (? = 5) | 5 (? = 6) | 6 ( ? = 7) | 7 (? = 8) | 8 (? = 9)) {2,}\d | (?: A (? = B) | b (? = C) | c (? = D) | d (? = e) | e (? = f) | f (? = g) | g (? = h) | h (? = i) | i (? = j) | j (? = k) | k (? = l) | l (? = m) | m (? = n) | n (? = o) | o (? = p) | p (? = q) | q (? = r) | r ( ? = s) | s (? = t) | t (? = u) | u (? = v) | v (? = w) | w (? = x) | x (? = y) | y (? = z)) {2,} [[: alpha:]]) | ([a-zA-Z0-9])\1\1+