Use

ArrayList.contains("StringToBeChecked");

If the String is present in the ArrayList, this function will return true, else will return false.

Java streams are handy for this

String[] value = {"Available to trade at 12 30", "I love sherlock"};
Stream.of(value).anyMatch(s -> s.contains("sherlock"));

If you want to get the string that has sherlock:

String[] value = {"Available to trade at 12 30", "I love sherlock"};
Stream.of(value).filter(s -> s.contains("sherlock")).findFirst().get();

Or use findAny(), if you don't care about order. Both findAny and findFirst return an Optional, which will be empty if there are no matches and .get() will throw.

That's simple with Java 8:

String str = "foo";
List<String> strings = Arrays.asList("foo", "foo", "foo", "foo", "foo");
boolean allMatch = strings.stream().allMatch(s -> s.equals(str));

For Java 7 replace the last line with:

boolean allMatch = true;
for (String string : strings) {
    if (!string.equals(str)) {
        allMatch = false;
        break;
    }
}

If you want to find if any element in mylist exists in items, you can first turn items into a Set:

Set<String> setOfItems = new HashSet<>(items);

Then, you can simply iterative over mylist and check if any element is contained in setOfItems.

mylist.stream().anyMatch(setOfItems::contains);

This brought your O(n * k) problem down to O(n + k) where n and k are the sizes of mylist and items, respectively.

Perhaps the easiest solution would be to use two List<List<String>>s instead. Assuming the List implementations used extend AbstractList, using equals will give you the desired behavior. From the documentation for AbstractList.equals:

Compares the specified object with this list for equality. Returns true if and only if the specified object is also a list, both lists have the same size, and all corresponding pairs of elements in the two lists are equal. (Two elements e1 and e2 are equal if (e1==null ? e2==null : e1.equals(e2)).) In other words, two lists are defined to be equal if they contain the same elements in the same order.

You can easily wrap a String[] in a thin List<String> implementation that extends AbstractList by using Arrays.asList.

EDIT: Here's an example:

String[] array1 = {"1", "2", "3"};
String[] array2 = {"4", "7"};

String[] array3 = {"1", "2", "3"};
String[] array4 = {"4", "7"};

List<List<String>> lst1 = new ArrayList<>();
lst1.add(Arrays.asList(array1));
lst1.add(Arrays.asList(array2));

List<List<String>> lst2 = new ArrayList<>();
lst2.add(Arrays.asList(array3));
lst2.add(Arrays.asList(array4));

System.out.println(lst1.equals(lst2)); //prints true

You are right in saying that if they are arrays you can't use Arrays.equals(), if they are List<>s then you cannot just use equals. In both cases they also check order.

So yes your main option without writing your own comparison algorithm is to use Collections.sort() on both lists.

If you don't need to check for duplicates you could drop both lists into a HashSet using addAll and then compare the two HashSet or just use List.containsAll. The bad news though is that these would both have the same limitation, if you need to compare lists that might have repeated elements then it may give incorrect results. i.e. "bob", "bob", "fred" would compare as equal to "bob", "fred", "fred".

Don't use != to compare strings. Use the equals method :

if (! Blist.get(i).equals(Alist.get(j))

But this wouldn't probably fix your algorithmic problem (which isn't clear at all).

If what you want is know what items are the same at the same position, you could use a simple loop :

int sizeOfTheShortestList = Math.min(Alist.size(), Blist.size());
for (int i=0; i<sizeOfTheShortestList; i++) {
    if (Blist.get(i).equals(Alist.get(i))) {
        System.out.println("Equals..: " + Blist.get(i));
    }
}

If you want to get items that are in both lists, use

for (int i = 0; i < Alist.size(); i++) {
    if (Blist.contains(Alist.get(i))) {
        System.out.println("Equals..: " + Alist.get(i));
    }
}