HashMap og containsKey()

vil gætte på at du skal implementere compare metoden

Har du overskrevet hashCode funktionen?

->erikjacobsen: Nope.

Det ville nok være en god idé ;)

dvs. at du har både en object klasse samt en objekt klasse?

Under alle omstændigheder skal du også huske at overskrive hashcode:
"Note that it is generally necessary to override the hashCode  method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes."

->erikjakobsen: Det ser ud til at virke, når jeg bare overskriver hashCode()-metoden og returnerer en dummy-værdi. Smid lige et svar.

en dummy værdi?
du bruger vel ikke dette >

-----------------------
// The worst possible legal hash function - never use!
public int hashCode() { return 42; }
It's legal because it ensures that equal objects have the same hash code. It's atrocious because
it ensures that every object has the same hash code. Therefore every object hashes to the same
bucket, and hash tables degenerate to linked lists. Programs that should run in linear time run
instead in quadratic time. For large hash tables, this is the difference between working and not
working.
Effective Java: Programming Language Guide
33
A good hash function tends to produce unequal hash codes for unequal objects. This is exactly
what is meant by the third provision of the hashCode contract. Ideally, a hash function should
distribute any reasonable collection of unequal instances uniformly across all possible hash
values.
---------------------------

kontrakten du skal overholde er beskrevet her >

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html#hashCode()

lidt kode der gør det nemmere kan ses her

http://www.javapractices.com/Topic28.cjp

du plejer at gå op i performance så du burde overveje at implementere hashcode ordenligt :)

det og meget mere er beskrevet i effective java, Joshua Bloch
http://java.sun.com/docs/books/effective/

Jeg samler ikke på point, tak.

Hvis du har de 3 heltals-værdier i din klasse, og du tester dem for lighed, kan du lave en hashfunktion i retning af:    10000*a+100*b+c;    Tænk lidt over hvilke værdier de kan antage, og vælge konstanterne derefter

->simonvalter: Tak for det fine input! Jeg har faktisk Joshua Blochs bog, men jeg har ikke studeret denne del :-)

Problemet jeg løber ind i konkret, hvis jeg ikke overskriver hashCode(), er vel (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html#hashCode()):
"If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result."

Den umiddelbart nemme løsning er derfor blot at overskrive med en (den samme) dummy-værdi, men det er så måske ikke så snedigt alligevel, jf. din kommentar.

Her må man så ud i noget i retning af, hvad erikjacobsen skriver, men det kan hurtigt blive lidt kringlet, hvis det objekt, som man udfører equals() på, indeholder såvel tekst som tal, hvad sagen er i mit tilfælde.

Man kunne måske se lidt på, hvad String-klassen gør i relation til hashCode() tænker jeg..

Nu ved jeg ikke hvilken IDE du bruger men intellij har en indbygget funktion til at generere equals/hashcode så det er klaret på 5 sec. Eclipse må have det samme.. eller ihvertfald et plugin til det.

Og kan du ikke automatisk er det med strings nu meget nemt: De har selv en hashCode, og den/dem tager du bare og lægger til din egen.

her er hvad intellij gør for et test program

class ProgramNode {

private IdentifierNode idNode;
private int test;
private long test2;
private double test3;
private String bleh;
   

        public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ProgramNode)) return false;

        final ProgramNode programNode = (ProgramNode) o;

        if (test != programNode.test) return false;
        if (test2 != programNode.test2) return false;
        if (test3 != programNode.test3) return false;
        if (bleh != null ? !bleh.equals(programNode.bleh) : programNode.bleh != null) return false;
        if (idNode != null ? !idNode.equals(programNode.idNode) : programNode.idNode != null) return false;

        return true;
    }

    public int hashCode() {
        int result;
        long temp;
        result = (idNode != null ? idNode.hashCode() : 0);
        result = 29 * result + test;
        result = 29 * result + (int) (test2 ^ (test2 >>> 32));
        temp = test3 != +0.0d ? Double.doubleToLongBits(test3) : 0l;
        result = 29 * result + (int) (temp ^ (temp >>> 32));
        result = 29 * result + (bleh != null ? bleh.hashCode() : 0);
        return result;
    }

}

->simonvalter: Jeg bruger netBeans.
->erikjacobsen: Er det så nemt? Hvis et objekt indeholder to variabler a og b, hvor a er en String, og b er en integer, hvordan vil du så definere hasCode() entydigt?

hashCode skal ikke defineres entydigt. Der skal bare være en rimelig god spredning på værdierne. I dit tilfælde: hashCode fra strengen + tallet.

Og som du kan se i eksemplet fra Simon: man tager ikke hashCode på en null-streng, så du skal lige teste ;)

Tænker lige højt..

Entydigheden er nok ligegyldig her. Altså det gør ikke noget at to forskellige (mht. equals()-metoden) objekter i visse tilfælde producerer samme hashCode(), blot hashCode() er den samme, hvis objekterne ens mht. equals().

Derfor kan man bare definere x=a.hashCode()+b, idet x er den samme for samme to objekter med samme værdier for a og b. Omvendt er x ikke entydig, men det gør ikke noget.

->erikjacobsen: Ja, så er vi enige.

Her her et lille eksempel:

public class Test {
    private String string;
    private int integerOne;
    private int integerTwo;
    public Test(String string, int integerOne, int integerTwo){
        this.string = string;
        this.integerOne = integerOne;
        this.integerTwo = integerTwo;
    }
   
    public boolean equals(Object o){
        if(!(o instanceof Test)){
            throw new IllegalArgumentException("The argument must be of type Test");
        }
        Test test = (Test) o;
        //eqals køre kun på string og integerOne
        return (string.equals(test.string) && integerOne == test.integerOne);
    }
   
    public int hashCode(){
        //eftersom equals kun køre på string og integerOne køre hashcode på samme
        return new Integer(integerOne).hashCode() + string.hashCode();
    }
   
    public static void main(String... args){
        ArrayList<Test> list = new ArrayList<Test>();
        list.add(new Test("Test1",1,2));
        list.add(new Test("Test2",2,3));
        System.out.println(list.contains(new Test("Test1",1,1)));
    }
}

Håber, at du kan følge tankegangen ved bare at bruge dine attributters hashcode til at lave din egen hashcode med iht. din equals metode.

new Integer(integerOne).hashCode()  giver vist bare værdien af integerOne  -  det er overflødigt at lave et objekt bare for det ;)

Prøv selv:

System.out.println((new Integer(7)).hashCode());

jep - men bare for at illustrere at alle java's objekter implementere deres egne hashcode methode man kan bruge til at opbygge sin egen hashkode...

Men du har fuldstændig ret...

Ingen der vil have point?

;-)