Code de hachage d'ArrayList qui se contient comme élément

Pouvons-nous trouver le hashcoded'un listqui se contient comme element?

Je sais que c'est une mauvaise pratique, mais c'est ce que l'intervieweur a demandé.

Lorsque j'ai exécuté le code suivant, il lance un StackOverflowError:

public class Main {
    public static void main(String args[]) {
        ArrayList<ArrayList> a = new ArrayList();
        a.add(a);
        a.hashCode();
    }
}

Maintenant, ici, j'ai deux questions:

1. Pourquoi y en a-t-il StackOverflowError?
2. Est-il possible de trouver le code de hachage de cette manière?

Le code de hachage pour les Listimplémentations conformes a été spécifié dans l'interface :

Renvoie la valeur du code de hachage pour cette liste. Le code de hachage d'une liste est défini comme étant le résultat du calcul suivant:

 int hashCode = 1;
 for (E e : list)
     hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());

Cela garantit que cela list1.equals(list2)implique que list1.hashCode()==list2.hashCode()pour deux listes, list1et list2, comme l'exige le contrat général de Object.hashCode().

Cela ne nécessite pas que l'implémentation ressemble exactement à cela (voir Comment calculer le code de hachage pour un flux de la même manière que List.hashCode () pour une alternative), mais le code de hachage correct pour une liste ne contenant que lui-même serait être un nombre pour lequel x == 31 + xdoit être true, en d'autres termes, il est impossible de calculer un nombre conforme.

Découvrez l'implémentation squelettique de la hashCodeméthode en AbstractListclasse.

public int hashCode() {
    int hashCode = 1;
    for (E e : this)
        hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
    return hashCode;
}

Pour chaque élément de la liste, cela appelle hashCode. Dans votre cas, la liste a elle-même comme seul élément. Maintenant, cet appel ne se termine jamais. La méthode s'appelle récursivement et la récursivité continue de s'enrouler jusqu'à ce qu'elle rencontre le StackOverflowError. Donc, vous ne pouvez pas trouver de hashCodecette façon.

Vous avez défini une liste (pathologique) qui se contient.

Pourquoi il y en a StackOverflowError?

Selon les javadocs (c'est-à-dire la spécification), le hashcode d'un Listest défini en fonction du hashcode de chacun de ses éléments. Ça dit:

"Le code de hachage d'une liste est défini comme étant le résultat du calcul suivant:"

int hashCode = 1;
    for (E e : list)
         hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());

Donc, pour calculer le code de hachage de a, vous devez d'abord calculer le code de hachage de a. C'est infiniment récursif et conduit rapidement à un débordement de pile.

Est-il possible de trouver le code de hachage de cette manière?

Non. Si vous considérez la spécification algorithmique ci-dessus en termes mathématiques, le code de hachage d'un Listqui se contient est une fonction non calculable . Il n'est pas possible de le calculer de cette façon (en utilisant l'algorithme ci-dessus) ou de toute autre manière .

Non, la documentation a une réponse

La documentation de la structure List indique explicitement:

Remarque: Bien qu'il soit permis aux listes de se contenir en tant qu'éléments, une extrême prudence est recommandée: les méthodes equals et hashCode ne sont plus bien définies sur une telle liste.

Il n'y a pas grand-chose à dire au-delà de cela - selon la spécification Java, vous ne pourrez pas calculer hashCode pour une liste qui se contient; d'autres réponses expliquent en détail pourquoi il en est ainsi, mais le fait est qu'elle est connue et intentionnelle.

La réponse de Ravindra donne une bonne explication pour le point 1. Pour commenter la question 2:

Est-il possible de trouver le code de hachage de cette manière?

Quelque chose est circulaire ici. Au moins l'un de ces 2 doit être erroné dans le contexte de cette erreur de débordement de pile:

• que le code de hachage de la liste doit prendre en compte ceux de ses éléments
• qu'il est normal qu'une liste soit son propre élément

Maintenant, parce que nous avons affaire à un ArrayList, le premier point est fixe. En d'autres termes, vous avez peut-être besoin d'une implémentation différente pour pouvoir calculer de manière significative le code de hachage d'une liste récursive ... On pourrait étendre ArrayListet ignorer l'ajout des codes de hachage des éléments, quelque chose comme

for (E e : this)
  if(e == this) continue; //contrived rules
  hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());

ArrayListVous pourriez utiliser une telle classe au lieu de .

Avec ArrayList, le deuxième point est faux. Donc, si l'intervieweur voulait dire "Est-il possible de trouver du code de hachage de cette manière (avec une liste de tableaux)?" , alors la réponse est non, car c'est absurde.

Parce que lorsque vous appelez la même fonction avec la même fonction, cela crée une condition de récursivité qui ne se termine jamais. Et pour empêcher cette opération, JAVA reviendrajava.lang.StackOverflowError

Voici un exemple de code qui explique un scénario similaire:

public class RefTest {

    public static void main(String... strings) {
        RefTest rf = new RefTest();
        rf.message(message("test"));
    }

    public static String message2(String s){
        return message(s);
    }

    public static String message(String s){
        return message2(s);
    }

}