Mit der Vergleichbar Schnittstelle beim vergleichen von Zeichenfolgen

Ich suchte für diese Frage, aber ich fand nur einen thread, der war irgendwie verwirrend, also werde ich hier Fragen, was ich hoffe, wird eine klarere Antwort.

Habe ich eine Zuweisung zu verwenden, die Vergleichbare Schnittstelle zum Sortieren von Objekten in einem array von Kunden-Namen. Ich habe nur getan, dies mit ganzen zahlen, so weit, so ich ' m nicht sicher, wie Sie Sie vergleichen die Zeichenfolgen zusammen. Wie würde ich gehen? Hier ist, wo ich bin so weit, vorausgesetzt, ich bin zu verwenden.Namen im Vergleich zu dieser.name:

public int comparedTo(Customer a)
{

}   //end comparedTo

Ich auch brauchen, um eine Klasse zu implementieren, die das interface Comparator zum Sortieren der Werte basiert auf Kunde kauft und ich glaube, ich habe das korrekt, aber ich möchte gern sicher gehen, bevor ich rippen meine Haare aus, wenn es falsch ist. Hier ist, was ich getan habe:

class NameComparator implements Comparator{
public int compare(Object cust1, Object cust2){    

    String cust1Purch = ((Customer)cust1).purchase;        
    String cust2Purch = ((Customer)cust2).purchase;

    return cust1Purch.compareTo(cust2Purch);
}

Jede Hilfe wird sehr geschätzt!

InformationsquelleAutor Lish | 2011-03-02

Seine ganz ok, aber können Sie festlegen Komparator-generischer Typ und dann keine Notwendigkeit zu werfen Objekte:

class NameComparator implements Comparator<Customer>{
public int compare(Customer cust1, Customer cust2){    

    String cust1Purch = cust1.purchase;        
    String cust2Purch = cust2.purchase;

    return cust1Purch.compareTo(cust2Purch);
}

Geändert hat! Dank

InformationsquelleAutor Sergey Vedernikov

Hier ist ein vollständiges Beispiel, das könnte helfen:

Einen CustomerComparator:

class CustomerComparator implements Comparator<Customer> {

    @Override
    public int compare(Customer c1, Customer c2) {
        return c1.name.compareTo(c2.name);   //or, simply c1.compareTo(c2);
    }
}

Einen Comparable Customer:

class Customer implements Comparable<Customer> {

    String name;

    public Customer(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Customer o) {
        return name.compareTo(o.name);
    }

    public String toString() {
        return name;
    }
}

Einen einfachen test driver:

public class Test {
    public static void main(String[] args) {

        List<Customer> customers = Arrays.asList(new Customer("Bravo"),
                                                 new Customer("Charlie"),
                                                 new Customer("Delta"),
                                                 new Customer("Alpha"));
        Collections.sort(customers);

        //Or
        //Collections.sort(customers, new CustomerComparator());

        System.out.println(customers);

    }
}

(ideone.com demo)

Warum wäre es Sammlungen.sort()? Ich hatte den Eindruck, dass die Art genannt wurde, die über Arrays.sort().
Collections.sort sind für Listen, etc. Arrays.sort() sind für arrays. Sie können entweder eine wirklich.
Ohh, okay. Das klingt vertraut. Wahrscheinlich sollte ich erkannte, dass, aber ich bin auch konzentriert auf diese Aufgabe. Vielen Dank für die Klarstellung.
Du bist herzlich willkommen.

InformationsquelleAutor aioobe

0

Sieht gut aus. Aber Sie nutzen können, Generika:
```
class NameComparator implements Comparator<Customer> {
    public int compare(Customer cust1, Customer cust2) {..}
}
```
Also anstatt es als String cust1Purch = ((Kunde)cust1).Kauf; ich würde sagen, String cust1Purch = cust1.kaufen; ? Doppelklicken Sie einfach überprüfen.
yup. Casting überflüssig wäre.
tatsächlich, casting implizit erfolgt über Generika...
Rochon gut, ja, aber die Programmierer müssten sich dann nicht Stimmen.

InformationsquelleAutor Bozho
0

Ich scheinen, um es richtig für die Comparable - Schnittstelle. Nichts wirklich kompliziert dort.

Als für die Comparator, wenn Sie nicht mit Generika, die Sie auch bestätigen müssen beide argument für den gleichen Basistyp, zumindest Comparable da Sie die Schnittstelle :
```
if (cust1 instanceof Comparable && cust2 instanceof Comparable) {
   Comparable c1 = (Comparable) cust1;
   Comparable c2 = (Comparable) cust2;
   return c1.compareTo(c2);
} else {
   return false;
}
```
Mein problem ist, dass ich bin nicht sicher, wie Sie Sie vergleichen die Zeichenfolgen in der comparedTo () - Methode. Jeder Einblick?
wenn man sich die String - Klasse bereits implementiert, die Comparable Schnittstelle 🙂
Ich sah, dass ich einmal aufgefrischt und jemand anderes gesagt hatte. Diese Seite bewegt sich SCHNELL! 🙂

InformationsquelleAutor Yanick Rochon
0

1) ich möchte, dass Generika verwendet werden, um zu definieren, Ihre Komparator und vermeiden zusätzliche Klasse casting:
```
class NameComparator implements Comparator<Customer> {
    public int compare(Customer cust1, Customer cust2) {
      ...
    }
}
```
2) die String-Klasse in java bereits implementiert Vergleichbare Schnittstelle ( http://download.oracle.com/javase/1.5.0/docs/api/java/lang/String.html ). Also, wenn Sie brauchen, vergleichen Sie einfach auf den Namen des Kunden oder kaufen Sie string, dann kann man nur delegieren, um die Zeichenfolge und das ist, was Sie bereits tun.

Oh, okay. das macht Sinn.

InformationsquelleAutor Andrey Adamovich

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.