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

Question

Я пытаюсь создать программу, состоящую из массива из 10 целых чисел, все из которых имеют случайное значение, настолько хорошее.

Однако, теперь мне нужно отсортировать их по порядку от самого низкого до самого высокого значения, а затем распечатать его на экране, как бы я это сделал?

(Извините за то, столько кода для программы, маленький, я не то, что хорошо с петлями, только начал работать с Java)

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)); 

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

} 

Answer 1

Loops также очень полезно узнать о том, особ При использовании массивов,

int[] array = new int[10]; 
Random rand = new Random(); 
for (int i = 0; i < array.length; i++) 
    array[i] = rand.nextInt(100) + 1; 
Arrays.sort(array); 
System.out.println(Arrays.toString(array)); 
// in reverse order 
for (int i = array.length - 1; i >= 0; i--) 
    System.out.print(array[i] + " "); 
System.out.println(); 

Answer 2

Посмотрите на Arrays.sort()

Answer 3

Вы можете сортируйте массив int с Arrays.sort(array).

Answer 4

Добавьте строку перед Println и ваш массив получает отсортирован

Arrays.sort(array); 

Answer 5

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

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 или слияния, которые реализуются

Answer 6

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

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); 

Является библиотечным методом, который сортирует массивы.

Answer 7

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

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]);   

} 

Answer 8

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

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 

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

Удачи ... Приветствия !!!

Answer 9

Arrays.sort(yourArray) 

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

Answer 10

Вот что я сделал:

System.out.print("Enter number of student: "); 
input = myScan.nextInt(); 

int[] scores = new int[input]; 
String[] students = new String[input]; 
try { 

    for (int index = 0; index < input; index++) { 
     System.out.print("Enter student: "); 
     students[index] = myBuff.readLine(); 
     System.out.print("Enter score for " + students[index] + ": "); 
     scores[index] = myScan.nextInt(); 
    } 

    //Sorting the numbers 
    for (int index = 0; index < input; index++) { 
     for (int index1 = 0; index1 < input - 1; index1++) { 
      if (scores[index1] > scores[index1 + 1]) { 

       contain = scores[index1]; 
       containS = students[index1]; 
       scores[index1] = scores[index1 + 1]; 
       students[index1] = students[index1 + 1]; 
       scores[index1 + 1] = contain; 
       students[index1 + 1] = containS; 

      } 
     } 
    } 

Answer 11

import java.util.*; 

public class Sample4You { 

    public static void main(String[] args) { 

     int[] YourList = new int[10]; 
     int x; 

     //this is for placing the randomly generated numbers into each index 
     for (x = 1; x < 10; x++) { 
      YourList[x] = (int) (Math.random() * 100); 
     } 

     Arrays.sort(YourList);//we must sort the array "YourList"from least 2 greatest 

     //now we print all the numbers 1 by 1 -- 
     for (x = 0; x < YourList.length; x++) { 
      System.out.println("Number in index [" + x + "] = " + YourList[x]); 
     } 
    } 
} 

Answer 12

Он хотел это в своем коде.

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)); 

    Array.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]); 

} 

Answer 13

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

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

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

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

Answer 14

САМЫЙ ЭФФЕКТИВНЫЙ ПУТЬ!

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+" "); 
} 

Answer 15

int []array = {5,8,2,1,3,0,1,7}; 
    int min = 0; 
    int temp; 

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

     } 
     temp = array[i]; 
     array[i] = array[min]; 
     array[min] = temp; 
    } 

Answer 16

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; 
     } 
    } 
} 

Answer 17

Для естественного порядка: Array.sort(array)

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

Answer 18

Вы можете использовать функцию Arrays.sort().

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

Answer 19

элегантное решение использовать поток API.It не лучший способ использовать его здесь, потому что вы тратите ресурсы для преобразования из Int -> Integer, но я хотел показать, что поток API является мощным инструментом для создайте любую логику, которую вы хотите в разных ситуациях.

int[] ints= {53,95,1,3,534,94,4356,5,1,114}; 
    List<Integer> integers = new ArrayList<>(); 
    Collections.addAll(integers, Arrays.stream(ints).boxed().toArray(Integer[]::new));//Converting int into Integer and put to arrayList 
    integers.sort(Comparator.comparingInt(o -> o));//sorting 
    integers.forEach(System.out::println);//printing 

С точки зрения производительности лучше использовать класс массивов.

Arrays.sort(ints); 

Answer 20

Я использую цикл, чтобы установить массив значений

int[] array = new int[10]; 

for (int i = 0; i < array.length; i++) { 
      int x = (int) (Math.random() * 100+1); 
      array[i] = x; 
     } 

     boolean flag = true; //flag to exit while loop 
     int tempValue; // temporary value for swapping the array values 
     while (flag) { 
      flag = false; 
      for (int i = 0; i < (array.length) - (1); i++) { 
       if (array[i] > array[i + 1]) { 
        tempValue = array[i]; 
        array[i] = array[i + 1]; 
        array[i + 1] = tempValue; 
        flag = true; 
       } 
      } 
     } 
     System.out.println("Ascending order\n" +Arrays.toString(array)); // print the ordered array values 

Answer 21

Вы можете это нравится ::

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)); 

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

    Arrays.sort(array); 
    System.out.println("After sorting array:: "); 
    for (int i = 0; i < array.length; i++) { 
     System.out.print(array[i] + " "); 
    } 
} 

Вы должны импортировать java.util.Arrays; в программу, чтобы использовать метод Arrays.sort ,

Answer 22

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

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

Как уже упоминалось в doc для parralelSort:

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

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

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

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

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

Answer 23

Простое решение:

private static void sortArray(int[] arr) { 

    for (int i = 0; i <arr.length-1; i++) { 
     for (int j = 1; j <arr.length-i; j++) { 

      if(arr[j-1]>arr[j]) { 
       int temp = arr[j-1]; 
       arr[j-1] = arr[j]; 
       arr[j] = temp; 
      } 

     } 
    } 

    System.out.println(Arrays.toString(arr)); 
}