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);
}

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

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]")

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);

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.

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

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

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