CODEWITHSUNDEEP
javaregex
Lucky
Lucky

Reputation: 801

Java - How to test if a String contains both letters and numbers

I need a regex which will satisfy both conditions.

It should give me true only when a String contains both A-Z and 0-9.

Here's what I've tried:

if PNo[0].matches("^[A-Z0-9]+$")

It does not work.

Upvotes: 16

Views: 80212

Answers (8)

farhad.kargaran
farhad.kargaran

Reputation: 2373

use this method:

  private boolean isValid(String str)
  {
    String Regex_combination_of_letters_and_numbers = "^(?=.*[a-zA-Z])(?=.*[0-9])[a-zA-Z0-9]+$";
    String Regex_just_letters = "^(?=.*[a-zA-Z])[a-zA-Z]+$";
    String Regex_just_numbers = "^(?=.*[0-9])[0-9]+$";
    String Regex_just_specialcharachters = "^(?=.*[@#$%^&+=])[@#$%^&+=]+$";
    String Regex_combination_of_letters_and_specialcharachters = "^(?=.*[a-zA-Z])(?=.*[@#$%^&+=])[a-zA-Z@#$%^&+=]+$";
    String Regex_combination_of_numbers_and_specialcharachters = "^(?=.*[0-9])(?=.*[@#$%^&+=])[0-9@#$%^&+=]+$";
    String Regex_combination_of_letters_and_numbers_and_specialcharachters = "^(?=.*[a-zA-Z])(?=.*[0-9])(?=.*[@#$%^&+=])[a-zA-Z0-9@#$%^&+=]+$";

    if(str.matches(Regex_combination_of_letters_and_numbers))
        return true;
    if(str.matches(Regex_just_letters))
        return true;
    if(str.matches(Regex_just_numbers))
        return true;
    if(str.matches(Regex_just_specialcharachters))
        return true;
    if(str.matches(Regex_combination_of_letters_and_specialcharachters))
        return true;
    if(str.matches(Regex_combination_of_numbers_and_specialcharachters))
        return true;
    if(str.matches(Regex_combination_of_letters_and_numbers_and_specialcharachters))
        return true;
    return false;
  }

You can delete some conditions according to your taste

Upvotes: 0

Suchi Talla
Suchi Talla

Reputation: 1

Try using (([A-Z]+[0-9])|([0-9]+[A-Z])) .It should solve.

Upvotes: 0

Fangming
Fangming

Reputation: 25261

Here is the regex for you

Basics:

Match in the current line of string: .

Match 0 or any amount of any characters: *

Match anything in the current line: .*

Match any character in the set (range) of characters: [start-end]

Match one of the regex from a group: (regex1|regex2|regex3)

Note that the start and end comes from ASCII order and the start must be before end. For example you can do [0-Z], but not [Z-0]. Here is the ASCII chart for your reference enter image description here

Check the string against regex

Simply call yourString.matches(theRegexAsString)

Check if string contains letters:

Check if there is a letter: yourString.matches(".*[a-zA-Z].*")

Check if there is a lower cased letter: yourString.matches(".*[a-z].*")

Check if there is a upper cased letter: yourString.matches(".*[A-Z].*")

Check if string contains numbers:

yourString.matches(".*[0-9].*")

Check if string contains both number and letter:

The simplest way is to match twice with letters and numbers

yourString.matches(".*[a-zA-Z].*") && yourString.matches(".*[0-9].*")

If you prefer to match everything all together, the regex will be something like: Match a string which at someplace has a character and then there is a number afterwards in any position, or the other way around. So your regex will be:

yourString.matches(".*([a-zA-Z].*[0-9]|[0-9].*[a-zA-Z]).*")

Extra regex for your reference:

Check if the string stars with letter

yourString.matches("[a-zA-Z].*")

Check if the string ends with number

yourString.matches(".*[0-9]")

Upvotes: 8

jahroy
jahroy

Reputation: 22692

It easier to write and read if you use two separate regular expressions:

String s  =  "blah-FOO-test-1-2-3";

String numRegex   = ".*[0-9].*";
String alphaRegex = ".*[A-Z].*";

if (s.matches(numRegex) && s.matches(alphaRegex)) {
    System.out.println("Valid: " + input);
}

Better yet, write a method:

public boolean isValid(String s) {
    String n = ".*[0-9].*";
    String a = ".*[A-Z].*";
    return s.matches(n) && s.matches(a);
}

Upvotes: 24

Sergey Kalinichenko
Sergey Kalinichenko

Reputation: 726599

A letter may be either before or after the digit, so this expression should work:

(([A-Z].*[0-9])|([0-9].*[A-Z]))

Here is a code example that uses this expression:

Pattern p = Pattern.compile("(([A-Z].*[0-9])|([0-9].*[A-Z]))");
Matcher m = p.matcher("AXD123");
boolean b = m.find();
System.out.println(b);

Upvotes: 7

nhahtdh
nhahtdh

Reputation: 56809

I suspect that the regex below is slowed down by the look-around, but it should work regardless:

.matches("^(?=.*[A-Z])(?=.*[0-9])[A-Z0-9]+$")

The regex asserts that there is an uppercase alphabetical character (?=.*[A-Z]) somewhere in the string, and asserts that there is a digit (?=.*[0-9]) somewhere in the string, and then it checks whether everything is either alphabetical character or digit.

Upvotes: 27

Chip
Chip

Reputation: 3316

What about ([A-Z].*[0-9]+)|([0-9].*[A-Z]+) ?

Upvotes: 1

vbezhenar
vbezhenar

Reputation: 12336

This should solve your problem:

^([A-Z]+[0-9][A-Z0-9]*)|([0-9]+[A-Z][A-Z0-9]*)$

But it's unreadable. I would suggest to first check input with "^[A-Z0-9]+$", then check with "[A-Z]" to ensure it contains at least one letter then check with "[0-9]" to ensure it contains at least one digit. This way you can add new restrictions easily and code will remain readable.

Upvotes: 5

Related Questions