Comment utiliser CompareTo pour trier la carte par ordre croissant et décroissant

Question

En essayant de trier mes avions par ordre croissant et décroissant. J'ai une hashmap de plans et je veux les comparer afin que je puisse obtenir l'avion suivant et le dernier plan dû en triant la carte par timeLimitBeforeLand. J'ai écrit une méthode compareTo qui ressemble à:

//--------------------------------------------------------------------------------------- 
// CompareTo() used with the Comparable implementation. 
//--------------------------------------------------------------------------------------- 
     public int compareTo(Object arg0) 
     { 
      if((arg0 != null) && (arg0 instanceof Plane)) 
      { 
      Plane p = (Plane) arg0; 
      return (int)Math.ceil(this.timeLimitBeforeLand - p.getLimitBeforeLand()); 
      } 
      return 0; 
     } 

CompareTo prend timeLimitBeforeLand:

// --------------------------------------------------------------------------------------- 
//  Name:  getTimeLimitBeforeLand. 
//  Description: Get the time before every plane is going to land. 
//--------------------------------------------------------------------------------------- 
     public double getTimeLimitBeforeLand() 
     { 
     double fuelConsumption; 
     double timeLimitBeforeLand = 0; 

     for (TreeMap<String, Plane> theEntry : airlineMap.values()) { 
     for (Plane aPlane : theEntry.values()) { 
     if (aPlane.getPlaneType() == aPlane.getPlaneType().AIRBUS) { 
     System.out.println(" "); 
     System.out.println(aPlane); 
     fuelConsumption = 2; 
     timeLimitBeforeLand = (double) (aPlane.getFuelRemaining()/fuelConsumption); 
     System.out.println(timeLimitBeforeLand + " minutes to land."); 
     System.out.println(" "); 
     } else if (aPlane.getPlaneType() == aPlane.getPlaneType().CORPORATE) { 
     System.out.println(" "); 
     System.out.println(aPlane); 
     fuelConsumption = 3; 
     timeLimitBeforeLand = (aPlane.getFuelRemaining()/fuelConsumption); 
     System.out.println(timeLimitBeforeLand + " minutes to land."); 
     System.out.println(" "); 
     } else if (aPlane.getPlaneType() == aPlane.getPlaneType().PRIVATE) { 
     System.out.println(" "); 
     System.out.println(aPlane); 
     fuelConsumption = 4; 
     timeLimitBeforeLand = (double) (aPlane.getFuelRemaining()/fuelConsumption); 
     System.out.println(timeLimitBeforeLand + " minutes to land."); 
     System.out.println(" "); 
     } 
     } 
     } 
     return timeLimitBeforeLand; 
     } 

Ma tentative à ce jour dans le MainApp:

TreeMap<String, PlaneStore> map = new TreeMap<String, PlaneStore>(); 

     ArrayList<Plane> copyList = new ArrayList<Plane>(map.); 

     Plane comp = new Plane(); 

     Collections.sort(copyList, plane); 

Avion Classe:

//--------------------------------------------------------------------------------------- 
// Name:   Imports. 
// Description: To allow the use of different Java classes. 
//--------------------------------------------------------------------------------------- 
import java.io.Serializable; 
//--------------------------------------------------------------------------------------- 
//Name:   Class declaration. 
//--------------------------------------------------------------------------------------- 
public class Plane implements Comparable, Serializable 
{ 
//--------------------------------------------------------------------------------------- 
// Variable declarations. 
//--------------------------------------------------------------------------------------- 
    private String flightNumber; 
    public String airlineName; 
    private double fuelRemaining; 
    private int overdue; 
    private int passengerNumber; 
//--------------------------------------------------------------------------------------- 
// Enum declaration. 
//--------------------------------------------------------------------------------------- 
    private AIRPLANETYPE planeType; 
    private boolean isLanded = false; 
    public double timeLimitBeforeLand; 
//--------------------------------------------------------------------------------------- 
// Enum Constuctor. 
//--------------------------------------------------------------------------------------- 
    public enum AIRPLANETYPE 
    { 
     AIRBUS("1"), CORPORATE("2"), PRIVATE("3"); 

     private String planeName; 

     private AIRPLANETYPE(String planeName) 
     { 
      this.planeName = planeName; 
     } 

     public String getPlaneName() 
     { 
      return this.planeName; 
     } 
    } 
//--------------------------------------------------------------------------------------- 
// Constructor. 
//--------------------------------------------------------------------------------------- 
    public Plane(String flightNumber, String airlineName, 
      double fuelRemaining, int overdue, int passengerNumber, 
      AIRPLANETYPE planeType, boolean isLanded) 
    { 
     this.flightNumber = flightNumber; 
     this.airlineName = airlineName; 
     this.fuelRemaining = fuelRemaining; 
     this.passengerNumber = passengerNumber; 
     this.overdue = overdue; 
     this.planeType = planeType; 
     this.isLanded = isLanded; 
    } 
//--------------------------------------------------------------------------------------- 
// Getters and Setters. 
//--------------------------------------------------------------------------------------- 
    public String getAirlineName() 
    { 
     return airlineName; 
    } 
    public void setAirlineName(String airlineName) 
    { 
     this.airlineName = airlineName; 
    } 
    public void setOverdue(int overdue) 
    { 
     this.overdue = overdue; 
    } 
    public int getOverdue() 
    { 
     return overdue; 
    } 
    public String getFlightNumber() 
    { 
     return flightNumber; 
    } 
    public void setFlightNumber(String flightNumber) 
    { 
     this.flightNumber = flightNumber; 
    } 
    public double getFuelRemaining() 
    { 
     return fuelRemaining; 
    } 
    public void setFuelRemaining(double fuelRemaining) 
    { 
     this.fuelRemaining = fuelRemaining; 
    } 
    public int getPassengerNumber() 
    { 
     return passengerNumber; 
    } 
    public void setPassengerNumber(int passengerNumber) 
    { 
     this.passengerNumber = passengerNumber; 
    } 
    public AIRPLANETYPE getPlaneType() 
    { 
     return planeType; 
    } 
    public void setPlaneType(AIRPLANETYPE planeType) 
    { 
     this.planeType = planeType; 
    } 
    public boolean isLanded() 
    { 
     return isLanded; 
    } 
    public void setLanded(boolean isLanded) 
    { 
     this.isLanded = isLanded; 
    } 
    public double getLimitBeforeLand() 
    { 
     return timeLimitBeforeLand; 
    } 

public void setTimeLimitBeforeLand(double timeLimitBeforeLand) 
{ 
this.timeLimitBeforeLand = timeLimitBeforeLand; 
} 

//--------------------------------------------------------------------------------------- 
// CompareTo() used with the Comparable implementation. 
//--------------------------------------------------------------------------------------- 
    public int compareTo(Object arg0) 
    { 
     if((arg0 != null) && (arg0 instanceof Plane)) 
     { 
     Plane p = (Plane) arg0; 
     return (int)Math.ceil(this.timeLimitBeforeLand - p.getLimitBeforeLand()); 
     } 
     return 0; 
    } 
//--------------------------------------------------------------------------------------- 
// toString(). 
//--------------------------------------------------------------------------------------- 
    public String toString() 
    { 
     return "Plane: flightNumber=" + flightNumber + "." 
       + " airlineName=" + airlineName + "." 
       + " fuelRemaining=" + fuelRemaining + " litres." 
       + " overdue=" + overdue + " minutes." 
       + " passengerNumber="+ passengerNumber + "." 
       + " airplaneType=" + planeType + 
       "hasLanded=" + isLanded+ ".\n"; 
    } 
} 

Answer 1

La seconde a rgument dans Collections.sort est pour un Comparator pas un Plane. Depuis que je ne voyais pas mention d'un Comparator, vous devriez être en mesure d'utiliser l'ordre naturel (défini par la méthode compareTo dans votre objet d'avion) ​​et ne pas avoir un second argument dans le Collections.sort

EDIT: Sauf si vous avez juste exclu que le code, vous n'êtes pas en train de créer des instances d'avion et que vous utilisez des collections vides ici ...

TreeMap<String, PlaneStore> map = new TreeMap<String, PlaneStore>(); 
    ArrayList<Plane> copyList = new ArrayList<Plane>(map.); 

et vous serez le tri par PlaneStores de sorte que vous devez obtenir tous les Plane s dans chaque PlaneStore et ajoutez-les à votre copyList avant le tri.

Je considérerais rechercher chacun des Collections un peu plus et décider de ce que le meilleur pour votre besoin serait.