# byte-array bitweise auslesen



## Schu (2. Aug 2005)

Hi !!

ALso...ich habe schon sämtliche Threads zum Thema byte-array durchgeforstet, aber für mein Problem war leider noch nicht das richtige dabei 

Es geht um folgendes:

Ich möchte ein byte-array (welches double-Werte enthält) der Länge x bitweise auslesen...d.h. die Zahlenwerte innerhalb dieses arrays können unterschiedlich lang sein, z.b. ist der 1.Zahlenwert in den ersten 7 bits gespeichert, der nächste in den nächsten 9 usw. !!
Deshalb komme ich mit der üblichen Herangehensweise (also immer byte-weise shiften) nicht weiter und suche einen Ansatz für mein Problem !!

Vielleicht kann mit ja jemand einen Denkanstoss geben ?? ???:L  

Thanx a lot...Schu !!


----------



## Bleiglanz (2. Aug 2005)

Anonymous hat gesagt.:
			
		

> Hi !!
> Ich möchte ein byte-array (welches double-Werte enthält) der Länge x bitweise auslesen...d.h. die Zahlenwerte innerhalb dieses arrays können unterschiedlich lang sein, z.b. ist der 1.Zahlenwert in den ersten 7 bits gespeichert, der nächste in den nächsten 9 usw. !!


hä?

wie willst du denn die "trennung" erreichen, woher weisst du dass erst 7 bits, dann 9 bits usw. sind?


----------



## Guest (3. Aug 2005)

Also dieses Wissen habe ich....ich habe ein byte-array, in dem semantische Informationen zu den Daten stehen, wie Einheit und auch Datenbreite (in Bits), die die datenwerte für ihre "Darstellung" benötigen...daher weiß ich, wieviel Bits ich gerade für den Datenwert auslesen muss...

Hast du vlt. ne Idee, wie ich das am dümmsten bewerkstellige... :?  ???:L 

grüße
schu


----------



## Schu (3. Aug 2005)

Uuupps...die obige Antwort war von mir...hatte meinen Namen vergessen anzugeben..sorry !!


----------



## anfänger (3. Aug 2005)

vielleicht helfen dir ja shift-operationen weiter:

Bsp:    0011 << 2 == 1100
          0111 >> 3 == 0011

die Verschiebung des Bitmusters funktioniert auch um nur eine Stelle nach rechts bzw links


----------



## thE_29 (3. Aug 2005)

Hier hast du ein Beispiel wie man es auslesen kann:



```
byte b[] = new byte[2];
    b[0] = 3;
    b[1] = 8;
    byte tmp_clone[] = b.clone();
    for(int x = 0; x != tmp_clone.length; x++)
    {
      System.out.println((x + 1) + "tes Element aus dem Array::");
      for(int y = 0; y != 8; y++) //  8 stellen hat ein Byte 
      {
        System.out.println("  Bit an der " + (y + 1) + " Stelle (entspricht " + (int)java.lang.Math.pow(2,y)  + ") ist: " + (tmp_clone[x] & 1));
        tmp_clone[x] >>= 1;
      }
      System.out.println(); //Zeilenvorschub
    }
```

Ausgabe:



> 1tes Element aus dem Array::
> 
> Bit an der 1 Stelle (entspricht 1) ist: 1
> 
> ...




Logik: wenn man einen Wert mit logisch 1 verknüpft (sprich 1ter bit) und es ergibt 1, dann war es vorher auch 1!

Ergibt es 0, dann war des 0!

Danach wird in jedem loop der Schleife, die Zahl um 1 Stelle (1 bit) nach rechts verschoben, sodaß man alle Stellen durchgeht!

Wenn man weiß wie es geht, isses ziemlich leicht 

Und in C konnte man sogar bitweise daraufzugreifen, bzw vereinbaren... das war halt manchmal schon ein Vorteil


----------



## Schu (3. Aug 2005)

Ja das hatte ich auch gedacht und daraufhin folgenden Code "entwickelt":


```
for (int i=0; i<description.getDescriptorsSize(); i++) {
            
            TableContents content = (TableContents) description.getDescriptors().get(i);
            DataItem item = new DataItem();
            
            item.tableBContent = content;
            item.dataValue = (reservedData[i] << content.dataWidth);
            
            realData.add(item);
                        
         }
```

die Schleife zählt also von 0 los und holt sich für jeden Durchlauf aus einer ArrayList nen Eintrag, der quasi auf das byte-array reservedData "pointed", wo ich auslesen will...die dataWidth bestimmt dabei, wieviel bits er auslesen soll....da geht's aber schon los...was, wenn die dataWidth >8 (also größer als ein Byte) oder <8 ist....ich müsste mir also (so meine Überlegung), einen globalen Counter basteln, der immer den absoluten Abstand (in Bits) vom ANfang von reservedData beinhaltet (indem ich bei jedem Durchlauf die dataWidth hinzuaddiere)....aber weiß er dann auch, dass die Stelle, die ich ihm anweise, als 2^0=1 zu deuten ist ???

hoffe, es wird ein bissl durchsichtiger   :bahnhof: 

grüße
Schu


----------



## Bleiglanz (3. Aug 2005)

leg das ganze in ein BitSet ein 

dann kannst du später mit

BitSet#get(int fromIndex, int toIndex) 

die richtigen Bereiche einfach "abgreifen"


----------



## Gast (3. Aug 2005)

Jo, Danke...war auch grad dabei, mich über dei Geschichte zu belesen (in "Java ist auch nur eine Insel")..aber nu bin ich mir da sicher....


----------



## Schu (4. Aug 2005)

So...hab mir da jetzt ne Methode gebastelt, die aus nem Byte-Array ein bitset macht...vlt. kann ja mal einer drüberschauen (Bleiglanz ??  :wink: )...die ANzahl der Bits stimmt..nur bei den WErten bin ich eher skeptisch, da ich Sie nicht mit REferenzwerten, die ich habe übereinstimmen... ???:L 

So...hier der Code:

```
public static BitSet toBitArray(byte[] arr){

      int counter = 0;
      BitSet value = new BitSet(arr.length*8);
      byte tmp_clone[] = (byte[]) arr.clone();
      // Schleife über das gesamte Byte-array
      for(int x = 0; x < tmp_clone.length; x++)
      {
        // Schleife über alle 8 Bits innerhalb eines Bytes (im Byte-array)
        for(int y = 0; y < 8; y++) //  8 stellen hat ein Byte
        {

           if ((tmp_clone[x] & 1) == 1) {
              value.set(counter+y);
           }
           else {
              value.clear(counter+y);
           }
          // shift innerhalb des bytes um 1 nach rechts
          tmp_clone[x] >>= 1;
        }
        
        counter += 8;
      }
      return value;
   }
```

Wäre euch für hilfreiche Kommentare dankbar...

grüße
Schu


----------



## Bleiglanz (4. Aug 2005)

hab mal den loop unrolled, du musst natürlich das höchste bit an die erste stelle setzen, also innen umgekehrt zählen

(wenn den bitset den "hingeschriebenen" 0-1-strom ergeben soll)


```
byte[] b = new byte[]{(byte)255,(byte)0,(byte)15};
        java.util.BitSet bs = new java.util.BitSet(b.length*8);
        for(int i=0;i<b.length;i++){
            bs.set(i*8+0,(b[i]&128)==128);
            bs.set(i*8+1,(b[i]&64)==64);
            bs.set(i*8+2,(b[i]&32)==32);
            bs.set(i*8+3,(b[i]&16)==16);
            bs.set(i*8+4,(b[i]&8)==8);
            bs.set(i*8+5,(b[i]&4)==4);
            bs.set(i*8+6,(b[i]&2)==2);
            bs.set(i*8+7,(b[i]&1)==1);
        }
```


----------



## Guest (4. Aug 2005)

Hmmmm...die WErte sind zwar jetzt andere, aber immer noch nicht korrekt (bzgl. der Referenzwerte)...vielleicht liegt das aber auch an der Methode, mittels derer ich aus einer bestimmten Anzahl von Bits einen double-WErt bilde ??

Die sieht so aus...vlt. könntest du ja nochmal kurz "debuggen"    :? 


```
public static double bitToInteger(BitSet arr, int start, int len) {
      double res = 0;
      
      for (int j=start, k=0; j<len+start;j++, k++) {
         
         if (arr.get(j) == true) {
            res += pow(2,k);
         }
         else {
            
         }
      }
      
      return res;
   }
```

Sie nimm sich halt aus dem vorher erzeugten und als Parameter übergebenem Bit-Array ein Teil heraus (von start bis start+len)...diesen soll sie jedes mal wie ein neues Bit-Array behandeln, d.h. das erste Bit bedeutet 2^0, das zweite 2^1 (sofern Sie denn gesetzt sind) bis hin zum letzten....habbisch hier auch wieder nen Denkfehler drin (was mich nich wundern würde) ??

Thanx a lot...Schu


----------



## Schu (4. Aug 2005)

obiger Beitrag war wieder mal von mir, wobei ich meinen Namen vergessen habe *sich vorn Kopf haut*


----------



## Bleiglanz (4. Aug 2005)

keine ahnung

wenn du aus

10101010111101010100101010110

was abgreifst, ist doch wahrscheinlich wieder die umgekehrte reihenfolge richtig (hängt eben davon ab wies reingeschrieben wird)

also das erste bit = 2^länge-1 usw.

was solln das mit den doubles?

wie wurden denn doubles zu einer bitfolge verwandelt?


----------



## Schu (4. Aug 2005)

Haaaaaaaaa...Tausend DAnk !! DAs war's..einmal anders herum ausgewertet und es passt !!!

Bis demnächst 

many, many THANX...Schu


----------

