Özel bir karşılaştırıcı kullanarak bir dizi init nasıl sıralanır?

Question

Özel bir karşılaştırıcı kullanarak bir dizi sıralamayı sıralamalıyım, ancak Java'nın kitaplığı, karşılaştırıcılarla birlikte ints için bir sıralama işlevi sağlamaz (karşılaştırıcılar yalnızca nesnelerle kullanılabilir). Bunu yapmanın kolay bir yolu var mı?

Answer 1

şu çalışacaktır:

final int[] data = new int[] { 5, 4, 2, 1, 3 }; 
final Integer[] sorted = ArrayUtils.toObject(data); 
Arrays.sort(sorted, new Comparator<Integer>() { 
    public int compare(Integer o1, Integer o2) { 
     // Intentional: Reverse order for this demo 
     return o2.compareTo(o1); 
    } 
}); 
System.arraycopy(ArrayUtils.toPrimitive(sorted), 0, data, 0, sorted.length); 

Bu kolayca int[] ve Integer[] arasında dönüştürmek için commons-lang projesinden ArrayUtils kullanır bir kopyasını oluşturur dizi, sıralama yapar ve sonra sıralanmış verileri orijinalin üzerine kopyalar.

Answer 2

Int dizisini bir Tamsayıya dönüştürerek ve ardından public static <T> void Arrays.sort(T[] a, Comparator<? super T> c)'u kullanarak (yalnızca ilk adım, yalnızca otomatik kutulama işleminin dizilerde bot çalışmasından kaynaklanıyor) gerekir. Eğer giriş dizinin türünü değiştiremiyorsanız

Answer 3

İşte bu işi yapmak için yardımcı bir yöntem.

Comparator olarak yeni bir karşılaştırıcı arayüzü gerekir her şeyden

Öncelikle primitifler desteklemez:

public interface IntComparator{ 
    public int compare(int a, int b); 
} 

(Elbette kutudan çıkarma Autoboxing/bile yaparım ama orada gitmeyecek,

public static void sort(final int[] data, final IntComparator comparator){ 
    for(int i = 0; i < data.length + 0; i++){ 
     for(int j = i; j > 0 
      && comparator.compare(data[j - 1], data[j]) > 0; j--){ 
      final int b = j - 1; 
      final int t = data[j]; 
      data[j] = data[b]; 
      data[b] = t; 
     } 
    } 
} 

Ve burada bazı istemci kod şudur: o

Sonra burada bu karşılaştırıcı kullanarak bir int dizi sıralamak için bir yardımcı yöntemdir) çirkin. (Olduğunu ne olursa olsun iyiliği için) sadece rakam '9' (yine boyutuna göre sıralı olarak) öne oluşur tüm numaraları ve sonra gerisini sıralayan bir aptal karşılaştırıcı:

final int[] data = 
    { 4343, 544, 433, 99, 44934343, 9999, 32, 999, 9, 292, 65 }; 
sort(data, new IntComparator(){ 

    @Override 
    public int compare(final int a, final int b){ 
     final boolean onlyNinesA = this.onlyNines(a); 
     final boolean onlyNinesB = this.onlyNines(b); 
     if(onlyNinesA && !onlyNinesB){ 
      return -1; 
     } 
     if(onlyNinesB && !onlyNinesA){ 
      return 1; 
     } 

     return Integer.valueOf(a).compareTo(Integer.valueOf(b)); 
    } 

    private boolean onlyNines(final int candidate){ 
     final String str = String.valueOf(candidate); 
     boolean nines = true; 
     for(int i = 0; i < str.length(); i++){ 
      if(!(str.charAt(i) == '9')){ 
       nines = false; 
       break; 
      } 
     } 
     return nines; 
    } 
}); 

System.out.println(Arrays.toString(data)); 

Çıktı:

[9, 99, 999, 9999, 32, 65, 292, 433, 544, 4343, 44934343] 

Sıralama kodu Arrays.sort(int[])'dan alındı ​​ve yalnızca küçük diziler için en iyileştirilmiş sürümü kullandım. Gerçek bir uygulama için, Arrays sınıfındaki iç yöntem sort1(int[], offset, length) kaynak koduna bakmak isteyebilirsiniz.

Answer 4

Karşılaştırıcıyı ilkel türün kendisiyle kullanmak için maksimum çaba harcadım. Sonunda karşılaştırıcıyı aldatmanın bir yolu olmadığına karar verdim. Bu benim uygulamam.

public class ArrSortComptr { 
    public static void main(String[] args) { 

     int[] array = { 3, 2, 1, 5, 8, 6 }; 
     int[] sortedArr=SortPrimitiveInt(new intComp(),array); 
     System.out.println("InPut "+ Arrays.toString(array)); 
     System.out.println("OutPut "+ Arrays.toString(sortedArr)); 

    } 
static int[] SortPrimitiveInt(Comparator<Integer> com,int ... arr) 
{ 
    Integer[] objInt=intToObject(arr); 
    Arrays.sort(objInt,com); 
    return intObjToPrimitive(objInt); 

} 
static Integer[] intToObject(int ... arr) 
{ 
    Integer[] a=new Integer[arr.length]; 
    int cnt=0; 
    for(int val:arr) 
     a[cnt++]=new Integer(val); 
    return a; 
} 
static int[] intObjToPrimitive(Integer ... arr) 
{ 
    int[] a=new int[arr.length]; 
    int cnt=0; 
    for(Integer val:arr) 
     if(val!=null) 
      a[cnt++]=val.intValue(); 
    return a; 

} 

} 
class intComp implements Comparator<Integer> 
{ 

    @Override //your comparator implementation. 
    public int compare(Integer o1, Integer o2) { 
     // TODO Auto-generated method stub 
     return o1.compareTo(o2); 
    } 

} 

@Roman: Bu aklıma gelen budur istedi beri bu iyi bir örnek olduğunu söyleyebiliriz ama olamaz. Numaraları yalnızca mutlak değerlerine göre sıralamak istediğiniz bir dizide varsayalım.

Integer d1=Math.abs(o1); 
Integer d2=Math.abs(o2); 
return d1.compareTo(d2); 

Eğer 100.It aslında o 's istiyoruz say'nın beri daha fazla örnek verebiliriz artık situations.Maybe Alexandru düşünemiyorum situation.I bağlıdır daha tek sayılar daha sıralamak istiyorum gibi başka örnek olabilir int dizisi için bir karşılaştırıcı kullanmak.

Answer 5

Akışları kullanma hakkında (Java 8)?

int[] ia = {99, 11, 7, 21, 4, 2}; 
ia = Arrays.stream(ia). 
    boxed(). 
    sorted((a, b) -> b.compareTo(a)). // sort descending 
    mapToInt(i -> i). 
    toArray(); 

Or-yerinde:

int[] ia = {99, 11, 7, 21, 4, 2}; 
System.arraycopy(
     Arrays.stream(ia). 
      boxed(). 
      sorted((a, b) -> b.compareTo(a)). // sort descending 
      mapToInt(i -> i). 
      toArray(), 
     0, 
     ia, 
     0, 
     ia.length 
    ); 

Answer 6

Eğer dizi kopyalamak istemiyorsanız (çok büyük olduğunu söylemek), içeri kullanılabilecek bir sarıcı listesi oluşturmak isteyebilirsiniz sıralama:

final int[] elements = {1, 2, 3, 4}; 
List<Integer> wrapper = new AbstractList<Integer>() { 

     @Override 
     public Integer get(int index) { 
      return elements[index]; 
     } 

     @Override 
     public int size() { 
      return elements.length; 
     } 

     @Override 
     public Integer set(int index, Integer element) { 
      int v = elements[index]; 
      elements[index] = element; 
      return v; 
     } 

    }; 

Artık özel bir karşılaştırıcı kullanarak bu sarmalayıcı Listesinde bir sıralama yapabilirsiniz.

Answer 7

Fastutil kitaplığından IntArrays.quickSort(array, comparator)'u kullanabilirsiniz.