Avoid while loop. Use break statement. If not careful, while loops can cause infinite loops.

private static void teamSearch(String teamName) {
    String subString = teamName;
    String string = "";
    boolean contains = false;

    for (int i = 0; i < clubList.size(); i++){
        string = clubList.get(i).aliases;
        if (string.contains(subString)) {
           contains = true; 
           break;
        }
    }
    System.out.println(contains);
}

I know that apache-commons has a utility class called StringUtils that could give you a elegant solution.

public boolean foo(String[] array, String pattern){
    for(String content : array){
        if(StringUtils.contains(content, pattern){
            return true;
        }
    }
    return false;
}

One thing I don't like about this is that it will only return true at the first found instance. I'm not entirely sure what you are attempting to do but if you don't if don't care about indexes in the array that don't match the pattern, I would recommend using the higher order function called filter.

Guava, lambdaJ, and Apache-Commons, are libraries that have support for functional programming.

Below is some sudo-code that should work in Apache-Commons.

List<String> content = Arrays.asList(strArray);
Predicate matchesPattern = new Predicate("asdf"){{
    private String pattern;
    public Predicate(String pattern){
        this.pattern = pattern;
    }
    @Overload
    public boolean evaluate(Object input){

        if(input instanceOf String){
            StringUtils.contains((String)input, pattern
        }
        return false;
    }
}};

CollectionUtils.filter(content, matchesPattern);

What this does is remove any String from the list that doesn't matches the pattern. As you can see it's a little verbose declaring a Predicate object. If you use Apache-Commons or Guava it's going to look similar, but that's where lambdaJ comes to the rescue.

A predicate is just term for function that takes in a single argument and returns a boolean value, you probably already used them before with the Matcher class. Hamcrest has some of the best Matcher's library available, so lambdaJ just built a functional programming library around it. It's easy to use and highly readable.

You will use Arrays.copyOfRange().

Here is an example:

String[] original = some array;
String[] grp = Arrays.copyOfRange(original, i, i + n);

The Javadocs for the Arrays class has lots of information about the method:

Approach 1:

when running document and inputting a letter, -1 is returned even if the list contains the letter.

ok, this problems @Dileep has already answered,

int retval = aList.IndexOf(letter);

Mistake is that you have passed a String type to List.indexOf(Object o) were, aList contains all elements of type Character. So List.indexOf() will always return -1.

you may change to work:

int retval = aList.indexOf(Character.toUpperCase(letter.charAt(0)));

Note: Character.toUpperCase() i have used because you have all elements in upper case.

throws

java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Character

exception message has already answered, that String cannot be a changed/cast to Character,

int index = Arrays.binarySearch(anArray, letter);

Here,

• anArray contains elements type of Character

• you have passed a String to Arrays.binarySearch(), instead of a char or Character, internally when Arrays#binarySearch() invokes Character.compareTo(T o) here, the specified object's type(i.e. letter#String) prevents it from being compared to Character object. then the ClassCastException is throwed.

Solution:

int index = Arrays.binarySearch(anArray, Character.toUpperCase(letter.charAt(0)));

Pass the strings you want to check to a method that does something like this:

        if(str.contains("(")){
           return str.substring(str.indexOf("("));
        }else{
            return null;
        }

Boyer Moore - Horspool algorithm is a fast way for string search. It is a good way to finding substrings in mega texts

You should note if this is homework.

One way to do this is:

    int i = 0;
    String searchTerm = "ta";

    System.out.println("Following substrings contain search term:");
    for (String s : "hi guys,this,is,sparta".split(",")) {
        if (s.contains(searchTerm)) System.out.println(i++);
        else i++;
    }

Or if you prefer using regex, then change s.contains(searchTerm) with s.matches(searchTerm).

If this is not homework, but interview question or work problem, this would be vastly more complex. For example: aminoacid sequence is search term and need to find locations in DNA/RNA where it is located. In that case you need more complex solution.

Examples:

• Brute-Force String Matching
• Suffix Trees String Matching Algorithm ( wiki )
• Boyer-Moore String Matching Algorithm ( wiki )
• Knuth-Morris-Pratt String Matching ( wiki )
• Sunday String Matching algorithm ( wiki )
• Horspool String Matching algorithm ( wiki )
• Rabin-Karp string matching algorithm ( wiki )
• Aho–Corasick string matching algorithm ( wiki )

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