Problèmes d'implémentation de Java Comparator - Generics

Question

J'ai donc un problème dans ma classe Main lorsque je souhaite appeler la méthode mergeSort() provoquée par le comparateur. Je reçois le message suivant:

Je ne sais pas comment résoudre ce problème .. s'il vous plaît aidez-moi!

Remarque: Ne vous étonnez pas qu'il ne se passe rien dans le code. Je suis coincé parce que je ne peux pas prouver la fonctionnalité de mon code en raison du problème décrit ci-dessus :(

(Sry pour mon mauvais anglais)

class Algorithms 
{ 
    public static <T> void mergeSort(final T[] a, final Comparator<T> c) 
    { 
     T[] list = a; 
     Comparator<T> comp = c; 
    } 
} 


public class Main 
{ 
    public static void main(String[] args) 
    { 
     int[] unsortedList = {4,5,7,1,98,32}; //Expected = 1,4,5,7,32,98 

     Comparator<Integer> sorted = Comparator.naturalOrder(); 
     int[] sortedList = Algorithms.mergeSort(unsortedList,sorted)) 
    } 
} 

Answer 1

Dans ce code, les types ne correspondent pas à la Algorithms.mergeSort appel:

int[] unsortedList = {4,5,7,1,98,32}; //Expected = 1,4,5,7,32,98 

Comparator<Integer> sorted = Comparator.naturalOrder(); 
Algorithms.mergeSort(unsortedList, sorted)) 

le type de unsortedList est int[] et le type de sorted est Comparator<Integer>. Pour les types match, vous devez utiliser Integer[] comme le type de unsortedList:

Integer[] unsortedList = {4, 5, 7, 1, 98, 32}; //Expected = 1,4,5,7,32,98 

Un autre problème est que Algorithms.mergeSort retours void, donc ce ne sera toujours pas: compiler

int[] sortedList = Algorithms.mergeSort(unsortedList, sorted); 

Vous devez supprimer l'affectation:

Algorithms.mergeSort(unsortedList, sorted); 

Mettre ensemble, cela fonctionnera (après avoir implémenté Algorithms.mergeSort):

public static void main(String[] args) { 
    Integer[] unsortedList = {4, 5, 7, 1, 98, 32}; 

    Comparator<Integer> sorted = Comparator.naturalOrder(); 
    Algorithms.mergeSort(unsortedList, sorted); 
} 

Answer 2

Utilisez un Integer[] au lieu de int[].

Answer 3

Une autre possibilité serait également travailler sur un clone: ​​

class Algorithm 
{ 
    public static <T> T[] mergeSort(final T[] a, final Comparator<T> c) 
    { 
     T[] list = a.clone(); 
     Comparator<T> comp = c; 
     Arrays.sort(list, comp); 
     return list; 
    } 

    public static void main(String[] args) 
    { 
     Integer[] unsortedList = {4,5,7,1,98,32}; //Expected = 1,4,5,7,32,98 

     Comparator<Integer> sorted = Comparator.naturalOrder(); 
     Integer[] sortedList = Algorithm.mergeSort(unsortedList,sorted); 
    } 
} 

Answer 4

Si vous voulez juste des choses à compiler, vous pouvez regarder cela. Il y avait quelques problèmes:

1. Essayer d'assigner à mergeSort ne fonctionne pas parce que c'est une méthode void.
2. Actuellement, votre mergeSort ne fait rien, ce que vous savez probablement.
3. La réponse ci-dessus est correcte que vous devez utiliser des entiers.

4. Il y avait plusieurs problèmes de syntaxe, comme le manque de points-virgules et trop de parens.

   import java.util.Comparator; 
   
   class Algorithms 
   { 
       public static <T> void mergeSort(final T[] a, final Comparator<T> c) 
       { 
        T[] list = a; 
        Comparator<T> comp = c; 
       } 
   } 
   
   
   public class Main 
   { 
   
   public static void main(String[] args) 
   { 
       Integer[] unsortedList = {4,5,7,1,98,32}; //Expected = 1,4,5,7,32,98 
   
       Comparator<Integer> sorted = Comparator.naturalOrder(); 
       Algorithms.mergeSort(unsortedList,sorted); 
   } 
   }