Créer de hachage à partir de string et int

Je me souviens de l'éclipse et l'idée d'avoir ce modèle pour créer automatiquement un objet hashCode en fonction de ses attributs.

L'une des stratégies si un nombre et une chaîne de caractères est utilisée, c'est quelque chose comme cela.

  return stringValue.hashCode() + intValue * 32;

Ooor quelque chose comme ça.

Je n'ai pas ni de l'éclipse ou de l'idée à la main et je voudrais créer une telle fonction.

MODIFIER

Sur la base des réponses, je créer ce mini-classe

    class StringInt {
        private final String s;
        private final int i;

        static StringInt valueOf( String string , int value ) {
            return new StringInt( string, value );
        }
        private StringInt( String string, int value ) {
            this.s = string;
            this.i = value;
        }
        public boolean equals( Object o ) {
            if( o != null && o instanceof StringInt ){
                StringInt other = ( StringInt ) o;
                return this.s == other.s && this.i == other.i;
            }

            return false;
        }
        public int hashCode() {
            return s != null ? s.hashCode() * 37 + i : i;
        }
    }

Cette classe est utilisé comme clé pour un grand plan de mémoire ( > 10k éléments ) je ne veux pas réitérer à chaque fois pour savoir si la Chaîne et de les int sont les mêmes.

Merci.

ps.. mmh probablement, il devrait être des noms StringIntKey.

Oscar, je pense que c'est une bonne classe. La méthode hashCode est clair, fiable et performant. Ce sur la prévention de la chaîne de valeur null? Dans votre constructeur, jeter un NPE si elle est nulle. Ensuite, vous pouvez supprimer ceux null gardes en equals et hashCode. Enfin, gardez une copie de "Effective Java" à portée de main pour des questions comme celles-ci. Les méthodes hashCode créé par Eclipse et l'IDÉE sont basées sur un livre.
Dans votre méthode equals devrait être la comparaison de la chaîne d'utilisation est égale au lieu de ==.

OriginalL'auteur OscarRyz | 2009-07-30

8

Utiliser Apache Commons HashcodeBuilder:
```
public int hashCode() {
    new HashCodeBuilder(17, 37).
           append(myString).
           append(myInt);
}
```
Lien ici:
http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/builder/HashCodeBuilder.html

Et ici:

http://www.koders.com/java/fidCE4E86F23847AE93909CE105394B668DDB0F491A.aspx

Est le HashCodeBuilder code source en ligne? ... .Je vais le regarder.
il dit: string.hashCode * 37 + intValue!! assez pour moi !! Merci

OriginalL'auteur Jon

Éclipse le fait toujours à peu près la même fonction de hachage, voici un exemple pour une classe avec une Chaîne et en tant que champs

    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + this.interger;
        result = prime * result + ((this.string == null) ? 0 : this.string.hashCode());
        return result;
    }

Ils toujours choisir des 31 comme le premier, et ensuite plusieurs par construire, dans les fonctions de hachage ou de la valeur si sa primitive. Quelque chose comme ce ne serait pas difficile de créer une méthode.

     public int hashCode(Object ... things) {
         final int prime = 31;
         int result = 1;
         for(Object thing : things) {
             result = prime * result + thing.hashCode();
         }
         return result;
     }

OriginalL'auteur Patrick Auld

2

Ou, si vous ne voulez pas d'ajouter une autre bibliothèque, faire quelque chose comme ce qui suit:
```
public int hashCode() {
    StringBuilder builder = new StringBuilder();
    builder.append(myString);
    builder.append(myInteger);
    return builder.toString().hashCode();
}
```
Doh!.. parfois je m'ennuie de ce genre de solutions !! Ouais je ne veux pas ajouter une autre bibliothèque. Merci pour les conseils
il est plus simple d'écrire juste "retour (myString + myInteger).hashCode()". Le compilateur Java compiler ce que l'équivalent de la séquence de StringBuilder.ajouter les appels.
une autre chose, si vous êtes vraiment préoccupé par la vitesse, alors cette approche est nettement plus lent que le calcul et la combinaison de composants hashcodes.
hashCode doit être rapide, il serait beaucoup mieux de prendre de la chaîne hashCode et faire un nombre entier simple opération mathématique avec l'entier.
Vitesse préoccupations sont probablement vrai, mais je n'ai jamais remarqué un ralentissement considérable de l'utilisation de cette méthode dans le code que nous écrivons. Généralement, nos problèmes de performances sont plus liés à des transferts de fonds ou les changements de l'algorithme.

OriginalL'auteur aperkins
1

Une méthode hashcode est quelque chose qui peut potentiellement être appelé plusieurs fois, et vaut donc la peine d'optimisation. Si le calcul est complexe, considérez memoizing la valeur de hachage. Aussi, évitez de faire des choses qui entraînent plus de calcul qu'il n'est nécessaire. (Par exemple, la classe StringBuilder solution passe la plupart de son temps à la création de la Chaîne temporaire.)

L'autre chose que je veux souligner est que la qualité de la table de hachage est important. Vous voulez éviter tout hashcode algorithme de cartes de beaucoup de clés communs. Si cela se produit, la table de hachage de recherche ne peut plus être en O(1). (Dans le pire des cas il sera en O(N) ... c'est à dire l'équivalent d'un linéaire de recherche!). Voici un exemple d'une mauvaise fonction de hachage:
```
int hashcode() {
    int hash = 1;
    for (int val : this.values) {
        hash = hash * value;
    }
    return hash;
}
```
Considérer ce qui se passe si un élément de this.values est zéro ...

OriginalL'auteur Stephen C
0

Suite à votre plus récente édition, si la vitesse de récupération est plus important que le stockage des préoccupations que vous pourriez pré-calculer et de stocker le code de hachage lors de la construction de votre StringInt classe. C'est sûr, comme vous l'avez marqué les String et int champs final, et aussi étant donné que String est immuable.

Aussi, vous pouvez optimiser votre equals méthode en vérifiant que l'objet en cours de comparaison == this avant de faire une comparaison. Je vous recommande aussi de faire le moins cher int basée sur la comparaison de la première avant de comparer les champs de type chaîne.

Une autre finale suggestion: Vous pouvez changer votre valueOf(String, int) méthode pour construire un StringInt ou de retour précédemment créée exemple si l'on existe déjà avec le même String et les valeurs int. Cela rend la construction plus cher, mais les comparaisons très bon marché que vous pouvez comparer StringInts à l'aide de "==" en sachant qu'aucun des deux StringInts ne sera jamais créé avec le même String et int valeur.

OriginalL'auteur Adamski
0

Vous pouvez également utiliser Objects classe de java.util.Objects paquet pour obtenir rapidement le code de hachage.
```
@Override
public int hashCode() {
    return Objects.hash(this.string, this.integerValue, this.otherDataTypes);
}
```
OriginalL'auteur Puneeth Reddy V

Vous devez vous connecter pour publier un commentaire.