# Bit für Bit vergleichen



## PollerJava (20. Aug 2007)

Hallo,


Ich habe 2 Zahlen (16 Bit) und ich möchte jetzt diese beiden Zahlen bitweise vergleichen,

Wie kann ich das am Besten machen, gibtrs dafür eine Methode oder muss ich das mit ausmaskieren und shiften machen?

So würde ichs brauchen:


```
Zahl 1:    ...100101
Zahl 2:    ...010100

Pos 0: G für gelöscht    (Pos 0... LSB)
Pos 4: K für kommen
Pos 5: G für gelöscht
```




Danke fürs Antworten,

lg


----------



## dieta (20. Aug 2007)

Wie wär's so:

```
if ( zahl1 == zahl2 )
{
    // Tu was
}
else
{
    // Tu was anderes
}
```


----------



## PollerJava (20. Aug 2007)

dieta hat gesagt.:
			
		

> Wie wär's so:
> 
> ```
> if ( zahl1 == zahl2 )
> ...




Nö nicht brauchbar, ich muss mir jedes Bit ansehen,


----------



## nebulo (20. Aug 2007)

Kennst du java.util.BitSet ich denke damit hast du Alles was du benötigst.

Gruß nebulo


----------



## mikachu (20. Aug 2007)

oder du machsts auf die alte art und weise und speicherst die zahl als binären string und vergleichst die beiden strings miteinander...


```
String s = Integer.toBinaryString( i );
```


----------



## Wildcard (20. Aug 2007)

PollerJava hat gesagt.:
			
		

> dieta hat gesagt.:
> 
> 
> 
> ...


Warum? Wenn die Zahlen gleich sind, sind auch die Bits gleich.


----------



## SlaterB (20. Aug 2007)

ob gleich oder nicht gleich ist doch offensichtlich ohne Belang, 
zumindest noch nicht sicher von Belang 

es sieht eher nach 16 kleinen verstecken Informationen aus, 
die alle einzeln ausgelesen werden sollen


----------



## byte (20. Aug 2007)

Wenn Du zwei Zahlen bitweise vergleichen willst, musst Du jeweils das zu vergleichende Bit maskieren:


```
int mask = (int)Math.pow(2, 7);   // Bsp.: Bit 2^7 vergleichen
if((num1 & mask) == (num2 & mask)) {
   ...
}
```


----------



## PollerJava (20. Aug 2007)

SlaterB hat gesagt.:
			
		

> ob gleich oder nicht gleich ist doch offensichtlich ohne Belang,
> zumindest noch nicht sicher von Belang
> 
> es sieht eher nach 16 kleinen verstecken Informationen aus,
> die alle einzeln ausgelesen werden sollen




genau so ist es, tut mir leid, wenn ich das zu undeutlich geschrieben habe,

ich habs jetzt so verwirklicht:


```
bitSetNeu    = (ArrayList<Integer>)bs.getBits(arr1[xy]);     // Pos der Bits die neu gesetzt wurden
 bitSetAlt    = (ArrayList<Integer>)bs.getBits(wertAlt[xy]);   // alte Pos der gesetzten Bits
bitPosChange = (ArrayList<Integer>)bs.getBits(arr1[xy]^wertAlt[xy]);   //wo hat sich was geändert

Iterator<Integer> it = bitPosChange.iterator();
                    while(it.hasNext())
                        {
                         if (bitSetNeu.contains(next))                                       // ein Bit wurde neu gesetzt
                            {
                            }
                        else      // ein bit wurde gelöscht
```

lg und Danke für die Anregungen


----------



## SlaterB (20. Aug 2007)

> bitSetNeu    = (ArrayList<Integer>)bs.getBits(arr1[xy]);     

getBits scheint keine Operation einer Standard-Java-Klasse zu sein,
aber dieser Cast sieht in jedem Falle sehr über aus,

falls getBits nur eine List zurückliefert, dann verwende das Ergebnis auch nur in einer List-Variable,
warum ArrayList + Cast?
was machst du wenn irgendwan mal LinkedList zurückgegeben wird?

verwende List und du bist auf der sicheren Seite


----------



## PollerJava (20. Aug 2007)

Ja, du hast recht,

Meine Methode schaut so aus:


```
public List<Integer> getBits(int value)
        {
        bs = new BitSet();
        bits = new ArrayList<Integer>();
        for( int i = value, bitIndex = 0; i > 0; i = i >> 1, ++bitIndex )
            {
            if( i % 2 == 1 )
                {
                bs.set( bitIndex );
                bits.add(bitIndex);
                x++;
                }
            }
        bs = null;
        return bits;
        }
```

vielen Dank


----------



## bygones (20. Aug 2007)

warum arbeitest du mit BitSet und ArrayList ? 

liegt vll auch daran, dass ich die getBits nicht ganz versteh, aber warum nicht einfach alles ueber das BitSet ? 

mir erscheint die methode jedenfalls mehr als schleierhaft und obskur....


----------



## byte (20. Aug 2007)

Nichts gegen Objektorientierung, aber es gibt nicht ohne Grund schnelle Operatoren, um Bitoperationen in Java umzusetzen.


----------



## bygones (20. Aug 2007)

byto hat gesagt.:
			
		

> Nichts gegen Objektorientierung, aber es gibt nicht ohne Grund schnelle Operatoren, um Bitoperationen in Java umzusetzen.


jup...

wenns dir darum geht ob sich x veraendert hat zu y nimm ^ als test... da bekommst du sogar dann die bits die sich veraendert haben....
[/code]


----------



## PollerJava (20. Aug 2007)

diese Methode oben gibt zurück an welchen Stellen ein Bit gesetzt ist. Der Rückgabewert (die List) enthält die Positionen der 1en.


----------



## bygones (20. Aug 2007)

lauf einfach ueber die gesetzten bit im Bitset....

```
for(int i=bs.nextSetBit(0); i>=0; i=bs.nextSetBit(i+1)) { 
// operate on index i here 
}
```


----------

