There are a few ways.

Which one you choose is up to you, there's a tradeoff between verbosity, being constrained to a simple equals check (if you want to do more complicated matching, you can't easily do Option 1), and using newer APIs that you might not yet support or be familiar with.

Option 1: The Collection.contains() method:

List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("orange");
fruits.add("banana");

if (fruits.contains("banana") {
    System.out.println("Found");
} else {
    throw new SkipException("could not be found");
}

Option 2: Using a for loop with external state:

List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("orange");
fruits.add("banana");

boolean found = false;
for (String s : fruits) {
    if (s.equals("banana")) {
        found = true;
        break; // Break out of the loop to skip the remaining items
    }
}
if (found) {
    System.out.println("Found");
} else {
    throw new SkipException("could not be found");
}

Option 3: If you're using Java 8, the neat Stream.anyMatch() method:

List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("orange");
fruits.add("banana");

if (fruits.stream().anyMatch(s -> s.equals("banana"))) {
    System.out.println("Found");
} else {
    throw new SkipException("could not be found");
}

Option 3 is my personal favorite, as it's nearly as compact as Option 1, but allows to to provide a more complex Predicate if you want a comparison based on something other than the equals() method.

With Java 8 Stream API:

List<String> myList = Arrays.asList("  A", "B  ", "  C  ");
return myList.stream().anyMatch(str -> str.trim().equals("B"));

temp = bankAccNos.contains(no) ? 1 : 2;

EDIT: Here is an update using the Java 8 Streaming API. So much cleaner. Can still be combined with regular expressions too.

public static boolean stringContainsItemFromList(String inputStr, String[] items) {
    return Arrays.stream(items).anyMatch(inputStr::contains);
}

Also, if we change the input type to a List instead of an array we can use items.stream().anyMatch(inputStr::contains).

You can also use .filter(inputStr::contains).findAny() if you wish to return the matching string.

Important: the above code can be done using parallelStream() but most of the time this will actually hinder performance. See this question for more details on parallel streaming.

Original slightly dated answer:

Here is a (VERY BASIC) static method. Note that it is case sensitive on the comparison strings. A primitive way to make it case insensitive would be to call toLowerCase() or toUpperCase() on both the input and test strings.

If you need to do anything more complicated than this, I would recommend looking at the Pattern and Matcher classes and learning how to do some regular expressions. Once you understand those, you can use those classes or the String.matches() helper method.

public static boolean stringContainsItemFromList(String inputStr, String[] items)
{
    for(int i =0; i < items.length; i++)
    {
        if(inputStr.contains(items[i]))
        {
            return true;
        }
    }
    return false;
}

you don't have to do this:

if(Arrays.asList(list).contains("Paul"))

because the identifier list is already an ArrayList

you'll need to do:

if(list.contains("Paul")){
    System.out.println("Yes it does");
}

Your code is more complicated than it needs to be, but it gets the job done.

The awkward part of your code is the use of the various index values i, j, and k. Really, you don't need them at all. If you rename things a bit, and use "enhanced-for" loops, it becomes:

public boolean compareTwoList(List<String> models, List<String> titleOfVehicles) {

    for(String title : titleOfVehicles) {
        boolean found = false;
        for(String model : models) {
            if(title.contains(model)) {
                found = true;
                break;
            }
        }
        if (!found) {
            return false;
        }
    }    
    return true;
}

Note that the logic is essentially the same, but you focus on the important things. The found variable is a better name, and it's scope is limited to inside the outer for-loop. The hard-to-understand k loop-terminator is removed.

Note, using streams, and a regular expression, would actually be more compact solution, but may not be as readable... I played with the stream version and a regex, and got:

public static boolean compareTwoList(List<String> models, List<String> titleOfVehicles) {

    String pattern = models.stream()
          .map(Pattern::quote)
          .collect(Collectors.joining("|", ".*(", ").*"));

    Pattern re = Pattern.compile(pattern);

    return titleOfVehicles.stream()
        .allMatch(t -> re.matcher(t).matches());

}

(which you can see working here: https://ideone.com/8sqKu7 )