Java Array Sıralama azalan?

Bir diziyi Arrays sınıfında artan düzende nasıl sıraladıkları gibi azalan sırada sıralamanın herhangi bir KOLAY yolu var mı ?

Yoksa tembel olmayı bırakmalı mıyım ve bunu kendim mi yapmalıyım: [

Bunu her türlü Nesneyi sıralamak için kullanabilirsiniz

sort(T[] a, Comparator<? super T> c) 

Arrays.sort(a, Collections.reverseOrder());

Arrays.sort()ilkel dizileri azalan düzende sıralamak için doğrudan kullanılamaz. Arrays.sort()Tarafından tanımlanan ters Karşılaştırıcıyı geçerek yöntemi çağırmaya çalışırsanız Collections.reverseOrder(), hata atılır

sıralama için uygun bir yöntem bulunamadı (int [], karşılaştırıcı)

Bu, Integer dizisi gibi 'Array of Objects' ile iyi çalışır ancak int dizisi gibi ilkel bir diziyle çalışmaz.

İlkel bir diziyi azalan düzende sıralamanın tek yolu, önce diziyi artan düzende sıralamak ve sonra diziyi yerinde ters çevirmektir. Bu, iki boyutlu ilkel diziler için de geçerlidir.

bir liste için

Collections.sort(list, Collections.reverseOrder());

bir dizi için

Arrays.sort(array, Collections.reverseOrder());

Bunu kullanabilirsiniz:

    Arrays.sort(data, Collections.reverseOrder());

Collections.reverseOrder()Comparatorters doğal düzeni kullanarak a döndürür . Düğmesini kullanarak kendi karşılaştırıcınızın ters sürümünü alabilirsiniz Collections.reverseOrder(myComparator).

bir alternatif olabilir (sayılar için !!!)

1. Diziyi -1 ile çarpın
2. çeşit
3. -1 ile bir kez daha çarpın

Kelimenin tam anlamıyla konuşulur:

array = -Arrays.sort(-array)

açık karşılaştırıcı olmadan:

Collections.sort(list, Collections.reverseOrder());

açık karşılaştırıcı ile:

Collections.sort(list, Collections.reverseOrder(new Comparator()));

Java 8:

Arrays.sort(list, comparator.reversed());

Güncelleme: reversed()belirtilen karşılaştırıcıyı tersine çevirir. Genellikle, karşılaştırıcılar yükselen sipariş verir, bu nedenle bu sıralama azalan sırada değişir.

Eldeki diziyi org.apache.commons.lang(3)tersine çevirmenin kolay bir yolu varsa (sıraladıktan sonra) ilkel elemanlar içeren dizi için kullanmaktır:

ArrayUtils.reverse(array);

Öncelikle dizinizi aşağıdakileri kullanarak sıralamanız gerekir:

Collections.sort(Myarray);

Ardından, düzeni kullanarak artantan azalana doğru ters çevirmeniz gerekir:

Collections.reverse(Myarray);

Kullanım durumunuzun ne olduğunu bilmiyorum, ancak burada diğer cevaplara ek olarak başka bir (tembel) seçenek hala belirttiğiniz gibi artan sırada sıralamak ama bunun yerine ters sırayla yinelemek .

Bir dizi ilkel dizisini (yani, int[] arr = {1, 2, 3};) kullanarak ters sıralamak doğrudan mümkün değildir Arrays.sort()ve Collections.reverseOrder()çünkü bu yöntemler Integer, ilkel tipler (int ) .

Ancak diziyi ters sırada sıralamak için ilk önce Java 8 Stream'i kullanabiliriz:

// 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]

Başka bir çözüm, Karşılaştırılabilir arabirimi CompareTo (Object bCompared) öğesinde belirttiğiniz çıkış değerlerini değiştirebilmenizdir.

Örneğin :

public int compareTo(freq arg0) 
{
    int ret=0;
    if(this.magnitude>arg0.magnitude)
        ret= 1;
    else if (this.magnitude==arg0.magnitude)
        ret= 0;
    else if (this.magnitude<arg0.magnitude)
        ret= -1;
    return ret;
}

Nerede büyüklüğü veri türü olan bir niteliktir çift benim programda. Bu, tanımlanan sınıf frekansımı tersine sıralayarak büyüklüğüne göre sıralıyordu. Bunu düzeltmek için <ve tarafından döndürülen değerleri değiştirirsiniz >. Bu size aşağıdakileri verir:

public int compareTo(freq arg0) 
{
    int ret=0;
    if(this.magnitude>arg0.magnitude)
        ret= -1;
    else if (this.magnitude==arg0.magnitude)
        ret= 0;
    else if (this.magnitude<arg0.magnitude)
        ret= 1;
    return ret;
}

Bu karşılaştırmayı kullanmak için, Arrays.sort(mFreq)size sıralanmış diziyi verecek olanfreq [] mFreq .

Bu çözümün güzelliği (benim görüşüme göre), kullanıcı tanımlı sınıfları sıralamak ve hatta belirli bir özelliğe göre sıralamaktan daha fazla kullanılabilir. Karşılaştırılabilir bir arayüzün uygulanması size korkutucu geliyorsa, bu şekilde düşünmemenizi tavsiye ederim, aslında değil. Bu karşılaştırılabilir nasıl uygulanacağına ilişkin bağlantı benim için çok daha kolay yapılmış şeyler. Umut eden insanlar bu çözümü kullanabilirler ve sevinciniz benimkiyle bile kıyaslanabilir olacak.

array.sort(function(a, b) {return b - a;}); //descending 

veya

array.sort(function(a, b) {return a - b;}); //ascending

Bu oldukça eski bir iş parçacığı olduğunu biliyorum, ama İşte Integers ve Java 8 için güncellenmiş bir sürümü:

Arrays.sort(array, (o1, o2) -> o2 - o1);

Normal artan düzen (veya Comparator.comparingInt ()) için "o1 - o2" olduğuna dikkat edin.

Bu aynı zamanda diğer tüm Nesneler için de geçerlidir. Söyle:

Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());

Bu benim için çalıştı:

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

Çıktı:

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

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

sadece bir tür diziyi azalan düzende çift sıralamak için bu yöntemi kullanın, sadece "dönüş türü", "bağımsız değişken türü" değiştirerek diğer türlerin (int, float, vb.) dizilerini sıralamak için kullanabilirsiniz. "x" değişkenini karşılık gelen türe çevirir. siparişi artan yapmak için if durumunda "> =" değerini "<=" olarak da değiştirebilirsiniz.

Comparator.reverseOrder () ile akış işlemlerini ( Collections.stream () ) kullanabilirsiniz .

Örneğin, şu koleksiyona sahip olduğunuzu varsayalım:

List<String> items = new ArrayList<>();
items.add("item01");
items.add("item02");
items.add("item03");
items.add("item04");
items.add("item04");

Öğeleri "doğal" düzeninde yazdırmak için sort () yöntemini kullanabilirsiniz (veya dışarıda bırakıp aynı sonucu alabilirsiniz):

items.stream()
     .sorted()
     .forEach(item -> System.out.println(item));

Veya bunları azalan (tersine) sırada yazdırmak için, Karşılaştırıcıyı alan ve sıralamayı tersine çeviren sıralı yöntemi kullanabilirsiniz :

items.stream()
     .sorted(Comparator.reverseOrder())
     .forEach(item -> System.out.println(item));

Bunun, koleksiyonun Karşılaştırılabilir (Tamsayı, Dize vb.) Uygulamasını gerektirdiğini unutmayın.

Burada çok fazla karmaşa var - insanlar ilkel olmayan değerler için çözümler öneriyorlar, yerden biraz sıralama algosunu uygulamaya çalışıyorlar, ek kütüphaneleri içeren çözümler veriyorlar, bazı huysuz olanları gösteriyorlar. Orijinal sorunun cevabı 50'dir. / 50. Sadece kopyalamak / yapıştırmak isteyenler için:

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

arrOfObjectsolduğunu {6,5,4,3,2,1}şimdi. Ints dışında bir diziniz varsa - bunun yerine karşılık gelen nesneyi kullanın Integer.

Yukarıdaki tartışmalar için, ilkel dizileri azalan düzende sıralamak için kolay bir örnek.

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

Çıktı:

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

Bir int dizi azalan sıralamak için basit bir yöntem:

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

Karşılaştırıcı ile başka bir yol

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

Bazen bir örnek üzerinde pratik yapmak iyidir, işte tam bir örnek:

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

derlemek ...

javac sortdec.java

onu çağırıyor ...

java sortdesc

ÇIKTI

Int Array Elements in reverse order:
30
16
15
9
2
String Array Elements in reverse order:
PP
OO
FF
DD
AA

Alfasayısal bir dizi denemek istiyorsanız ...

//replace this line:
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};

//with this:
String[] stringArray=new String[]{"10FF","20AA","50AA"};

OUTPUT'u aşağıdaki gibi alacaksınız:

50AA
20AA
10FF

kaynak