In TreeSet, Sortierung & Einzigartigkeit des eigenen Objekte auf der Grundlage verschiedener Eigenschaften

Unten ist mein Schüler Klasse

class Student implements Comparable {
   String name;
   int rollNo;

   @Override
   public int compareTo(Object obj) {
        return ((Student)obj).name.compareTo(this.name);
   }
} 

Letzte änderung:, aber immer noch nicht das richtige Ergebnis

@Override
public int compareTo(Object obj) {
    Student s = (Student) obj;
    if (name.equals(s.name)) { //achieving uniqueness
        return 0;
    } else {
        if (rollNo < s.rollNo) {
            return -1;
        } else if (rollNo > s.rollNo) {
            return 1;
        } else {
            //this makes `name` the second ordering option.
            //names don't equal here
            return name.compareTo(s.name);
        }
    }
}

Wenn ich create object von TreeSet<Student> ich bin immer sortierte Liste von Student-Objekten basierend auf eindeutigen Namen & bestellt von name auch.

Aber ich brauche einzigartige student-name " in mein TreeSet<Student> mit der Bestellung von Schüler-rollNo.

Ist es möglich, mit Komparator? Kann mir keiner helfen, Jeder Vorschlag ist willkommen.
Danke.

UPDATE: hier ist das vollständige Programm:

public class Student implements Comparable {

    int rollNo;
    String name;

    Student(String n,int rno) {
        rollNo=rno;
        name=n;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {

        TreeSet<Student> ts = new TreeSet<Student>();
        ts.add(new Student("bbb",2));
        ts.add(new Student("aaa",4));
        ts.add(new Student("bbb",2));
        ts.add(new Student("ccc",3));
        ts.add(new Student("aaa",1));
        ts.add(new Student("bbb",2));
        ts.add(new Student("bbb",5));

        System.out.println(ts);

    }

    @Override
    public int compareTo(Object obj) {
        Student s = (Student) obj;
        if (name.equals(s.name)) { //achieving uniqueness
            return 0;
        } else {
            if (rollNo < s.rollNo) {
                return -1;
            } else if (rollNo > s.rollNo) {
                return 1;
            } else {
                //this makes `name` the second ordering option.
                //names don't equal here
                return name.compareTo(s.name);
            }
        }
    }

    @Override
    public String toString() {
        return name + rollNo;
    }
}

Update:2: Danke Euch allen für Eure Vorschläge, ich brauche noch einige mehr 🙂

/*
 * Actual scenario is having different properties,
 * So here I am just relating my actual scenario with Student class
 */
class Student implements Comparable {
    //sorting required on rollNo
    int rollNo;
    //Unique name is required
    String name;

    Student(String n, int rno) {
        rollNo = rno;
        name = n;
    }

    /**
     * 
     * @param args
     */
    public static void main(String[] args) {

        TreeSet<Student> tsName = new TreeSet<Student>();
        //here by default, order & uniqueness by name only
        tsName.add(new Student("ccc", 2));
        tsName.add(new Student("aaa", 4));
        tsName.add(new Student("ddd", 1));
        tsName.add(new Student("bbb", 3));
        tsName.add(new Student("ddd", 5));
        //output: aaa:4, bbb:3, ccc:2, ddd:1
        System.out.println(tsName);

        //creating new comparator for student RollNo
        TreeSet<Student> tsRollNo = new TreeSet<Student>(new Comparator<Student>() {
                    public int compare(Student stud1, Student stud2) {
                        return new Integer(stud1.rollNo).compareTo(stud2.rollNo);
                    }
                });
        tsRollNo.addAll(tsName);
        System.out.println(tsRollNo);
        //now got the desire output: ddd:1, ccc:2, bbb:3, aaa:4
    }

    public boolean equals(Object obj) {
        //internally not used to check equality while adding objects
        //in TreeSet
        System.out.println("equals() for " + this + " & " + ((Student) obj));
        return false;//return false/true doesn't make any sense here
    }

    @Override
    public int compareTo(Object obj) {
        Student s = (Student) obj;
        //internally inside TreeSet, compareTo is used to decide
        //whether two objects are equal or not,
        //i.e. compareTo will return 0 for same object(here student name)
        System.out.println("compareTo() for " + this + " & " + ((Student) obj));
        //achieving uniqueness
        return name.compareTo(s.name);
    }

    @Override
    public String toString() {
        return name + ":" + rollNo;
    }
}

AUSGABE:

compareTo() for aaa:4 & ccc:2
compareTo() for ddd:1 & ccc:2
compareTo() for bbb:3 & ccc:2
compareTo() for bbb:3 & aaa:4
compareTo() for ddd:5 & ccc:2
compareTo() for ddd:5 & ddd:1
[aaa:4, bbb:3, ccc:2, ddd:1]
[ddd:1, ccc:2, bbb:3, aaa:4]

Freunde, was auch immer ich habe durch die Verwendung von zwei Komparatoren, Ist es möglich,
das gleiche zu erreichen, während das hinzufügen der Objekte ??
Ich kann nicht Hinzufügen, Elemente & dann mit neu Komparator zum erreichen der gewünschten Reihenfolge.

Ich bin die Manipulation von tausenden von Werten, so betrachten müssen, die Leistung auch.