Determine if elements in an ArrayList are consecutively ordered Write a method isConsecutive that accepts an ArrayList of integers as
  a parameter and returns true if the list contains a sequence of
  consecutive integers and false otherwise. Consecutive integers are
  integers that come one after the other in ascending order, as in 5, 6,
  7, 8, 9, etc. For example, if a variable called list stores the values
  [3, 4, 5, 6, 7, 8, 9], then the call of list.isConsecutive() should
  return true. If the list instead stored [3, 4, 5, 6, 7, 12, 13] then
  the call should return false because the numbers 7 and 12 are not
  consecutive. The list [3, 2, 1] might seem to be consecutive, but the
  elements appear in reverse order, so the method would return false in
  that case. Any list with fewer than two values should be considered to
  be consecutive. You may assume that the list passed is not null.


Wondering which better ways there are to do this, and how to improve my future code.

public boolean isConsecutive(ArrayList&lt;Integer&gt; list) {
    int count = 0;
    for (int i = 0; i &lt; list.size() - 1; i++) {
        if (list.get(i) == (list.get(i + 1) - 1)) {
            count++;
        } else {
            count = 0;
        }
    }
    return list.size() - 1 == count || list.isEmpty();
}
You don't need a counter in your code:

public boolean isConsecutive(ArrayList&lt;Integer&gt; list) {
    for (int i = 0; i &lt; list.size() - 1; i++) {
        if (list.get(i) != list.get(i + 1) - 1) {
            return false;
        }
    }
    return true;
}


As a next step, you can change the loop to start at 1 instead of 0, so that the loop condition becomes simpler.

public boolean isConsecutive(ArrayList&lt;Integer&gt; list) {
    for (int i = 1; i &lt; list.size(); i++) {
        if (list.get(i - 1) + 1 != list.get(i)) {
            return false;
        }
    }
    return true;
}


The specification does not require the algorithm to be constant-time (it's not used for cryptography), therefore it should be OK to return as soon as you know the answer.

To be extra correct, you could detect integer overflows:

int prev = list.get(i - 1);
if (prev != list.get(i) /* mismatch */ || prev + 1 &lt; prev /* overflow */) {
    return false;
}


If the requirements were to change that you may only access each list element once, you would need to remember the previous value.

public boolean isConsecutive(ArrayList&lt;Integer&gt; list) {
    Iterator&lt;Integer&gt; it = list.iterator();
    if (!it.hasNext()) {
        return true;
    }

    int prev = it.next();
    while (it.hasNext()) {
        int curr = it.next();
        if (prev + 1 != curr /* mismatch */ || prev + 1 &lt; prev /* overflow */) {
            return false;
        }
        prev = curr;
    }
    return true;
}