Finding the longest sequence of increasing numbers in an array A continuation of  this queston.
The task's description can also be found there.

After reformatting the code and getting rid of the ArrayIndexOutOfBounds check,it now looks like this:

public static List&lt;Integer&gt; findLongestIncreasingSequence(int[] numbersToBeProcessed) {

        if (numbersToBeProcessed.length == 0) {
            return null;
        }

        List&lt;Integer&gt; longestIncreasingSequence = new ArrayList&lt;Integer&gt;();
        List&lt;Integer&gt; currentNumbersSequence = new ArrayList&lt;Integer&gt;();

        // the first number will be added always,no matter what
        currentNumbersSequence.add(numbersToBeProcessed[0]);

        for (int i = 1; i &lt; numbersToBeProcessed.length; i++) {

            int currentNumber = numbersToBeProcessed[i];
            int previousNumber = numbersToBeProcessed[i - 1];

            if (currentNumber &gt; previousNumber) {
                currentNumbersSequence.add(currentNumber);
            } else {
                // checks if the current sequence is bigger
                if (currentNumbersSequence.size() &gt; longestIncreasingSequence.size()) {
                    longestIncreasingSequence.clear();
                    longestIncreasingSequence.addAll(currentNumbersSequence);
                }
                // clear the current sequence so it can start all over again
                currentNumbersSequence.clear();
                // after clearing add the current number as the first of the new
                // sequence
                currentNumbersSequence.add(currentNumber);
            }
        }
        // at the end of the loop always compare the two sequences.
        if (currentNumbersSequence.size() &gt; longestIncreasingSequence.size()) {
            longestIncreasingSequence.clear();
            longestIncreasingSequence.addAll(currentNumbersSequence);
        }
        return longestIncreasingSequence;
    }


There are couple of things that bother me about the algorithm above:


We never actually check the n-1 number at the start of the algorithm - instead we directly check if the n number and we process it. This is why I have added the  currentNumbersSequence.add(numbersToBeProcessed[0]); code line before we go in the for loop.
What if the last n number is bigger than n-1? That means that we do not go into the else statement and the current sequence will never be compared against the largest one at this moment.
This is why I had to add an extra check after the for loop. However it leads to a very obvious code repetition.
No need for temporary lists
In your last review, it was mentioned that you could just use two integers to keep track of the sequences instead of two whole lists.  So instead of currentNumbersSequence and longestIncreasingSequence, you could track just the start and length of those two sequences.  The code then becomes:
public static List&lt;Integer&gt; findLongestIncreasingSequence(int[] numbersToBeProcessed) {

    if (numbersToBeProcessed.length == 0) {
        return null;
    }

    int bestStart  = 0;
    int curStart   = 0;
    int bestLength = 1;
    int curLength  = 1;

    for (int i = 1; i &lt; numbersToBeProcessed.length; i++) {
        if (numbersToBeProcessed[i] &gt; numbersToBeProcessed[i-1]) {
            curLength++;
            if (curLength &gt; bestLength) {
                bestStart  = curStart;
                bestLength = curLength;
            }
        } else {
            curStart  = i;
            curLength = 1;
        }
    }
    ArrayList&lt;Integer&gt; ret = new ArrayList&lt;&gt;(bestLength);
    for (int i = 0; i &lt; bestLength; i++) {
        ret.add(numbersToBeProcessed[bestStart+i]);
    }
    return ret;
}