werte aus hashmap auslesen

[andreas2505]

hallo,

habe eine wahrscheinlich für viele ganz einfach Frage:

Ich habe eine HashMap:

Map<Character, BitString> map = new HashMap<Character, BitString>();
        
        
        map.put(' ', new BitString(-1,-1,-1,-1,-1));
        map.put('0', new BitString(-1,-1,-1,-1,0));
        map.put('1', new BitString(-1,-1,-1,-1,1));
        map.put('2', new BitString(-1,-1,-1,0,-1));
        map.put('3', new BitString(-1,-1,-1,0,0));
        map.put('4', new BitString(-1,-1,-1,0,1));
        map.put('5', new BitString(-1,-1,-1,1,-1));
        map.put('6', new BitString(-1,-1,-1,1,0));
        map.put('7', new BitString(-1,-1,-1,1,1));
        map.put('8', new BitString(-1,-1,0,-1,-1));
        map.put('9', new BitString(-1,-1,0,-1,0));

daraus möchte ich jetzt die Werte der einzelnen BitStrings auslesen, also wieder die Zahlen zurück bekommen.

BitString[] num = new BitString[ep.laenge];
        char[] c  = new char[ep.laenge];

        for (int i=0; i<ep.laenge; i++) {
            num[i] = new BitString(numInt[i]);
            
            c[i] = (Character) alphabet.get(num[i]);
            decrypted = new String(c);
        }

Allerdings bekomme ich in der Zeile mit c = (Chrar.... immer eine NullPointerException.

Woran liegt das?

 

[Spacerat]

Du hast schlicht "Key" mit "Value" verwechselt würde ich sagen. Wenn du nach den BitStrings suchst und Charackter als Ergebnis haben möchtest müsste die HashMap umgedreht ("HashMap<BitString, Charackter>") werden.

 

[andreas2505]

Nein, ich will an einer anderen Stelle die BitStrings auslesen und an der anderen Stelle die Zahlen, also das beides geht!

 

[Marcinek]

Hallo,

ich sehe erstmal keinen Fehler im Code (den du angegeben hast).

gibt es eine Stelle an der du alphabet.put (new bit(), new Character() ) machst?

char != Character. Es gibt in Java Autoboxing, dass die entsprechenden werte zwischen ihren primitiven und den Objekten hin und her wandelt bei bedarf. Maybe geht das hier schief?

Gruß,

 

[Spacerat]

Tja, dann bleibt dir nur die Möglichkeit über das EntrySet zu iterieren.[JAVA=6]for(Entry<Character, BitString> e : ep.entrySet()) {
if(e.getValue().equals(num)) {
c = e.getKey();
break;
}
}[/code]Natürlich muss die Klasse BitString nun mit allen dazugehörigen Konformitäten "equals()" und "hashCode()" überschreiben, weil du ja immer ein neues Objekt erzeugst.
Wenn es das ist, wonach es aussieht (crypt/decrypt) wäre es natürlich angebracht, wenn man von vorneherein 2 HashMaps mit den selben Instanzen der Werte füllt und zwar eine "HashMap<Character, BitString>" und eine "HashMap<BitString, Character>".

Map<Character, BitString> crypt = new HashMap<Character, BitString>();
Map<BitString, Character> decrypt = new HashMap<BitString, Character>();

BitString bs = new BitString(-1,-1,-1,-1,-1);
Character c = ' ';
crypt.put(c, bs);
decrypt.put(bs, c);

bs = new BitString(-1,-1,-1,-1,0);
c = '0';
crypt.put(c, bs);
decrypt.put(bs, c);

//... dafür wäre eine extra Methode nicht schlecht ;)

Ganz fein wäre es natürlich, alles in einer eigenst implementierten Map unterzubringen, welche dann noch über entsprechende "crypt()" und "decrypt()" Methoden verfügt.
@Marcinek: Nein, das scheint hier eher weniger das Problem. Wenn man davon ausgeht, dass "alphabet" genau die selbe Struktur hat wie "ep", also "HashMap<Character, BitString>", wird man kaum einen Eintrag finden, wenn man nach einem BitString (im 2. Code, Zeile 7) sucht.

 

[andreas2505]

Also ich habe es jetzt mal versucht mit einer zweiten HashMap, wo die Werte halt vertauscht sind, aber da kommt genau der selbe Fehler wieder!

 

[SlaterB]

damit ein BitString in der HashMap auch wiedergefunden wird, muss hashCode() + equals() gut implementiert sein,
was hast du denn dazu in deiner Klasse? wenn gar nichts, dann ist schlicht jedes Objekt unterschiedlich, zu neuen werden alte nicht gefunden,
Java kommt noch von selber auf die Idee, irgendwelche 1en und 0en zu vergleichen




Galileo Computing :: Java ist auch eine Insel – 13.8 Assoziative Speicher
13 Datenstrukturen und Algorithmen
13.8 Assoziative Speicher
13.8.1 Die Klassen »HashMap« und »TreeMap«
13.8.3 Über die Bedeutung von »equals()«, »hashCode()«


edit:
da du, wie ich in einem anderen Thema sehe, sicher schon toString() hast,
könntest du in equals die beiden Strings zu zwei Objekten vergleichen und als hashCode den hashCode des Strings zurückgeben,
nicht performant, aber funktional,

wenn dir das nichts sagt, dann unbedingt erstmal equals() und hashCode() kennenlernen

 

[andreas2505]

also ich habe da leider noch keine equals oder hashcode methode.

Wie sehen die denn aus? Habe eine solche noch nicht implementiert? Was muss ich da bei meinem Besipiel reinschreiben?

Dazu hier mal die komplette Klasse (in diesem Fall schon mit zwei HashMaps), eine wäre mir aber lieber

public class BitString {
    
    private static final int BITS = 5;
    private int[] _bitString;
    
    public BitString() {
        setBitString(new int[BITS]);
    }
    
    /**
     * Vorsicht.
     * @param bits
     */
    public BitString(int... bits){
        setBitString(bits);
    }
    
    /**
     * @param bitString
     *            the bitString to set
     */
    public void setBitString(int... bitString) {
        if (bitString.length == BITS) {
            this._bitString = bitString;
        } else {
            // TODO
        }
    }
    
    /**
     * @return the bitString
     */
    public int[] getBitString() {
        return _bitString;
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for(int i : _bitString){
            sb.append(i);
        }
        
        return sb.toString();
    }


    public static Map createMapCrypt() {
        Map<Character, BitString> map = new HashMap<Character, BitString>();
        
        
        map.put(' ', new BitString(-1,-1,-1,-1,-1));
        map.put('0', new BitString(-1,-1,-1,-1,0));
        map.put('1', new BitString(-1,-1,-1,-1,1));
        map.put('2', new BitString(-1,-1,-1,0,-1));
        map.put('3', new BitString(-1,-1,-1,0,0));
        map.put('4', new BitString(-1,-1,-1,0,1));
        map.put('5', new BitString(-1,-1,-1,1,-1));
        map.put('6', new BitString(-1,-1,-1,1,0));
        map.put('7', new BitString(-1,-1,-1,1,1));
        map.put('8', new BitString(-1,-1,0,-1,-1));
        map.put('9', new BitString(-1,-1,0,-1,0));
        map.put('a', new BitString(-1,-1,0,-1,1));
        map.put('b', new BitString(-1,-1,0,0,-1));
        map.put('c', new BitString(-1,-1,0,0,0));
        map.put('d', new BitString(-1,-1,0,0,1));
        map.put('e', new BitString(-1,-1,0,1,-1));
        map.put('f', new BitString(-1,-1,0,1,0));
        map.put('g', new BitString(-1,-1,0,1,1));
        map.put('h', new BitString(-1,-1,1,-1,-1));
        map.put('i', new BitString(-1,-1,1,-1,0));
        map.put('j', new BitString(-1,-1,1,-1,1));
        map.put('k', new BitString(-1,-1,1,0,-1));
        map.put('l', new BitString(-1,-1,1,0,0));
        map.put('m', new BitString(-1,-1,1,0,1));
        map.put('n', new BitString(-1,-1,1,1,-1));
        map.put('o', new BitString(-1,-1,1,1,0));
        map.put('p', new BitString(-1,-1,1,1,1));
        map.put('q', new BitString(-1,0,-1,-1,-1));
        map.put('r', new BitString(-1,0,-1,-1,0));
        map.put('s', new BitString(-1,0,-1,-1,1));
        map.put('t', new BitString(-1,0,-1,0,-1));
        map.put('u', new BitString(-1,0,-1,0,0));
        map.put('v', new BitString(-1,0,-1,0,1));
        map.put('w', new BitString(-1,0,-1,1,-1));
        map.put('x', new BitString(-1,0,-1,1,0));
        map.put('y', new BitString(-1,0,-1,1,1));
        map.put('z', new BitString(-1,0,0,-1,-1));
        map.put('A', new BitString(-1,0,0,-1,0));
        map.put('B', new BitString(-1,0,0,-1,1));
        map.put('C', new BitString(-1,0,0,0,-1));
        map.put('D', new BitString(-1,0,0,0,0));
        map.put('E', new BitString(-1,0,0,0,1));
        map.put('F', new BitString(-1,0,0,1,-1));
        map.put('G', new BitString(-1,0,0,1,0));
        map.put('H', new BitString(-1,0,0,1,1));
        map.put('I', new BitString(-1,0,1,-1,-1));
        map.put('J', new BitString(-1,0,1,-1,0));
        map.put('K', new BitString(-1,0,1,-1,1));
        map.put('L', new BitString(-1,0,1,0,-1));
        map.put('M', new BitString(-1,0,1,0,0));
        map.put('N', new BitString(-1,0,1,0,1));
        map.put('O', new BitString(-1,0,1,1,-1));
        map.put('P', new BitString(-1,0,1,1,0));
        map.put('Q', new BitString(-1,0,1,1,1));
        map.put('R', new BitString(-1,1,-1,-1,-1));
        map.put('S', new BitString(-1,1,-1,-1,0));
        map.put('T', new BitString(-1,1,-1,-1,1));
        map.put('U', new BitString(-1,1,-1,0,-1));
        map.put('V', new BitString(-1,1,-1,0,0));
        map.put('W', new BitString(-1,1,-1,0,1));
        map.put('X', new BitString(-1,1,-1,1,-1));
        map.put('Y', new BitString(-1,1,-1,1,0));
        map.put('Z', new BitString(-1,1,-1,1,1));
        map.put('^', new BitString(-1,1,0,-1,-1));
        map.put('°', new BitString(-1,1,0,-1,0));
        map.put('!', new BitString(-1,1,0,-1,1));
        map.put('²', new BitString(-1,1,0,0,-1));
        map.put('§', new BitString(-1,1,0,0,0));
        map.put('³', new BitString(-1,1,0,0,1));
        map.put('$', new BitString(-1,1,0,1,-1));
        map.put('%', new BitString(-1,1,0,1,0));
        map.put('&', new BitString(-1,1,0,1,1));
        map.put('/', new BitString(-1,1,1,-1,-1));
        map.put('{', new BitString(-1,1,1,-1,0));
        map.put('(', new BitString(-1,1,1,-1,1));
        map.put('[', new BitString(-1,1,1,0,-1));
        map.put(')', new BitString(-1,1,1,0,0));
        map.put(']', new BitString(-1,1,1,0,1));
        map.put('=', new BitString(-1,1,1,1,-1));
        map.put('}', new BitString(-1,1,1,1,0));
        map.put('ß', new BitString(-1,1,1,1,1));
        map.put('?', new BitString(0,-1,-1,-1,-1));
        map.put('´', new BitString(0,-1,-1,-1,0));
        map.put('`', new BitString(0,-1,-1,-1,1));
        map.put('+', new BitString(0,-1,-1,0,-1));
        map.put('*', new BitString(0,-1,-1,0,0));
        map.put('~', new BitString(0,-1,-1,0,1));
        map.put('#', new BitString(0,-1,-1,1,-1));
        map.put('-', new BitString(0,-1,-1,1,1));
        map.put('_', new BitString(0,-1,0,-1,-1));
        map.put('.', new BitString(0,-1,0,-1,0));
        map.put(':', new BitString(0,-1,0,-1,1));
        map.put(',', new BitString(0,-1,0,0,-1));
        map.put(';', new BitString(0,-1,0,0,0));
        map.put('µ', new BitString(0,-1,0,0,1));
        map.put('<', new BitString(0,-1,0,1,-1));
        map.put('>', new BitString(0,-1,0,1,0));
        map.put('|', new BitString(0,-1,0,1,1));
       
        return map;
        
       }
       
       
       
       public static Map createMapDecrypt() {
        Map<BitString, Character> map = new HashMap<BitString, Character>();
        
        
        map.put(new BitString(-1,-1,-1,-1,-1), ' ');
        map.put(new BitString(-1,-1,-1,-1,0),'0');
        map.put(new BitString(-1,-1,-1,-1,1),'1');
        map.put(new BitString(-1,-1,-1,0,-1),'2');
        map.put(new BitString(-1,-1,-1,0,0),'3');
        map.put(new BitString(-1,-1,-1,0,1),'4');
        map.put(new BitString(-1,-1,-1,1,-1),'5');
        map.put(new BitString(-1,-1,-1,1,0),'6');
        map.put(new BitString(-1,-1,-1,1,1),'7');
        map.put(new BitString(-1,-1,0,-1,-1),'8');
        map.put(new BitString(-1,-1,0,-1,0),'9');
        map.put(new BitString(-1,-1,0,-1,1),'a');
        map.put(new BitString(-1,-1,0,0,-1),'b');
        map.put(new BitString(-1,-1,0,0,0),'c');
        map.put(new BitString(-1,-1,0,0,1),'d');
        map.put(new BitString(-1,-1,0,1,-1),'e');
        map.put(new BitString(-1,-1,0,1,0),'f');
        map.put(new BitString(-1,-1,0,1,1),'g');
        map.put(new BitString(-1,-1,1,-1,-1),'h');
        map.put(new BitString(-1,-1,1,-1,0),'i');
        map.put(new BitString(-1,-1,1,-1,1),'j');
        map.put(new BitString(-1,-1,1,0,-1),'k');
        map.put(new BitString(-1,-1,1,0,0),'l');
        map.put(new BitString(-1,-1,1,0,1),'m');
        map.put(new BitString(-1,-1,1,1,-1),'n');
        map.put(new BitString(-1,-1,1,1,0),'o');
        map.put(new BitString(-1,-1,1,1,1),'p');
        map.put(new BitString(-1,0,-1,-1,-1),'q');
        map.put(new BitString(-1,0,-1,-1,0),'r');
        map.put(new BitString(-1,0,-1,-1,1),'s');
        map.put(new BitString(-1,0,-1,0,-1),'t');
        map.put(new BitString(-1,0,-1,0,0),'u');
        map.put(new BitString(-1,0,-1,0,1),'v');
        map.put(new BitString(-1,0,-1,1,-1),'w');
        map.put(new BitString(-1,0,-1,1,0),'x');
        map.put(new BitString(-1,0,-1,1,1),'y');
        map.put(new BitString(-1,0,0,-1,-1),'z');
        map.put(new BitString(-1,0,0,-1,0),'A');
        map.put(new BitString(-1,0,0,-1,1),'B');
        map.put(new BitString(-1,0,0,0,-1),'C');
        map.put(new BitString(-1,0,0,0,0),'D');
        map.put(new BitString(-1,0,0,0,1),'E');
        map.put(new BitString(-1,0,0,1,-1),'F');
        map.put(new BitString(-1,0,0,1,0),'G');
        map.put(new BitString(-1,0,0,1,1),'H');
        map.put(new BitString(-1,0,1,-1,-1),'I');
        map.put(new BitString(-1,0,1,-1,0),'J');
        map.put(new BitString(-1,0,1,-1,1),'K');
        map.put(new BitString(-1,0,1,0,-1),'L');
        map.put(new BitString(-1,0,1,0,0),'M');
        map.put(new BitString(-1,0,1,0,1),'N');
        map.put(new BitString(-1,0,1,1,-1),'O');
        map.put(new BitString(-1,0,1,1,0),'P');
        map.put(new BitString(-1,0,1,1,1),'Q');
        map.put(new BitString(-1,1,-1,-1,-1),'R');
        map.put(new BitString(-1,1,-1,-1,0),'S');
        map.put(new BitString(-1,1,-1,-1,1),'T');
        map.put(new BitString(-1,1,-1,0,-1),'U');
        map.put(new BitString(-1,1,-1,0,0),'V');
        map.put(new BitString(-1,1,-1,0,1),'W');
        map.put(new BitString(-1,1,-1,1,-1),'X');
        map.put(new BitString(-1,1,-1,1,0),'Y');
        map.put(new BitString(-1,1,-1,1,1),'Z');
        map.put(new BitString(-1,1,0,-1,-1),'^');
        map.put(new BitString(-1,1,0,-1,0),'°');
        map.put(new BitString(-1,1,0,-1,1),'!');
        map.put(new BitString(-1,1,0,0,-1),'²');
        map.put(new BitString(-1,1,0,0,0),'§');
        map.put(new BitString(-1,1,0,0,1),'³');
        map.put(new BitString(-1,1,0,1,-1),'$');
        map.put(new BitString(-1,1,0,1,0),'%');
        map.put(new BitString(-1,1,0,1,1),'&');
        map.put(new BitString(-1,1,1,-1,-1),'/');
        map.put(new BitString(-1,1,1,-1,0),'{');
        map.put(new BitString(-1,1,1,-1,1),'(');
        map.put(new BitString(-1,1,1,0,-1),'[');
        map.put(new BitString(-1,1,1,0,0),')');
        map.put(new BitString(-1,1,1,0,1),']');
        map.put(new BitString(-1,1,1,1,-1),'=');
        map.put(new BitString(-1,1,1,1,0),'}');
        map.put(new BitString(-1,1,1,1,1),'ß');
        map.put(new BitString(0,-1,-1,-1,-1),'?');
        map.put(new BitString(0,-1,-1,-1,0),'´');
        map.put(new BitString(0,-1,-1,-1,1),'`');
        map.put(new BitString(0,-1,-1,0,-1),'+');
        map.put(new BitString(0,-1,-1,0,0),'*');
        map.put(new BitString(0,-1,-1,0,1),'~');
        map.put(new BitString(0,-1,-1,1,-1),'#');
        map.put(new BitString(0,-1,-1,1,1),'-');
        map.put(new BitString(0,-1,0,-1,-1),'_');
        map.put(new BitString(0,-1,0,-1,0),'.');
        map.put(new BitString(0,-1,0,-1,1),':');
        map.put(new BitString(0,-1,0,0,-1),',');
        map.put(new BitString(0,-1,0,0,0),';');
        map.put(new BitString(0,-1,0,0,1),'µ');
        map.put(new BitString(0,-1,0,1,-1),'<');
        map.put(new BitString(0,-1,0,1,0),'>');
        map.put(new BitString(0,-1,0,1,1),'|');
       
        return map;
        
       }
       
}

 

[SlaterB]

siehe auch edit meines letzten Postings, vor allem aber die genannten Links + überhaupt Literatur!,
und 'wie muss ich das programmieren?' brauchst du gar nicht erst fragen,
du sollst tagelang Bücher lesen und lernen, nicht alles von anderen programmieren lassen

vielleicht schreibt aber noch wer genaueres, klappt oft genug

-----

edit: statt 100 Zeilen komplizierte Zuordnung zweimal hinzuschreiben wäre es besser, Methodenaufrufe wie
insert(map1, map2, 'x', BitString(...));
zu verwenden, jedes Paar nur einmal, die Methode fügt alles in beide Maps ein

Fleiß ist nicht immer die beste Methode beim Programmieren, aber natürlich schon brauchbar

 

[andreas2505]

also ich weiß ja, dass ich in der equals einmal prüfen müsste, ob die BitStrings die gleiche Länge haben und dann noch, ob die BitStrings alle Einträge gleich haben, oder?

Aber wie schreibe ich das?

 

[SlaterB]

die Idee klingt gut, ja, um das zu beantworten

zum Code wie zu erwarten von mir persönlich keine Lösung, aber abschließend noch mal eine Gegenüberstellung:
du hantierst mit HashMaps, hunderten Zeilen Code, decrypt, encrypt und wer weiß was alles,
aber es ist dir nicht möglich, zwei einfache int-Arrays zu vergleichen?

public class Test {
    public static void main(String[] args) {
        int[] a = {4,5,6,7};
        int[] b = {4,5,7,7};
        // a ähnelt b oder nicht? von Programm errechnen lassen, nicht mit Kopf beantworten
    }
}

hmm..
Kapitel 13 im Lehrbuch kommt dann objektiv betrachtet wohl paar Wochen bis Monate zu früh,
Galileo Computing :: Java ist auch eine Insel – 3.7 Arrays

'arrays vergleichen' kann man übrigens auch in Suchmaschinen eintippen..

 

[andreas2505]

ja das Problem ist nicht die zwei int[] zu vergleichen:

if (a.length != b.length) {
    return false;
}
for (int i=0; i<a.length; i++) {
    if (a[i] != b[i]) {
        return false;
   }
else return true;

das Problem ist jetzt wie ich das in die equals reinpacke.

public boolean equals(BitString s) {
    erstes Problem, wie heißen jetzt hier die beiden int[]?
}

und muss ich dann noch was in die equals reinpacken?

 

[SlaterB]

die int[]s sind Attribute von BitString, mit getBitString() abzufragen, eins ist das eigene Objekt, das andere der Parameter s,
diese Frage war bisschen berechtigter als die vorherige, aber auch wieder eigentlich nur ein winziger normal-einfacher Schritt,
mit ein bisschen überlegen und nachschlagen, was eine equals-Methode normalerweise so macht (Beispiele!), hättest du das sehr gut selber beantworten können

das hier zu fragen ist natürlich genauso berechtigt, aber mein persönliches Kontingent an Antworten ist damit leichtfertig aufgebraucht
viel Erfolg weiterhin

 

[andreas2505]

dann müsste es ja so jetzt stimmen oder?

public boolean equals(BitString s) {
           int[] a = s.getBitString();
           int[] b = this.getBitString();
           if (a.length != b.length) {
               return false;
           }
           for (int i=0; i<a.length; i++) {
                if (a[i] != b[i]) {
                    return false;
                }
           }
           return true;
        }

aber bei der hashCode weiß ich echt nicht wie ich die machen soll. Was muss denn da rein?

 

[Spacerat]

@SlaterB: Also den HashCode über "toString().hashCode();" zu errechnen fand ich auch einst eine Superidee... im nächsten Debug wurde diese allerdings von der Mutter aller Klassen (Object) wie folgt zu Nichte gemacht...

// Klasse Object Auszug
    public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

Das ganze funktioniert also nur, wenn "toString()" ebenfalls überschrieben wird und in der überschriebenen Methode keinesfalls "hashCode()" verwendet wird.

 

[maki]

dann müsste es ja so jetzt stimmen oder?

Daran stimmt nichtmal die Signatur der Methode.
public boolean equals(Object o)

Bitte nochmals die Literatur dazu konsultieren: Object (Java Platform SE 6)

Alle Attribute die equals heranzieht um Gleichheit zu definieren sollten auch von der hashcode Methode herangezogen werden.

hashcode & equals kann man übrigens auch per IDE generieren lassen, bei Eclipse im "Source" Kontextmenü zu finden.

 

[SlaterB]

HashCode über "toString().hashCode();" [..] Das ganze funktioniert also nur, wenn "toString()" ebenfalls überschrieben wird

was ich ja für BitString auch vorher in einem älteren Thread bestätigt hatte bzw. nun hier nachzulesen ist,

wenn man nicht weiß was toString() zurückliefert, dann würde ich toString().hashCode() gegenüber dem direkten hashCode() nicht gleich für eine 'Superidee' bzw. überhaupt eine Verbesserung halten

 

[andreas2505]

ok dann hoffe ich, dass es so jetzt richtig ist:

public boolean equals(Object o) {
           if (!(o instanceof BitString)) {
               return false;
            }
           
           BitString s = (BitString) o;
           int[] a = s.getBitString();
           int[] b = this.getBitString();
           if (a.length != b.length) {
               return false;
           }
           for (int i=0; i<a.length; i++) {
                if (a[i] != b[i]) {
                    return false;
                }
           }
           return true;
        }

Kann mir mal jemand konkret Vorschläge zum hashCode machen

Also ich habe jetzt die hashcode ganz einfach so gemacht

public int hashCode(){
            return 1;
        }

Funktioniert auch soweit ist aber garantiert nicht so sinnvoll. Wäre trotzdem schön wenn noch wer eine sinnvolle Hashcode() für mich hätte

 

[Andi_CH]

Rechne aus dem Bitmuster einen Wert aus.

so frei nach dem Motto :

wert += i * 2^BitString[i];

Dass das Pseudocode ist, muss ich ja hoffentlich nicht betonen.