compareTo() la méthode n'est pas primordial méthode par défaut lors de l'utilisation d'interface Comparable

Je suis en train de remplacer la valeur par défaut compareTo() la méthode en java, par l'écriture de mon propre et à l'aide de implémente comparable, cependant, il semble que java est encore à l'aide de la méthode par défaut.

Je suis en train de trier un tableau de Chaînes de caractères en fonction de la longueur que je l'obtenir à partir d'une .fichier dat, cependant, il continue à faire le tri par ordre alphabétique au lieu de cela. Je vous serais reconnaissant si quelqu'un pouvait me dire ce que je fais de mal que je ne peux pas comprendre pourquoi cela ne fonctionne pas.

Grâce

import static java.lang.System.*;
import java.util.Arrays;

public class Word implements Comparable
{
private String word;
private String[] array;

public Word()
{
    word = "";
}

public Word(String s)
{
    word = s;
}

public void setWord(String s)
{
    word = s;
}

public int compareTo(String rhs)
{
    String temp = (String)rhs;
    if(word.length() > temp.length())
        return 1;
    else if(word.length() < temp.length())
        return -1;

    return 0;
}

public void setSize(int size)
{
    array = new String[size];
}

public void add(int spot, String other)
{
    array[spot] = other;
}

public String[] sortByLength()
{
    Arrays.sort(array);
    return array;
}
public String toString()
{
    return Arrays.toString(array);
}
}

Ici est la classe qui contient la méthode main

import java.io.File;
import java.io.IOException;
import java.util.Scanner;
import java.util.Arrays;
import static java.lang.System.*;

public class Lab18d
{
public static void main( String args[] ) throws IOException
{
    Scanner file = new Scanner(new File("lab18d.dat"));

    int size = file.nextInt();
    file.nextLine();
    Word test = new Word();
    test.setSize(size);
    String word = "";

    for(int i = 0; i < size; i++)
    {
        word = file.next();
        test.setWord(word);
        test.add(i, word);
    }
    test.sortByLength();
    System.out.println(test);
}
}

OriginalL'auteur Special K | 2012-02-04

  1. 4

    Faites-vous une faveur: à chaque fois que vous remplacez une méthode, ajouter le @Override annotation. Cela vous donnera une erreur de compilation si vous faites une erreur dans la substitution de la méthode, qui est ce qui se passe ici. Vous sont la mise en œuvre de ce mal, comme Comparable (la "première" forme de Comparable<T> ne pas déclarer une méthode compareTo(String), il déclare une méthode compareTo(Object).

    Pour la compiler comme il est, vous devez accepter une Object au lieu d'un String ou de mettre en œuvre Comparable<String> au lieu de Comparable.

    Mais ce serait vraiment être incorrecte dans la plupart des cas, parce qu'une telle comparaison n'est pas symétrique: vous pouvez comparer un Mot d'une Chaîne de caractères, mais pas une Chaîne de caractères dans un mot.

    Plus probable que vous voulez mettre en œuvre Comparable<Word> au lieu de Comparable et accepter un Word à compareTo().

    @Override
public int compareTo(Word other)
{
    String temp = other.word;
    //...
}

    Notez bien que l' Comparable est seulement une très bonne forme quand un type est intrinsèquement commandé (ce que les médecins appellent un "ordre naturel"), comme des dates ou des nombres. Puisque vous n'êtes pas réellement en comparant les deux mots par ordre alphabétique (ce qui serait le plus proche d'une Chaîne de l'ordre naturel) c'est un meilleur candidat pour l'utilisation d'une externe comparateur de.

    //since Word.word is a private member, this either needs to be nested inside of Word
//or Word.word would need to be given an accessor method
public static class LengthComparator implements Comparator<Word> {
    @Override
    public int compare(Word word1, Word word2) {
        return Integer.valueOf(word1.word.length()).compareTo(word2.word.length());
    }
}

    OriginalL'auteur Mark Peters

  2. 2

    Comparable est tapé, mais vous êtes à l'aide de la crue de type. Essayez ceci:

    public class Word implements Comparable<Word> { //Note: typing of Comparable
    ...

    public int compareTo(Word rhs) { //Note: parameter is typed
        String temp = rhs.word;
        return word.length() - temp.length(); //Note: Simplification of code
    }
}
    Ce n'est toujours pas corrigé le fait que le sortByLength méthode est le tri d'une liste de chaînes de caractères, et non une liste de Word objets.
    J'ai fait ces changements et il compile très bien (comme avant), mais il est encore trier le tableau dans l'ordre alphabétique.

    OriginalL'auteur Bohemian

  3. 1

    Vérifier la signature de la méthode compareTo ici

    Il devrait être int compareTo(Object o)

    et vous donner public int compareTo(String rhs)

    Vous pouvez également ajouter @Override annotation à votre méthode. Il vous permettra de savoir si vous ne suivez pas la bonne signature.

    Votre lien pointe vers Java 1.4, les documents ont été écrits avant les génériques ont été ajoutés à la langue. Si vous cochez la version 6 de Java docs docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html, vous verrez que la signature correcte de la compareTo méthode dans une classe de mise en œuvre Comparable<String> est en effet public int compareTo(String rhs). Cela dit, la posté ce code met en œuvre brute Comparable plutôt que Comparable<String>, ce qui est mal vu.

    OriginalL'auteur gprathour

  4. 0

    La version courte: Vous devez utiliser le Les tableaux de.méthode de tri de prendre un Comparateur à la place.

    La version longue: La ligne

    Arrays.sort(array);

    dans le sortByLength méthode continue d'appeler le compareTo méthodes sur les objets qu'il est tri - et ces objets sont des chaînes de caractères! Au lieu de cela, vous avez besoin de la ligne de

    Arrays.sort(array, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        if (s1.length() > s2.length())
            return 1;
        if (s1.length() < s2.length())
            return -1;

        return 0;
    }
});

    ou vous pouvez créer une catégorie distincte de mise en œuvre Comparator<String> et utiliser une instance de ce que le deuxième argument de Arrays.sort.

    Woah, je suis confus sur où exactement s'inscrit dans le contexte de l'autre code dans la classe. Je suis sûr que ça ne marchera pas si j'ai mis tout le à la place de celui qui dit: les Tableaux.sort(tableau);
    Pourquoi pas? C'est un exemple d'une classe anonyme, et vous pouvez trouver un exemple d'une classe anonyme au en.wikibooks.org/wiki/Java_Programming/...
    Eh bien, j'ai essayé de copier ce que vous avez écrit à la place de la Tableaux.sort(array); et il m'a donné 43 erreurs.

    OriginalL'auteur Adam Mihalcin