Erreur de compilation Collections.sort - types incompatibles

Question

J'ai développé une implémentation de l'algorithme de voisinage en Java pour un projet de physique sur lequel je travaille. Je suis tout nouveau à Java alors je m'excuse pour toute idiotie qui en résulte.

Je reçois l'erreur « »

incompatible types 
found : void 
required: java.util.List<VoronoiPoint> 

« » sur la ligne 22 du compilateur Java pour tenter de compiler le programme ci-dessous. Je n'arrive pas à comprendre pourquoi la variable '' thelist '' se transforme en quelque sorte en un vide lorsque je l'ai déclaré de type List<VoronoiPoint>. Si quelqu'un peut m'expliquer ce qui se passe, ce serait très apprécié!

import java.lang.Double; 
import java.util.*; 


public class VoronoiTiling 
{ 


    public static void main(String args[]) 
    { 
    Integer n = 10; //Number of dimensions of model parameter space 
    Integer ns = 20; //Number of points per iteration 
    Integer nr = 4; //Number of cells to populate 
    Integer iterations = 5; //Number of iterations 
    List<VoronoiPoint> thelist = VoronoiList.startlist(ns,n); 
    //System.out.println(thelist); 
    //System.out.println(thelist.get(1).misfit); 
    for (Integer i=0 ; i<thelist.size() ; i++) 
    { 
     thelist.get(i).setmisfit(); 
    } 
    List<VoronoiPoint> orderedlist = Collections.sort(thelist); 
    Double distance = EuclidianDistance((thelist.get(1)).location,(thelist.get(2)).location); 
    System.out.println(distance); 
    } 

    public static Double EuclidianDistance(Double[] point1, Double[] point2) 
    { 
    Double distance=0.0; 
    for (int i = 0; i < point1.length; i++) 
    { 
     distance = distance + Math.pow((point1[i]-point2[i]),2); 
    } 
    return Math.sqrt(distance); 
    } 
} 

Les autres classes I utilisés sont ici: La classe VoronoiList:

import java.util.*; 

public class VoronoiList 
{ 
    public static List<VoronoiPoint> startlist(Integer ns, Integer n) 
    { 
    List<VoronoiPoint> thestartlist = new ArrayList<VoronoiPoint>(); 
    for (int i = 0; i < ns; i++) 
    { 
     thestartlist.add(new VoronoiPoint(0.,n)); 
    } 
    return thestartlist; 
    } 
} 

La classe VoronoiPoint:

import java.util.Random; 

public class VoronoiPoint implements Comparable<VoronoiPoint> 
{ 
    Double[] location; 
    private Random generator = new Random(); 
    Double misfit = -1.; 

    //*************************************************************** 
    public VoronoiPoint(Double misfit, Integer n) 
    { 
    location = new Double[n]; 
    ParameterBoundaries boundaries = new ParameterBoundaries(n); 
    for(int i = 0; i < n; i++) 
    { 
     location[i] = boundaries.getboundaries(2*i)+2*generator.nextDouble(); 
    } 
    } 
    //*************************************************************** 
    //public Double[] getlocation() 
    //{ 
    //return location; 
    //} 
    public void setlocationi(Integer i, Double j) 
    { 
    location[i] = j; 
    } 

    //*************************************************************** 

    public void setmisfit() 
    { 
    Integer n = location.length; 
    Double tempmisfit = 0.0; 
    for(Integer i = 0; i < n; i++) 
    { 
     tempmisfit = tempmisfit + Math.pow((location[i]),2); 
    } 
    misfit = Math.sqrt(tempmisfit); // Temporarily just distance to centre 
    } 

    //public Double getmisfit() 
    //{ 
    //return misfit; 
    //} 
    public int compareTo(VoronoiPoint b) 
    { 
    if (this.misfit<b.misfit) return -1; 
    else if (this.misfit==b.misfit) return 0; 
    return 1; 
    } 
} 

Et la classe limites des paramètres:

public class ParameterBoundaries 
{ 
    private Double[] boundaries; /*Set to 2n where n is dimensions of parameter space, 
    * it just makes it easier*/ 
    public ParameterBoundaries(Integer n) 
    { 
    boundaries = new Double[2*n]; 
    for(Integer i = 0; i<n; i++) 
    { 
     boundaries[2*i] = -1.0; 
     boundaries[2*i+1] = 1.0; 
    } 
    } 
    public Double getboundaries(Integer i) 
    { 
    return boundaries[i]; 
    } 
} 

Answer 1

Collections.sort(..) trie la liste d'origine. Il ne retourne pas une nouvelle liste. (Son type de retour est void)

Answer 2

Votre code est erroné. Collections.sort() est une fonction de tri sur place; il modifie l'argument de liste donné et ne renvoie rien (void).