Hash-Code von ArrayList, der sich selbst als Element enthält

Können wir das hashcodevon einem finden list, das sich selbst enthält als element?

Ich weiß, dass dies eine schlechte Praxis ist, aber das hat der Interviewer gefragt.

Wenn ich den folgenden Code ausgeführt habe, wird ein StackOverflowError:

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

Hier habe ich zwei Fragen:

1. Warum gibt es eine StackOverflowError?
2. Ist es möglich, den Hash-Code auf diese Weise zu finden?

Der Hash-Code für konforme ListImplementierungen wurde in der Schnittstelle angegeben :

Gibt den Hashcode-Wert für diese Liste zurück. Der Hash-Code einer Liste ist das Ergebnis der folgenden Berechnung:

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

Dies stellt sicher, list1.equals(list2)dass list1.hashCode()==list2.hashCode()für zwei beliebige Listen list1und list2, wie im Generalvertrag von vorgeschrieben Object.hashCode().

Dies erfordert nicht, dass die Implementierung genau so aussieht (siehe So berechnen Sie den Hash-Code für einen Stream auf die gleiche Weise wie List.hashCode () für eine Alternative), aber der richtige Hash-Code für eine Liste, die nur sich selbst enthält, würde dies tun eine Zahl sein, für die es sein x == 31 + xmuss true, mit anderen Worten, es ist unmöglich, eine übereinstimmende Zahl zu berechnen.

Überprüfen Sie die Skelettimplementierung der hashCodeMethode in der AbstractListKlasse.

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

Dies ruft für jedes Element in der Liste auf hashCode. In Ihrem Fall hat sich die Liste als einziges Element. Jetzt endet dieser Anruf nie. Die Methode ruft sich selbst rekursiv auf und die Rekursion wird so lange gewickelt, bis sie auf die trifft StackOverflowError. So kann man den hashCodeWeg nicht finden .

Sie haben eine (pathologische) Liste definiert, die sich selbst enthält.

Warum gibt es StackOverflowError?

Gemäß den Javadocs (dh der Spezifikation) wird der Hashcode von a Listals eine Funktion des Hashcodes jedes seiner Elemente definiert. Es sagt:

"Der Hash-Code einer Liste ist das Ergebnis der folgenden Berechnung:"

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

Um den Hashcode von zu berechnen, berechnen aSie zuerst den Hashcode von a. Das ist unendlich rekursiv und führt schnell zu einem Stapelüberlauf.

Ist es möglich, Hash-Code auf diese Weise zu finden?

Nein. Wenn Sie die obige algorithmische Spezifikation mathematisch betrachten, ist der Hashcode von a List, der sich selbst enthält, eine nicht berechenbare Funktion . Es ist nicht möglich, es auf diese Weise (unter Verwendung des obigen Algorithmus) oder auf andere Weise zu berechnen .

Nein, die Dokumentation hat eine Antwort

In der Dokumentation der Listenstruktur heißt es ausdrücklich:

Hinweis: Es ist zwar zulässig, dass sich Listen als Elemente enthalten, es ist jedoch äußerste Vorsicht geboten: Die Methoden equals und hashCode sind in einer solchen Liste nicht mehr genau definiert.

Darüber hinaus gibt es nicht viel mehr zu sagen - gemäß der Java-Spezifikation können Sie den HashCode für eine Liste, die sich selbst enthält, nicht berechnen. Andere Antworten gehen ins Detail, warum es so ist, aber der Punkt ist, dass es bekannt und beabsichtigt ist.

Ravindras Antwort gibt eine gute Erklärung für Punkt 1. Um Frage 2 zu kommentieren:

Ist es möglich, Hash-Code auf diese Weise zu finden?

Hier ist etwas kreisförmig. Mindestens eine dieser beiden muss im Zusammenhang mit diesem Stapelüberlauffehler falsch sein:

• dass der Hash-Code der Liste die seiner Elemente berücksichtigen muss
• dass es in Ordnung ist, wenn eine Liste ein eigenes Element ist

Nun, da es sich um eine handelt ArrayList, ist der erste Punkt festgelegt. Mit anderen Worten, vielleicht benötigen Sie eine andere Implementierung, um einen Hash-Code einer rekursiven Liste sinnvoll berechnen zu können ... Sie können das ArrayListHinzufügen der Hash-Codes von Elementen erweitern und überspringen, so etwas wie

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

Verwenden ArrayListSie stattdessen eine solche Klasse .

Mit ArrayListist der zweite Punkt falsch. Wenn der Interviewer also meinte: "Ist es möglich, Hash-Code auf diese Weise zu finden (mit einer Array-Liste)?" dann lautet die Antwort nein, denn das ist absurd.

Denn wenn Sie dieselbe Funktion mit derselben Funktion aufrufen, wird eine Rekursionsbedingung erstellt, die niemals endet. Und um diesen Vorgang zu verhindern, kehrt JAVA zurückjava.lang.StackOverflowError

Unten finden Sie einen Beispielcode, der ein ähnliches Szenario erklärt:

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);
    }

}