Java number sorting algorithm - remove ugly break
//find length of array to control loop
    int length = numbers.length-1; 

    //do not exceed length of array in loop
    for (int outer = 0; outer&lt;length; outer++){

        //reset second counter
        int inner = 0;

        //keep looping while two consecutive numbers are not in order
        while (numbers[outer+inner]&gt;numbers[outer+inner+1]) {

            //swap numbers that are not in order
            int temp = numbers[outer+inner];
            numbers[outer+inner] = numbers[outer+inner+1];
            numbers[outer+inner+1] = temp;

            //decrement and see if numbers need swapped again
            inner--;

            //break on negative index to prevent overflow error
            if (outer+inner&lt;0) {
                break;
            }
        }
    }



Consider 

    for (int i = 1; i &lt; numbers.length; i++) {
        // insert the ith element in its correct position among the elements up to i
        for (int j = i; j &gt; 0 &amp;&amp; numbers[j - 1] &gt; numbers[j]; j--) {
            int temp = numbers[j - 1];
            numbers[j - 1] = numbers[j];
            numbers[j] = temp;
        }
    }


Rather than calculate inner + outer, we just track one value, which we call j.  Because we set it to the value of i, it will have the same values as inner + outer had in the original.  

By moving the check for negative values into the loop control, we don't have to break.  We do end up doing an extra check because of that.  

I prefer more horizontal whitespace to break up each line into more easily readable pieces.  

I reduced the comments down to just one, which I believe is the only line that actually requires thinking to read.  I tried to explain the goal of that section of code rather than simply restate what the code does.  

Incidentally, this algorithm is called an insertion sort.  It's one of the \$\mathcal{O}(n^2)\$ sorts.  The built-in sort that Java uses is capable of \$\mathcal{O}(n\log n)\$ complexity.  You would normally only use an insertion sort for small input sizes.  For any decent sized input, a loglinear sort like quicksort or mergesort would be faster.  Of course, you may be reinventing-the-wheel on purpose, for learning purposes.  When you do that, including the tag can better focus feedback.