You could also use the commons-lang library from Apache which provides the much appreciated method contains.

import org.apache.commons.lang.ArrayUtils;

public class CommonsLangContainsDemo {

    public static void execute(String[] strings, String searchString) {
        if (ArrayUtils.contains(strings, searchString)) {
            System.out.println("contains.");
        } else {
            System.out.println("does not contain.");
        }
    }

    public static void main(String[] args) {
        execute(new String[] { "AA","BB","CC" }, "BB");
    }

}

String[] a= {"tube", "are", "fun"};
Arrays.asList(a).contains("any");

You can optionally make a copy of the array since sorting might be unwanted for consumers of the method

public static int Search(String[] thewords, String answer) {  
     if(thewords == null) {  
        throw new NullPointerException();  
     }  
     String[] copy = new String[thewords.length];  
     System.arraycopy(thewords,0,copy,0,copy.length);  
     Arrays.sort(thewords);    
     return Arrays.binarySearch(thewords, answer);  
}  

Note: It returns -pos and not -1

If you need -1:

public static int Search(String[] thewords, String answer) {  
     if(thewords == null) {  
        throw new NullPointerException();  
     }  
     String[] copy = new String[thewords.length];  
     System.arraycopy(thewords,0,copy,0,copy.length);  
     Arrays.sort(thewords);  
     int idx = Arrays.binarySearch(thewords, answer);  
     return idx < 0? -1:idx;  
}  

Concerning your code: I believe the problem would be related to casing or spacing:
Replace with something like: if (answer.equalsIgnoreCase(theWords[i].trim())){

For large arrays go with binary search.

Okay, if binary search isn't possible (which seems to be the case), we can just implement a simple custom solution:

public Customer findCustomerByName(Customer[] array, String pattern){
    for(Customer candidate: array){
       if(candidate.getName().contains(pattern)){
          return candidate;
       }
    }
    return null;
}

Or did I miss something?

use equalsIgnoreCase() instead of equals()

Read for documentation here

from javadoc,

Compares this String to another String, ignoring case considerations. Two strings are considered equal ignoring case if they are of the same length and corresponding characters in the two strings are equal ignoring case.

Concise update for Java SE 9

Reference arrays are bad. For this case we are after a set. Since Java SE 9 we have Set.of.

private static final Set<String> VALUES = Set.of(
    "AB","BC","CD","AE"
);

"Given String s, is there a good way of testing whether VALUES contains s?"

VALUES.contains(s)

O(1).

The right type, immutable, O(1) and concise. Beautiful.*

Original answer details

Just to clear the code up to start with. We have (corrected):

public static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

This is a mutable static which FindBugs will tell you is very naughty. Do not modify statics and do not allow other code to do so also. At an absolute minimum, the field should be private:

private static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

(Note, you can actually drop the new String[]; bit.)

Reference arrays are still bad and we want a set:

private static final Set<String> VALUES = new HashSet<String>(Arrays.asList(
     new String[] {"AB","BC","CD","AE"}
));

(Paranoid people, such as myself, may feel more at ease if this was wrapped in Collections.unmodifiableSet - it could then even be made public.)

(*To be a little more on brand, the collections API is predictably still missing immutable collection types and the syntax is still far too verbose, for my tastes.)