"Does an array contain the same elements as another array?" Write a static method named contains that accepts two arrays of
  integers a1 and a2 as parameters and that returns a boolean value
  indicating whether or not a2's sequence of elements appears in a1
  (true for yes, false for no). The sequence of elements in a2 may
  appear anywhere in a1 but must appear consecutively and in the same
  order. For example, if variables called list1 and list2 store the
  following values:
  
  int[] list1 = {1, 6, 2, 1, 4, 1, 2, 1, 8}; int[] list2 = {1, 2, 1};
  
  Then the call of contains(list1, list2) should return true because
  list2's sequence of values {1, 2, 1} is contained in list1 starting at
  index 5. If list2 had stored the values {2, 1, 2}, the call of
  contains(list1, list2) would return false because list1 does not
  contain that sequence of values. Any two lists with identical elements
  are considered to contain each other, so a call such as
  contains(list1, list1) should return true.
  
  You may assume that both arrays passed to your method will have
  lengths of at least 1. You may not use any Strings to help you solve
  this problem, nor methods that produce Strings such as
  Arrays.toString.


I'm looking for general feedback to improve my future code. I'm intent on learning Java, so any style tips would be well appreciated. Other ways to accomplish this task?

public static boolean contains(int[] list1, int[] list2) {
    for (int i = 0; i &lt;= (list1.length - list2.length); i++) {
        if (list1[i] == list2[0]) {
            for (int j = 1; j &lt; list2.length; j++) {
                if (list1[i + j] == list2[j]) {
                    if (j == (list2.length - 1)) {
                        return true;
                    }
                } else {
                    break;
                }
            }
        }
    }
    return false;
}
if (list1[i] == list2[0]) {
            for (int j = 1; j &lt; list2.length; j++) {
                if (list1[i + j] == list2[j]) {



We can drop this from three lines to one.  

        for (int j = 0; j &lt; list2.length &amp;&amp; list1[i + j] == list2[j]; j++) {


A side benefit is that this handles the case where list2 is empty (zero length).  The original code would crash in that case.  

At the expense of an extra comparison (which could be compiled out), we get rid of two levels of indent and 


                } else {
                    break;



Because this will leave the loop automatically.  It won't be necessary to break out manually.  

It might be better to replace 


        if (list1[i] == list2[0]) {
            for (int j = 1; j &lt; list2.length; j++) {
                if (list1[i + j] == list2[j]) {
                    if (j == (list2.length - 1)) {
                        return true;
                    }
                } else {
                    break;
                }
            }
        }



with 

        int j = 0;
        while (j &lt; list2.length &amp;&amp; list1[i + j] == list2[j]) {
            j++;
        }

        if (j == list2.length) {
            return true;
        }


Moving the scope of j outside the inner loop allows us to move the test out of the loop as well.  So rather than testing on every iteration, we can test just once.  

Alternately 

        for (int j = 0; list1[i + j] == list2[j]; j++) {
            if (j + 1 &gt;= list2.length) {
                return true;
            }
        }


Does the same thing as the original code.  It may not be obvious, but this does the same thing with fewer comparisons.  

But we're back to throwing an exception if list2 is zero length.  This does exactly the same thing as the original code with fewer comparisons and less code.