В убывающем порядке

Алгоритм сортировки пузырьком 1) создаем бесконечный цикл while с флажком

boolean isSorted = false;
while(!isSorted){
    isSorted = true              // в конце поймете
}

2) внутри создаем цикл for чтобы сравнивать элементы нашего массива

for(int i = 1; i < massiv.length; i++){}

3) если первый элемент [i] больше чем нолевой элемент [i - 1] то меняем их местами с помощью временного переменного

int template = list[i];
list[i] = list[i - 1]
list[i - 1] = template;
isSorted = false;

Сортировка пузырьком требует несколько десятков итераций(циклов) чтобы массив полностью отсортировался. А как мы поймем что он отсортирован? Верно если элементы массива не меняются местами значит он полностью отсортирован и флажок в конце isSorted = false не сработает а флажок вначале цикла while isSorted = true сработает и цикл остановится

Можно же по человечески решить через Collections.reverseOrder(), но нет давайте снова пузырьком.

Решил с 4 попытки только из-за того, что перепутал строку

sort(array);

с

Arrays.sort(array);

Думал, вроде массив отсортирован, а выводит почему-то неправильно

Пипец издевательство, а не задача! Решить её на 7-м уровне - нереально. Я с 14-го её ели решил, да и то коряво, до ужаса. Умножил сначала весь массив на -1. Код сортировки нагуглил. Опять умножил всё на минус один. Как правильное решение JR даёт эту самую сортировку (пузырьком), только с изменёнными знаками. Вот тут можно посмотреть прямую. http://study-java.ru/uroki-java/urok-11-sortirovka-massiva/

Блин, мне так тяжело даются алгоритмы(( Не смогла написать свою сортировку, решила чрез стандартный Arrays.sort(). может кто-нибудь посоветует что-нибудь по алгоритмам(кроме Кормена). Искала много информации в интернете, но всегда полезно узнать что-то напрямую от людей.

Все пишут про пузырьковую сортировку, но с помощью сортировки выбором тоже удобно решать эту задачу: http://study-java.ru/uroki-java/urok-11-sortirovka-massiva/

Задачу решил, но не могу понять почему после вызова метода сортировки sort, массив array становится отсортированным, ведь метод sort ничего не возвращает. В случае с простой переменной, все нормально и ее значение сохраняется. Где про это можно почитать?

int[] array = new int[20];
      for (int i = 0; i < 20; i++) {
          array[i] = Integer.parseInt(reader.readLine());
      }

      sort(array);

      for (int x : array) {
          System.out.println(x);
      }

Решил расписать для себя, чтобы понять, как поэтапно происходит сортировка "пузырьком", возможно кому-то будет полезно, чтобы разобраться:

boolean sorted = false; // устанавливаем значение false для переменной sorted
int temp; // вводим переменную в которую будем перекидывать значения из массива
while(!sorted) { // повторяем цикл пока sorted не равно true
    sorted = true; // устанавливаем значение true на тот случай, если if не сработает ни разу.

    for (int i = 0; i < array.length - 1; i++) { // уменьшаем длину массива на 1, чтобы не выходить за пределы массива

        if (array[i] < array[i+1]) { // на первой итерации сравниваем array[0] и array[1], если array[0] меньше, то ->
            //выполняем следующий блок команд:
            temp = array[i]; // присваиваем переменной temp значение array[0]
            array[i] = array[i+1]; // присваиваем array[0] значение array[1] , т.е. меняем их местами: array[1] -> array[0]
            array[i+1] = temp; // присваиваем array[1], значение из temp, т.е. бывшее значение array[0] -> array[1]
            sorted = false; // поскольку условие if = true, мы меняем переменную sorted на false, чтобы цикл сработал еще раз.

        /*
        Цикл for пройдет по длине всего массива и сравнит друг с другом соседние числа, те числа, что окажутся меньше, чем число справа, переместятся на их место, т.е. как бы "всплывут", поэтому этот метод называется пузырьковой сортировкой.
         */
        }
    }
}

P.S. Если где-то ошибся в терминах, не судите строго :)

Те кто решит делать через Collections.reverseOrder() c заменой int на Integer - не стоит... работать будет, но валидатор не примет.