Vergleichen von Objekteigenschaften in Java mit Vergleichen

Question

Ich arbeite an meiner DS/A Hausaufgabe, und ich kann nicht für das Leben von mir herausfinden, wie die Comparable/Comparator-Schnittstellen eine bestimmte Eigenschaft meines Objekts als Schlüssel markieren vergleichen und bestellen nach. Wir verwenden eine Mergesort Funktion, die uns zur Verfügung gestellt hat, und ich glaube, ich habe meistens alles andere bekam in dem Programm arbeiten, anders als dieser Fehler Ich erhalte:

 incompatible types: Student[] cannot be converted to Comparable[] 

ich sehr einen kleinen Einblick schätzen würde in Dieses Problem, da ich noch ziemlich neu in Java und OOP bin. Hier ist, was ich habe:

TestMergeSort.java:

public class TestMergeSort { 

public static void main(String[] args) { 
    Student[] students = initializeStudentsArray(); 

    System.out.println("Displaying students array before sorting..."); 
    display(students); 

    System.out.println("Being sorting..."); 
    /* 
    * The Student array will be sorted by studentId 
    * which is declared as a String 
    */ 
    Merge.sort(students); // TODO: Fix the Student class to eliminate this error 
    System.out.println("End sorting..."); 

    System.out.println("Displaying students array after sorting..."); 
    display(students); 
} 

private static Student[] initializeStudentsArray() { 

    Student[] students = new Student[5]; 
    students[0] = new Student("Joe", "Jones", "1001"); 
    students[1] = new Student("Adam", "Ant", "950"); 
    students[2] = new Student("Bill", "Barnes", "735"); 
    students[3] = new Student("Mark", "Roth", "1102"); 
    students[4] = new Student("Jerome", "Howard", "1150"); 
    return students; 

} 

private static void display(Student[] students) { 
    for (Student std : students) { 
     System.out.println("Students [firstName=" + std.firstName + ", lastName=" + std.lastName + ", studentId=" + std.studentId + "]"); 
    } 
} 

}

und Student.java:

public class Student implements Comparator<Student> { 

    public String firstName; 
    public String lastName; 
    public String studentId; 

    public Student(String first, String last, String Id) { 

     this.firstName = first; 
     this.lastName = last; 
     this.studentId = Id; 
    } 

    @Override 
    public int compare(Student stud1, Student stud2) { 

     String student1 = stud1.studentId; 
     String student2 = stud2.studentId; 

     return student1.compareTo(student2); 
    } 
} 

Ich bin wahrscheinlich etwas schrecklich falsch zu machen, so wenden Sie sich bitte klicke mich an. Vielen Dank für deine Zeit!

Answer 1

Merge.sort(students); 

Ich weiß nicht, was die Merge-Klasse ist. Ich benutze einfach den Standard Collections.sort (...).

public class Student implements Comparator<Student> { 

Unter der Annahme, es funktioniert auf die gleiche Weise wie der Standard Collections.sort, ich habe immer Comparable umgesetzt, nicht Vergleicher.

Hier ist ein Beispiel dafür, wie Comparable implementieren (Vergleicher nicht) für die Klasse und wie benutzerdefinierte Comparators erstellen:

/* 
** Use the Collections API to sort a List for you. 
** 
** When your class has a "natural" sort order you can implement 
** the Comparable interface. 
** 
** You can use an alternate sort order when you implement 
** a Comparator for your class. 
*/ 
import java.util.*; 

public class Person implements Comparable<Person> 
{ 
    String name; 
    int age; 

    public Person(String name, int age) 
    { 
     this.name = name; 
     this.age = age; 
    } 

    public String getName() 
    { 
     return name; 
    } 

    public int getAge() 
    { 
     return age; 
    } 

    public String toString() 
    { 
     return name + " : " + age; 
    } 

    /* 
    ** Implement the natural order for this class 
    */ 
    public int compareTo(Person p) 
    { 
     return getName().compareTo(p.getName()); 
    } 

    static class AgeComparator implements Comparator<Person> 
    { 
     public int compare(Person p1, Person p2) 
     { 
      return p1.getAge() - p2.getAge(); 
     } 
    } 

    public static void main(String[] args) 
    { 
     List<Person> people = new ArrayList<Person>(); 
     people.add(new Person("Homer", 38)); 
     people.add(new Person("Marge", 35)); 
     people.add(new Person("Bart", 15)); 
     people.add(new Person("Lisa", 13)); 

     // Sort by natural order 

     Collections.sort(people); 
     System.out.println("Sort by Natural order"); 
     System.out.println("\t" + people); 

     // Sort by reverse natural order 

     Collections.sort(people, Collections.reverseOrder()); 
     System.out.println("Sort by reverse natural order"); 
     System.out.println("\t" + people); 

     // Use a Comparator to sort by age 

     Collections.sort(people, new Person.AgeComparator()); 
     System.out.println("Sort using Age Comparator"); 
     System.out.println("\t" + people); 

     // Use a Comparator to sort by descending age 

     Collections.sort(people, Collections.reverseOrder(new Person.AgeComparator())); 
     System.out.println("Sort using Reverse Age Comparator"); 
     System.out.println("\t" + people); 

     // Use a Comparator with lambda expression to sort by age 

//  Collections.sort(people, (o1, o2) -> o1.getAge() - o2.getAge()); 
//  Collections.sort(people, Comparator.comparingInt(p -> p.getAge())); 
     Collections.sort(people, Comparator.comparingInt(Person::getAge)); 
     System.out.println("Sort using Lambda Age Comparator"); 
     System.out.println("\t" + people); 
    } 
}