Сортировка массива в Java

добавьте строку перед println и Ваш массив будет отсортирован

Arrays.sort( array );

Это может помочь вам понять, петли, реализуя себя. Смотрите пузырь сортировки легко понять:

public void bubbleSort(int[] array) {
    boolean swapped = true;
    int j = 0;
    int tmp;
    while (swapped) {
        swapped = false;
        j++;
        for (int i = 0; i < array.length - j; i++) {
            if (array[i] > array[i + 1]) {
                tmp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = tmp;
                swapped = true;
            }
        }
    }
}

конечно, вы не должны использовать его в производстве, так как есть более эффективные алгоритмы для больших списков, таких как QuickSort или MergeSort которые реализуются Arrays.sort(array)

посмотри массивы.сортировка ()

Я был ленив и добавил петли

import java.util.Arrays;


public class Sort {
    public static void main(String args[])
    {
        int [] array = new int[10];
        for ( int i = 0 ; i < array.length ; i++ ) {
            array[i] = ((int)(Math.random()*100+1));
        }
        Arrays.sort( array );
        for ( int i = 0 ; i < array.length ; i++ ) {
            System.out.println(array[i]);
        }
    }
}

Ваш массив имеет длину 10. Вам нужна одна переменная (i), которая принимает значения от 0до 9.

for ( int i = 0  ; i < array.length ;   i++ ) 
       ^               ^                   ^
       |               |                   ------  increment ( i = i + 1 )
       |               |
       |               +-------------------------- repeat as long i < 10
       +------------------------------------------ start value of i


Arrays.sort( array );

- это библиотека методов, которая сортирует массивы.

Arrays.sort(yourArray)

сделает работу отлично

посмотреть ниже, это даст вам сортировка по возрастанию и по убыванию оба

import java.util.Arrays;
import java.util.Collections;

public class SortTestArray {

/**
 * Example method for sorting an Integer array
 * in reverse & normal order.
 */
public void sortIntArrayReverseOrder() {

    Integer[] arrayToSort = new Integer[] {
        new Integer(48),
        new Integer(5),
        new Integer(89),
        new Integer(80),
        new Integer(81),
        new Integer(23),
        new Integer(45),
        new Integer(16),
        new Integer(2)
    };

    System.out.print("General Order is    : ");

    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }


    Arrays.sort(arrayToSort);

    System.out.print("\n\nAscending Order is  : ");

    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }


    Arrays.sort(arrayToSort, Collections.reverseOrder());
    System.out.print("\n\nDescinding Order is : ");
    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }

}


/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    SortTestArray SortTestArray = new SortTestArray();
    SortTestArray.sortIntArrayReverseOrder();
}}

выход будет

General Order is    : 48 5 89 80 81 23 45 16 2 

Ascending Order is  : 2 5 16 23 45 48 80 81 89 

Descinding Order is : 89 81 80 48 45 23 16 5 2 

Примечание: вы можете использовать математику.ranodm вместо добавления ручных чисел. Дайте мне знать, если мне нужно изменить код...

Удачи... Ура!!!

вот как это использовать в вашей программе:

public static void main(String args[])
{
    int [] array = new int[10];

    array[0] = ((int)(Math.random()*100+1));
    array[1] = ((int)(Math.random()*100+1));
    array[2] = ((int)(Math.random()*100+1));
    array[3] = ((int)(Math.random()*100+1));
    array[4] = ((int)(Math.random()*100+1));
    array[5] = ((int)(Math.random()*100+1));
    array[6] = ((int)(Math.random()*100+1));
    array[7] = ((int)(Math.random()*100+1));
    array[8] = ((int)(Math.random()*100+1));
    array[9] = ((int)(Math.random()*100+1));

    Arrays.sort(array); 

    System.out.println(array[0] +" " + array[1] +" " + array[2] +" " + array[3]
    +" " + array[4] +" " + array[5]+" " + array[6]+" " + array[7]+" " 
    + array[8]+" " + array[9] );        

}

просто FYI, теперь вы можете использовать Java 8 новый API для сортировки любого типа массива с помощью parallelSort

parallelSort использует Fork / Join framework, представленную в Java 7, чтобы назначить задачи сортировки нескольким потокам, доступным в пуле потоков.

два метода, которые могут быть использованы для сортировки int массив,

parallelSort(int[] a)
parallelSort(int[] a,int fromIndex,int toIndex)

int[] array = {2, 3, 4, 5, 3, 4, 2, 34, 2, 56, 98, 32, 54};

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array.length; j++) {
        if (array[i] < array[j]) {
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
}

вы можете сортировать массив int с помощью Arrays.sort( array ).

в естественном порядке : Array.sort(array)

в обратном порядке : Array.sort(array, Collections.reverseOrder()); -- > это статический метод в классе коллекций, который в дальнейшем вызовет внутренний класс сам по себе, чтобы вернуть обратный компаратор.

САМЫЙ ЭФФЕКТИВНЫЙ СПОСОБ!

public static void main(String args[])
{
    int [] array = new int[10];//creates an array named array to hold 10 int's
    for(int x: array)//for-each loop!
      x = ((int)(Math.random()*100+1));
    Array.sort(array);
    for(int x: array)
      System.out.println(x+" ");
}

Java 8 предоставляет возможность использования потоков, которые могут быть использованы для сортировки int[] array как:

int[] sorted = Arrays.stream(array).sorted().toArray(); // option 1
Arrays.parallelSort(array); //option 2

как говорится в doc на parallelSort:

алгоритм сортировки-это параллельная сортировка-слияние, которое разбивает массив в суб-массивы, которые сами сортируются, а затем объединяются. Когда длина подрешетки достигает минимальной детализации, подрешетка равна сортировка с использованием соответствующих массивов.метод сортировки. Если длина указанный массив меньше минимальной детализации, то это сортировка с использованием соответствующих массивов.метод сортировки. Алгоритм требуется рабочее пространство не больше размера оригинала матрица. Общий пул ForkJoin используется для выполнения любых параллельных задач.

так что если входной массив меньше, чем гранулярность (8192 элементов в Java 9 и 4096 в Java 8 я считаю), то parallelSort просто вызывает последовательный алгоритм сортировки.

на всякий случай мы хотим обратная сортировка целочисленного массива мы можем использовать компаратор как:

int[] reverseSorted = IntStream.of(array).boxed()
                        .sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray();

поскольку Java не имеет возможности сортировать примитивы с помощью пользовательского компаратора, мы должны использовать промежуточный бокс или какую-либо другую стороннюю библиотеку, которая реализует такую примитивную сортировку.

вы можете использовать массивы.сортировка ().

sort() method is a java.util.Arrays class method.          
Declaration : Arrays.sort(arrName)