Is er een eenvoudige manier om een array in aflopende volgorde te sorteren zoals hoe ze een soort in oplopende volgorde hebben in de arrays class ?
of moet ik stoppen met lui zijn en dit zelf doen: [
1, Autoriteit 100%
U kunt dit gebruiken om alle soorten objecten
te sorteren
sort(T[] a, Comparator<? super T> c)
Arrays.sort(a, Collections.reverseOrder());
Arrays.sort()kan niet rechtstreeks worden gebruikt om primitieve arrays in aflopende volgorde te sorteren. Als u probeert de Arrays.sort()-methode te bellen door omgekeerde comparator die is gedefinieerd door Collections.reverseOrder(), gooit deze de fout
Geen geschikte methode gevonden voor Sort (int [], comparator)
Dat werkt prima met ‘reeks objecten’ zoals integer-array, maar werkt niet met een primitieve array zoals int array.
De enige manier om een primitieve array in aflopende volgorde te sorteren, is eerst de array in oplopende volgorde sorteren en vervolgens de array op zijn plaats omdraaien. Dit geldt ook voor tweedimensionale primitieve arrays.
2, Autoriteit 28%
Voor een lijst
Collections.sort(list, Collections.reverseOrder());
voor een array
Arrays.sort(array, Collections.reverseOrder());
3, Autoriteit 24%
U kunt dit gebruiken:
Arrays.sort(data, Collections.reverseOrder());
Collections.reverseOrder()retourneert Comparatormet de inverse natuurlijke orde. U kunt een omgekeerde versie van uw eigen comparator te krijgen met behulp van Collections.reverseOrder(myComparator).
4, Autoriteit 20%
een alternatief zou kunnen zijn (voor nummers !!!)
- vermenigvuldigen de Array met -1
- sort
- vermenigvuldigen opnieuw met -1
Letterlijk gesproken:
array = -Arrays.sort(-array)
5, gezag 14%
zonder uitdrukkelijke vergelijker:
Collections.sort(list, Collections.reverseOrder());
met expliciete comparator:
Collections.sort(list, Collections.reverseOrder(new Comparator()));
6, Autoriteit 3%
Het is niet meer mogelijk sort keren een reeks van primitieven (bijvoorbeeld int[] arr = {1, 2, 3};) met Arrays.sort()en Collections.reverseOrder()omdat die vereisen verwijzingstypen (Integer) in plaats van primitieve (int).
Maar we kunnen Java 8 Stroom van de array gebruiken om eerste vak te sorteren in omgekeerde volgorde:
// an array of ints
int[] arr = {1, 2, 3, 4, 5, 6};
// an array of reverse sorted ints
int[] arrDesc = Arrays.stream(arr).boxed()
.sorted(Collections.reverseOrder())
.mapToInt(Integer::intValue)
.toArray();
System.out.println(Arrays.toString(arrDesc)); // outputs [6, 5, 4, 3, 2, 1]
7, Autoriteit 3%
Java 8:
Arrays.sort(list, comparator.reversed());
Update:
reversed()keert de opgegeven comparator om. Meestal bestellen comparators oplopend, dus dit verandert de volgorde om af te dalen.
8, Autoriteit 2%
Eerst moet u uw array sorteren met:
Collections.sort(myArray);
Dan moet u de bestelling ombergen van oplopend naar aflopend met behulp van:
Collections.reverse(myArray);
9, Autoriteit 2%
Voor array die elementen van primitieven bevat als er org.apache.commons.lang(3)op de beschikking eenvoudige manier om de array (na het sorteren ervan) te gebruiken:
ArrayUtils.reverse(array);
10
Ik weet niet wat uw gebruikscase was, maar in aanvulling op andere antwoorden hier is een andere (luie) optie om nog steeds in oplopende volgorde te sorteren terwijl u aangeeft, maar vervolgens in omgekeerd bestelling .
Antwoord 11
Voor bovenstaande discussies is hier een eenvoudig voorbeeld om de primitieve arrays in aflopende volgorde te sorteren.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] nums = { 5, 4, 1, 2, 9, 7, 3, 8, 6, 0 };
Arrays.sort(nums);
// reverse the array, just like dumping the array!
// swap(1st, 1st-last) <= 1st: 0, 1st-last: nums.length - 1
// swap(2nd, 2nd-last) <= 2nd: i++, 2nd-last: j--
// swap(3rd, 3rd-last) <= 3rd: i++, 3rd-last: j--
//
for (int i = 0, j = nums.length - 1, tmp; i < j; i++, j--) {
tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
// dump the array (for Java 4/5/6/7/8/9)
for (int i = 0; i < nums.length; i++) {
System.out.println("nums[" + i + "] = " + nums[i]);
}
}
}
Uitvoer:
nums[0] = 9
nums[1] = 8
nums[2] = 7
nums[3] = 6
nums[4] = 5
nums[5] = 4
nums[6] = 3
nums[7] = 2
nums[8] = 1
nums[9] = 0
Antwoord 12
Ik weet dat dit een vrij oude thread is, maar hier is een bijgewerkte versie voor integers en Java 8:
Arrays.sort(array, (o1, o2) -> o2 - o1);
Merk op dat het “o1 – o2” is voor de normale oplopende volgorde (of Comparator.comparingInt()).
Dit werkt ook voor alle andere soorten objecten. Zeg:
Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());
Antwoord 13
Er is hier een hoop rommel gaande – mensen stellen oplossingen voor niet-primitieve waarden voor, proberen een aantal sorteeralgo’s vanaf de grond te implementeren, geven oplossingen met extra bibliotheken, pronken met enkele hacky’s enz. Het antwoord op het origineel vraag is 50/50. Voor degenen die alleen willen kopiëren/plakken:
// our initial int[] array containing primitives
int[] arrOfPrimitives = new int[]{1,2,3,4,5,6};
// we have to convert it into array of Objects, using java's boxing
Integer[] arrOfObjects = new Integer[arrOfPrimitives.length];
for (int i = 0; i < arrOfPrimitives.length; i++)
arrOfObjects[i] = new Integer(arrOfPrimitives[i]);
// now when we have an array of Objects we can use that nice built-in method
Arrays.sort(arrOfObjects, Collections.reverseOrder());
arrOfObjectsis nu {6,5,4,3,2,1}. Als je een array hebt van iets anders dan ints, gebruik dan het bijbehorende objectin plaats van Integer.
Antwoord 14
Als een array een type Integer-klasse is, kun je het onderstaande gebruiken:
Integer[] arr = {7, 10, 4, 3, 20, 15};
Arrays.sort(arr, Collections.reverseOrder());
Als een array een type int-gegevenstype is, kun je het onderstaande gebruiken:
int[] arr = {7, 10, 4, 3, 20, 15};
int[] reverseArr = IntStream.rangeClosed(1, arr.length).map(i -> arr[arr.length-i]).toArray();
Antwoord 15
Om 2D-arrays in aflopende volgorde te sorteren, kunt u gewoon de posities van de parameters omdraaien
int[][] array= {
{1, 5},
{13, 1},
{12, 100},
{12, 85}
};
Arrays.sort(array, (a, b) -> Integer.compare(a[1], b[1])); // for ascending order
Arrays.sort(array, (b, a) -> Integer.compare(a[1], b[1])); // for descending order
Uitvoer voor aflopend
12, 100
12, 85
1, 5
13, 1
Antwoord 16
Dit werkte voor mij:
package doublearraysort;
import java.util.Arrays;
import java.util.Collections;
public class Gpa {
public static void main(String[] args) {
// initializing unsorted double array
Double[] dArr = new Double[] {
new Double(3.2),
new Double(1.2),
new Double(4.7),
new Double(3.3),
new Double(4.6),
};
// print all the elements available in list
for (double number : dArr) {
System.out.println("GPA = " + number);
}
// sorting the array
Arrays.sort(dArr, Collections.reverseOrder());
// print all the elements available in list again
System.out.println("The sorted GPA Scores are:");
for (double number : dArr) {
System.out.println("GPA = " + number);
}
}
}
Uitgang:
GPA = 3.2
GPA = 1.2
GPA = 4.7
GPA = 3.3
GPA = 4.6
The sorted GPA Scores are:
GPA = 4.7
GPA = 4.6
GPA = 3.3
GPA = 3.2
GPA = 1.2
17
public double[] sortArrayAlgorithm(double[] array) { //sort in descending order
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length; j++) {
if (array[i] >= array[j]) {
double x = array[i];
array[i] = array[j];
array[j] = x;
}
}
}
return array;
}
Gebruik deze methode gewoon om een reeks type dubbel in aflopende volgorde te sorteren, u kunt het gebruiken om reeksen van andere typen (zoals int, float en enz.) te sorteren door het “Retourtype”, het “argument”, het “argument”, het “argument”, het “argument te wijzigen Type “en het variabele” X “-type naar het overeenkomstige type. U kunt ook “& GT; =” naar “& LT; =” in de indiensconditie wijzigen om de bestelling op te staan.
18
U kunt stroom Operaties (collections.Stream () ) met comparator. reverseorder () .
Zeg bijvoorbeeld dat u deze collectie hebt:
List<String> items = new ArrayList<>();
items.add("item01");
items.add("item02");
items.add("item03");
items.add("item04");
items.add("item04");
Om de items in hun “natuurlijke” opdracht af te drukken, kunt u de gesorteerd () methode (of laat het uit en ontvang hetzelfde resultaat):
items.stream()
.sorted()
.forEach(item -> System.out.println(item));
Of om ze in te drukken in aflopend (omgekeerde) bestelling, kunt u de gesorteerd methode die een comparator inneemt en de bestelling omdraait:
items.stream()
.sorted(Comparator.reverseOrder())
.forEach(item -> System.out.println(item));
Houd er rekening mee dat de verzameling Comparable moet hebben geïmplementeerd (net als Integer, String, enz.).
Antwoord 19
Eenvoudige methode om een int-array aflopend te sorteren:
private static int[] descendingArray(int[] array) {
Arrays.sort(array);
int[] descArray = new int[array.length];
for(int i=0; i<array.length; i++) {
descArray[i] = array[(array.length-1)-i];
}
return descArray;
}
Antwoord 20
Een andere manier met Comparator
import java.util.Arrays;
import java.util.Comparator;
...
Integer[] aInt = {6,2,3,4,1,5,7,8,9,10};
Arrays.sort(aInt, Comparator.reverseOrder() );
Antwoord 21
Het is goed dat we soms over een voorbeeld oefenen, hier is een volledig voorbeeld:
sortdesc.java
import java.util.Arrays;
import java.util.Collections;
class sortdesc{
public static void main(String[] args){
// int Array
Integer[] intArray=new Integer[]{
new Integer(15),
new Integer(9),
new Integer(16),
new Integer(2),
new Integer(30)};
// Sorting int Array in descending order
Arrays.sort(intArray,Collections.reverseOrder());
// Displaying elements of int Array
System.out.println("Int Array Elements in reverse order:");
for(int i=0;i<intArray.length;i++)
System.out.println(intArray[i]);
// String Array
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};
// Sorting String Array in descending order
Arrays.sort(stringArray,Collections.reverseOrder());
// Displaying elements of String Array
System.out.println("String Array Elements in reverse order:");
for(int i=0;i<stringArray.length;i++)
System.out.println(stringArray[i]);}}
Het compileren van het …
javac sortdec.java
Oproepen …
java sortdesc
output
Int Array Elements in reverse order:
30
16
15
9
2
String Array Elements in reverse order:
PP
OO
FF
DD
AA
Als u een alfanumerieke array wilt proberen …
//replace this line:
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};
//with this:
String[] stringArray=new String[]{"10FF","20AA","50AA"};
U krijgt de uitvoer als volgt:
50AA
20AA
10FF
22
Er is een manier die misschien een beetje langer is, maar het werkt prima. Dit is een methode om een int-array af te sorteren.
Ik hoop dat dit iemand ,,, op een dag zal helpen:
public static int[] sortArray (int[] array) {
int [] sortedArray = new int[array.length];
for (int i = 0; i < sortedArray.length; i++) {
sortedArray[i] = array[i];
}
boolean flag = true;
int temp;
while (flag) {
flag = false;
for (int i = 0; i < sortedArray.length - 1; i++) {
if(sortedArray[i] < sortedArray[i+1]) {
temp = sortedArray[i];
sortedArray[i] = sortedArray[i+1];
sortedArray[i+1] = temp;
flag = true;
}
}
}
return sortedArray;
}
Antwoord 23
Ik had de onderstaande werkende oplossing
public static int[] sortArrayDesc(int[] intArray){
Arrays.sort(intArray); //sort intArray in Asc order
int[] sortedArray = new int[intArray.length]; //this array will hold the sorted values
int indexSortedArray = 0;
for(int i=intArray.length-1 ; i >= 0 ; i--){ //insert to sortedArray in reverse order
sortedArray[indexSortedArray ++] = intArray [i];
}
return sortedArray;
}