Regular Expressions: A String should not contain the word "TEST"

[Peter Heide]

The following regular expression matches for all Strings that contains word TEST, not matter if in the beginning or in the end:

.*TEST.*

How would the regular expression look like that matches for all Strings that do not contain the word TEST?

For testing I am using the following code:

    
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
	public static void main(String[] args) {
		test("TEST");
		test("TEST TEST");
		test("TES T");
		test("PETER");
	}
	
	public static void test(String input) {
		String regexStr = ".*TEST.*";
		Pattern pattern = Pattern.compile(regexStr);
		Matcher matcher = pattern.matcher(input);
		if (matcher.matches())
			System.out.println("String " + input + " has the word TEST in it ");
		else
			System.out.println("String " + input + " hasn't the word TEST in it ");
	}
}

I know that it is possible to program this with the indexOf method of the String class, but I need to implement this using regular expressions.

[Info Wwn]

Oops, wrong info

[Joanne Neal]

What's wrong with the code you have ? If matcher.matches() returns false, the string doesn't contain TEST.

[Sebastian Janisch]

don't employ the heavy regex engine when an indexOf just does fine ...

[Ireneusz Kordal]

You must use negative lookahead construct:
This will match only if string doesn't contain TEST:

   static String regexStr = "(?!.*TEST.*).*";  

[Sebastian Janisch]

Why simple when you can do it incredibly complicated :-)

how about

if(str.toLowerCase().indexOf("test") == -1) {
    // the word test is not in str
}

[Peter Heide]

Thank you for all your help guys! Of course you are right, the simplest code ist the best for the given problem.
But I wanted to figure out how to solve it with an regular expression. Thank you Ireneusz Kordal for your correct regular expression!

The following code :

 

		import java.util.regex.Matcher;
		import java.util.regex.Pattern;
		
		public class Test2 {
			public static void main(String[] args) {
				System.out.println("This program delivers false when a String contains the String \"TEST\" and true otherwise");
				test("TEST", false);
				test("TEST TEST", false);
				test("123 TEST 456", false);
				test("Peter", true);
			}
			
			public static void test(String input, boolean expected) {
				String myInput = input.toUpperCase();
				String regexStr = "(?!.*TEST.*).*";				
				Pattern pattern = Pattern.compile(regexStr);
				Matcher matcher = pattern.matcher(myInput);
				if (matcher.matches() == expected)
					System.out.println("OK! String \"" + input + "\" delivers " + expected);
				else
					System.out.println("Error! String \"" + input + "\" does not deliver " + expected);
			}
		}
   

Delivers the following answer I needed:

This program delivers false when a String contains the String "TEST" and true otherwise (It is forbidden to have the Substring "TEST" in a String)
OK! String "TEST" delivers false
OK! String "TEST TEST" delivers false
OK! String "123 TEST 456" delivers false
OK! String "Peter" delivers true

[Rob Spoor]

matches() only returns true if the entire String matches the entire regex. Use find() otherwise.

You may also want to check out the Pattern.CASE_INSENSITIVE flag, that way you don't need to use toUpperCase().