# Unklarheit bei Umwandlung von byte zu int



## Dethix (10. Jan 2011)

Hallo Zusammen,

ich schreibe gerade ein Java Programm, in dem ein AudioInputStream grafisch dargestellt werden soll.
Nun habe ich in einer JavaSoundDemo von Sun ein passendes Beispiel gefunden. Es funktioniert auch soweit alles, nur habe ich noch etwas Verständnisschwierigkeiten was den Code angeht. Vielleicht könnt ihr mir da auf die Sprünge helfen.


```
int[] audioData = null;
        if (format.getSampleSizeInBits() == 16) 
        {
             int nlengthInSamples = audioBytes.length / 2; 
             audioData = new int[nlengthInSamples];
             
             if (format.isBigEndian()) 
             {
                for (int i = 0; i < nlengthInSamples; i++) 
                {
                     /* First byte is MSB (high order) */
                     int MSB = (int) audioBytes[2*i];
                     /* Second byte is LSB (low order) */
                     int LSB = (int) audioBytes[2*i+1];
                     audioData[i] = MSB << 8 | (255 & LSB);
                 }
             } 
            else 
             {
                 for (int i = 0; i < nlengthInSamples; i++) 
                 {
                     /* First byte is LSB (low order) */
                     int LSB = (int) audioBytes[2*i];
                     /* Second byte is MSB (high order) */
                     int MSB = (int) audioBytes[2*i+1];
                     audioData[i] = MSB << 8 | (255 & LSB);
                 }
             }
```

16Bit = 2Byte ist mir klar, und somit kann ich auch nlengthInSamples nachvollziehen. Wie ich zu LSB und MSB komme auch. Aber mit der nächsten Zeile komme ich nicht ganz klar:


```
audioData[i] = MSB << 8 | (255 & LSB);
```

Da wird ein Bitshift nach links um 8 stellen gemacht und dann? Und vor allem warum? Vielleicht könnt ihr mir mit einem kleinen Beispiel die Unklarheiten beseitigen.

Gruß
Dethix


----------



## tagedieb (10. Jan 2011)

Du hast 2 Bytes.

z.B.

```
1. Byte = 00010011  =  19
2. Byte = 00000101  =   5
```
Um daraus nun einen Int zu kriegen musst du nun die Bits des 1. Byte um 8 Stellen nach links verschieben.


```
1. Byte = 00010011 00000000  = 4864
2. Byte = 00000000 00000101  =    5
-------------------------------------
Int     = 00010011 00000101  = 4869
```

Der 
	
	
	
	





```
|
```
 Operator funktioniert in dieser Situation gleich wie eine Addition, ist aber schneller.


----------



## Dethix (10. Jan 2011)

Danke, genau so eine Erklärung habe ich gebraucht 
Gibt es eine einfach Möglichkeit, sich Bytes mit dieser Darstellung mit System.out.prinln auf der Konsole ausgeben zu lassen? Also schon irgendeine fertige Funktion oder so?


----------



## Antoras (10. Jan 2011)

tagedieb hat gesagt.:


> Der
> 
> 
> 
> ...


Das bezweifle ich. Und selbst wenn wären es Microoptimierungen, die man nicht merken würde. Guck lieber, dass der Code verständlicher ist.

Integer in Binärdarstellung:

```
Integer.toBinaryString(aInt)
```


----------



## tagedieb (10. Jan 2011)

Antoras hat gesagt.:


> Das bezweifle ich. Und selbst wenn wären es Microoptimierungen, die man nicht merken würde. Guck lieber, dass der Code verständlicher ist.



Ja stimmt. Kannst machen wie du willst. Die Haelfte der Beispiele im Internet benutzen 
	
	
	
	





```
|
```
 und die andern 
	
	
	
	





```
+
```


----------



## Antoras (10. Jan 2011)

Man sollte sich nicht immer auf alles verlassen was im Internet steht. 

Hier z.B. bekommt man unterschiedliche Ergebnisse:

```
11 + 11 != 11 | 11
```
Wobei folgendes immer das Gleiche ergibt:

```
10 + 01 == 10 | 01
```
Für jemanden, der einen Code nur liest aber nicht selbst geschrieben hat, ist auf den ersten Blick nicht erkennbar ob sich der Schöpfer des Codes dessen bewusst war. Er kann auch nicht sofort erkennen ob der Code fehlerfrei arbeitet oder bei bestimmten Eingabewerten falsche Ausgabewerte produziert. Deswegen gar nicht erst auf die Idee kommen und bei einer Berechnung bei der ein ODER sinnvoll ist eine Addition verwenden weil man der Meinung ist, dass die höherwertigen Bits sowieso nie davon betroffen sind. Selbst wenn der Code durch diese Überlegung fehlerfrei arbeiten würde sollte man immer auch an denjenigen denken, der den Code einmal zu Gesicht bekommt - auch wenn man es nur selbst ist aber halt ein halbes Jahr später.


----------



## tagedieb (11. Jan 2011)

Ja wenn ich den Code selber geschrieben haette ich wohl auch 
	
	
	
	





```
|
```
 verwendet.
Da sich in diesem Algorithmus keine Bits ueberschneiden ist es gleichbedeutend wie ein 
	
	
	
	





```
+
```
.

Sicher ist diese Logik nicht fuer jedermann ersichtlich und deshalb die Addition vorzuziehen.

Ich habe versucht eine Erklaerung fuer den 
	
	
	
	





```
|
```
 Operator zu finden und das einzig Logische scheint mit aus (Micro-)Performance Gruenden.


----------



## Andi_CH (11. Jan 2011)

... und was schliessen wir daraus  Noch wichtiger als lauffähiger Code ist guter Kommentar


----------

