Comment trier un tableau d'objets Person en utilisant compareto()?

Question

Voici mon code:

> import java.util.Scanner; 
    import java.util.Arrays; 

    /** 
    This class tests the Person class. 
    */ 
    public class PersonDemo 
    { 
    public static void main(String[] args) 
    { 
    int count = 0; 
    Scanner in = new Scanner(System.in); 

    boolean more = false; 
    Person first = null; 
    Person last = null; 
    while (more) 
    { 
     System.out.println(
      "Please enter the person's name or a blank line to quit"); 
     String name = in.nextLine(); 

     if (name.equals("")) 
     more = false; 
     else 
     { 
     Person p = new Person(name); //new person object created with inputted name 

     Person[] people = new Person[10]; //new array of 10 person objects 
     people[count] = p; //declare person object with index of variable count as the new person object        

     first = people[count]; // I have no idea what to do here. This is where I'm stuck. 
     last = people[count]; // I can't figure out what to do with this either. 

     first.compareTo(p); //call compareTo method on first and new person object 
     last.compareTo(p); //call compareTo method on last and new person object  

     count++; // increase count variable 
     } 
    } 

     System.out.println("First: " + first.toString()); 
     System.out.println("Last: " + last.toString()); 
    } 
    } 

Et la classe Personne:

/** 
    A person with a name. 
*/ 
public class Person implements Comparable 

{ 
/** 
    * Constructs a Person with a name. 
    * @param aName the person's name 
    */ 
public Person(String aName) 
{ 
    name = aName; 
} 

public String getName() 
{ 
    return name; 
} 

@Override 
public int compareTo(Object otherObject) 
{ 
    Person other = (Person)otherObject; 
    if (name.compareTo(other.name) < 0) return -1; 
    if (name.compareTo(other.name) > 0) return 1; 
    return 0; 
} 

/** 
     Returns a string representation of the object. 
     @return name of Person 
*/ 
public String toString() 
{ 
    return "[name=" + name + "]"; 
    } 

private String name; 

} 

Answer 1

Ce que vous manque en fait est que compareTo est une fonctionnalité que vous donnez aux objets. Dans votre exemple, vous donnez à l'instance Person la possibilité d'être comparée avec d'autres Person pour obtenir un total de la commande des éléments de cette classe.

Habituellement, cette méthode est implictly utilisé par les collections JDK comme Lists, SortedMaps et ainsi de suite, mais vous avez un tableau , qui est une sorte de type primitif, de sorte que vous devriez regarder Arrays.sort(Object[]) qui prendra soin de le commander à l'aide l'interface .

Un indice: depuis votre méthode compareTo juste travailler sur la String du Person vous pouvez facilement juste retourner sa valeur au lieu de vérifier à se comporter de la même manière.

Answer 2

Tout d'abord, obtenez votre création de tableau en dehors de la boucle. Deuxièmement, même si l'attribution des devoirs indiquait qu'ils n'engliraient que 10 noms, vous devriez en supposer plus - vous ne demandez qu'IndexOutOfBoundsExceptions. Pensez à utiliser une collection comme TreeSet qui trie automatiquement.

Pour sort an array:

Person[] people = new Person[10]; 
// add elements to the array... 
java.util.Arrays.sort(people); 
first = people[0]; 
// etc... 

Pour trier une collection (un ensemble est une collection sans doublons) il suffit d'utiliser TreeSet et ils sont triés automatiquement.

TreeSet<Person> people = new TreeSet<Person>(); // using generics to say "only Person objects are allowed" 
while (more) { 
    System.out.println("Please enter the person's name or a blank line to quit"); 
    String name = in.nextLine(); 

    if (name.equals("")) 
     more = false; 
    else 
     people.add(new Person(name)); 
} 

System.out.println("First: " + people.first()); 
System.out.println("Last: " + people.last()); 

Answer 3

Eh bien, tout d'abord, votre code ne fera pas grand-chose tant que vous n'aurez pas défini plus de vrai au début. Sinon, vous obtiendrez une exception null pointeur lorsque vous essayez d'appeler tostring sur un objet nul. De même, ne créez pas le tableau de personnes dans la boucle while, sinon il sera réinitialisé à chaque fois et annulera ce qui semble être le but de stocker toutes les personnes.

En outre, étant donné aux objets foo et bar, de la classe de zoo, vous ne pouvez pas le faire:

foo.compareto(bar); 

Ce serait comme avoir juste une ligne de code comme

-4; 

Java ne l'aime pas. Donc, pour répondre à votre question, en utilisant comparer aux méthodes, sont comme des tests de vérité de préforme. Par exemple

if(foo<bar) 
    /*Do something*/; 

Sauf, vous pouvez utiliser .compareto() afin que vos objets réellement comparaison, plutôt que de simplement les références. Ainsi, vous pouvez déterminer quel objet de type zoo est supérieur, foo ou bar, en les comparant avec compare to. L'API pour compareto stipule que si 0 est retourné, leur nombre égal, si un nombre positif est retourné, le premier est plus grand, et si un nombre négatif est retourné, le second est plus grand.Donc:

if(foo.compareto(bar) >0) 
    /* foo is greater*/; 
else if(foo.compareto(bar) = 0) 
    /* foo and bar are equal*/; 
else 
    /* bar is greater*/;