Develop Reference

Android: regex for edit text to have only 2 values possible in decimal

In my filter used into EditText, I want to be sure the user can only set .5 or .0 for decimal values.
Valid values examples:
34.5
34.0
34
Invalid values examples:
34.2
34.8
34.6
I tried this one, but it doesn't work properly: [0-9]*[.]?[0|5]
Thank you very much guys!

You're probably looking for [0-9]*(\.([50][0]*)*)*.
[0-9]*: Any character from 0 to 9, zero or more times [so that just a "." (= 0.0) input is valid]
\.: You need to escape the '.' character, since it usually would mean "any character", and you especifically need the dot there.
[50][0]*: First, either five or zero (once). Second, the 0 character, zero or more times (since 35.50 = 35.5). This also avoids inputs like 35.59 from being valid, since 9 != 0.
([50][0]*)*: This occurrence zero or more times, so that 35., for instance, becomes a valid input (since 35. = 35.0).
(\.([50][0]*)*)*: As for this grouping, it's in order to check for the five or the zero only if there is a decimal dot. It's grouping the dot character and the 5/0 logic together with a star (zero or more times) at the end, so if it doesn't occur, it still matches.
Let me know if this was what you were looking for.

To verify the whole numbers in the examples, you can make the last part optional and use anchors.
^[0-9]+(?:[.][05])?$
^ Start of string
[0-9]+ Match 1+ digits 0-9
(?:[.][05])? Optionally match . and a digit 0 or 5
$ End of string
See a regex demo.
If you want to be able to only type a pattern like that and also accept empty strings or 34. you can repeat the digit 0 or more times, optionally match . and optionally match either 0 or 5.
^[0-9]*[.]?[05]?$
See another regex demo

Regex for 17 digits allowing spaces

What may be the regex for allowing 17 digits with or without spaces in-between any number of the characters?
I am using a OCR real-time capture SDK (ABBYY RTR SDK) on Android(, and I'm using a custom data capture (which has to capture 17 digits with or without spaces in-between anywhere)
My regex is currently this:
field.setRegEx( "[0-9]{14,16}" );
This is only able to capture in-line digits (38492039483726473)
But I need it to capture digits in that format, as well as this format - 3849 20394 8372 6473.
How do I go about achieving this?

If it's simply those two formats:
(\d{17}|\d{4}\s\d{5}\s(?:\d{4}\s){2})
Captures a digit 17 times
or
Capture 4 digits followed by a space, then 5 digits followed by another space, and then 4 digits followed by a space twice

Try repeating a digit with optional space:
(\d ?){17}
Demo

An alternative to the answer given by #mrzasa would be to first remove all whitespace from the number string, and then use a simpler regex to check for 17 digits:
String input = "3849 20394 8372 6473";
if (input.replaceAll("\\s+", "").matches("\\d{17}")) {
System.out.println("match");
}

Regex to determine if string contains at least 2 numbers

I'm try to write a username field validator and one of the reqs is that the field must contain at least 2 numbers (more is ok, just no less). I thought I could do something like this, and the regex splits on the first number, but never on the second.
String[] arr = string.split("[0-9][0-9]");
return arr.length > 2;
Use cases:
Bob11
Bo1b1
11Bob
1Bob1

Below is my version, that has an extremely fast execution, can be easily updated to different criteria, and has a better readability (at least to me):
Regex
(\D*\d){2,}
Example
Bob11 - Match
Bo1b1 - Match
11Bob - Match
1Bob1 - Match
11235 - Match
Bobb - Does NOT Match
Bob1 - Does NOT Match
Bo1b - Does NOT Match
1Bob - Does NOT Match
Explanation
\D - non digit.
* - (quantifier) zero or more times.
\d - one digit.
(\D*\d) - encapsulate the combination above as a group.
{2,} - (quantifier) ensures that the group occurs at least 2 times, being able to occur more times.
(\D*\d){2,} - So, \D* non digit zero or infinite times, followed by a \d digit, this combination repeated {2,} two or infinite times.
Updating to different criteria
The ^ (start string anchor) and $ (end string anchor) can be included to ensure restriction, in case the criteria changes to be exact 2 or any other number.
This is an example that ensures no more, no less that 5 numbers anywhere in a string: ^(\D*\d){5}\D*$. The last \D is necessary to allow the string to end with a non digit, validating the regex if the criteria of five digits be satisfied.*

Try this:
.* matches everything (from 0 to n times)
[0-9] is number from 0-9
Pattern pattern = Pattern.compile("[0-9].*[0-9]");
Matcher matcher = pattern.matcher(string);
if (matcher.find()) {
return true;
}
And you can check regex in https://www.freeformatter.com/regex-tester.html

Remove all non numeric characters using regex and count the length

[^\d]*\d[^\d]*\d.* should be one way to go (there are several..)
[^\d]* Matches any character which is not a digit (zero to infinite times)
\d matches a single digit (once)
.* matches everything (zero to infinite times)
I use [^\d]* because .* is greedy and thus might match too much (depending on the language). Greedy behavior can be disabled by appending ?: .*?
You can test it at https://regex101.com/.

You do not need RegEx for this. I'm not sure what language you're using, but it is safe to assume that a String in your language is essentially a Char array. If that is the case, then get the count of digit characters in the Char array and compare if it is greater than 1.
For example, here is a C# example:
String username = Console.ReadLine();
if (username.Count(c => Char.IsDigit(c)) > 1) {
Console.WriteLine("The String contains 2 or more digits.");
} else {
Console.WriteLine("The String did not contain 2 or more digits.");
}
This would likely yield faster results too.

Use string.match(‘.*\d.*\d.*’);
It will look for one digit two times in a string.

Password validator is not working in android

In my application I am accepting a password from the user which should be in following format:-
case sensitive and
must be at least 6 characters long,
including at least
one letter (a-Z),
one number (0-9) and
one of the following special characters:!=+*;:-,._{[()]}#%?#
So by following the tutorial given here:
http://www.mkyong.com/regular-expressions/how-to-validate-password-with-regular-expression/
I have created my own pattern as:-
private static final String PASSWORD_PATTERN = "($\\S*(?=\\S{6,})(?=\\S*[a-z])(?=\\S*[A-Z])(?=\\S*[\\d])(?=\\S*[\\W])\\S*$)";
But it is not working properly. If I enter a correct value for the password as per pattern, it still displays an error to me.
Please tell me what's happening here; what error is there?
Here is my code:-
PWD_Validate = new PasswordValidator();
String password = TXT_PassWord.getText().toString();
if (PWD_Validate.validate(password))
{
}
else{ } it takes me every time in else block, even I entered a correct passwaord.

I'm not sure why you've deviated from the pattern that is listed within the tutorial you've linked. Your pattern starts with $ which asserts position at end of the string, so it's highly unlikely you'll match anything. Usually if you're using an assertion you use $ at the very end of the pattern and ^ to assert the beginning.
Also no where in your pattern do you have any of the special characters you've outlined as those you've said are required. If you plan on matching those I would recommend including them into your pattern.
The breakdown of your regex goes like this:
$ assert position at end of the string (you've got it at the beginning).
\S* match any non-white space character [^\r\n\t\f ]
Quantifier: Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
(?=\S{6,}) Positive Lookahead - Assert that the regex below can be matched
\S{6,} match any non-white space character [^\r\n\t\f ]
Quantifier: Between 6 and unlimited times, as many times as possible, giving back as needed [greedy]
(?=\S*[a-z]) Positive Lookahead - Assert that the regex below can be matched
\S* match any non-white space character [^\r\n\t\f ]
Quantifier: Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
[a-z] match a single character present in the list below
a-z a single character in the range between a and z (case sensitive)
(?=\S*[A-Z]) Positive Lookahead - Assert that the regex below can be matched
\S* match any non-white space character [^\r\n\t\f ]
Quantifier: Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
[A-Z] match a single character present in the list below
A-Z a single character in the range between A and Z (case sensitive)
(?=\S*[\d]) Positive Lookahead - Assert that the regex below can be matched
\S* match any non-white space character [^\r\n\t\f ]
Quantifier: Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
[\d] match a single character present in the list below
\d match a digit [0-9]
(?=\S*[\W]) Positive Lookahead - Assert that the regex below can be matched
\S* match any non-white space character [^\r\n\t\f ]
Quantifier: Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
[\W] match a single character present in the list below
\W match any non-word character [^a-zA-Z0-9_]
\S* match any non-white space character [^\r\n\t\f ]
Quantifier: Between zero and unlimited times, as many times as possible, giving back as needed [greedy]
$ assert position at end of the string
To be quite honest your regex is so far off from the tutorial you've
linked that it's not even remotely close. I would recommend you go
back and thoroughly re-read and study the guide, for it's apparent you
haven't applied any of it to be applicable by any means.

How Match Regular expression of international number in android

i have a EditText in my activity where i take a phone number from user.. Now user provides a number activity and based on xml rules you i have to tell whether application routes the phone number or not.

This is more of a java question, you need to know how to build regular expressions. So I assume you know how to fetch the value of the edit text. Lets assume you have loaded the phone number in a String phoneNumber. So now how do you check against a regular expression:
import java.util.regex.Pattern;
import java.util.regex.Matcher;
....
Pattern pattern = Pattern.compile("\+0[8-9][0-9]{2}-[0-9]{2}-[0-9]{3}");
Matcher matcher = pattern.matcher(phoneNumber);
if (matcher.matches()) {
// The phone number matches the template given. do the routing.
}
In th eexample I have given I am searching for phone numbers that start with + (note that + is a special character for regexes, thus I need to escape it, the same holds for $, ., ^), then I expect a zero, 8 or 9, then exactly 2 digits, a dash 2 more digits and 3 more digits. The if matcher.matches() will return true only if the phoneNumber is exactly of the described format. Hopefully this will give you a brief introduction to the regex power of java.

ITU: National Numbering Plans can help you with the harder problem.
Your question is poor enough that any one of my link, Boris's regex-centric answer, or an answer that focused on nothing more than Android's GUI could be what you're really looking for. Please keep this in mind for future questions.