byte [] in String convertieren?

[Guest]

Hallo,

ich habe Quellcode im Internet gefunden der mir einen byte-Array in einen String convertieren kann und der funktioniert auch super.
Ich würde den aber gerne auch verstehen und da gibts ein kleines Problem.

Diese Zeile sagt mir einfach garnichts und das ist wohl die entscheidende:

hexDigit[(b >> 4) & 0x0f];

Was bedeutet der Operator '>>'? Ich finde den nicht im Netz.

Danke

Christian


PS: Der gesammte Code:

   /** hexadecimal digits */
  private static char hexDigit[] =
  {
    '0', '1', '2', '3', '4', '5', '6', '7',
    '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
  };
  
  /** conversion routine */
  public static char byteToHexHi(byte b)
  {
    return hexDigit[(b >> 4) & 0x0f];
  }
  /** conversion routine */
  public static char byteToHexLo(byte b)
  {
    return hexDigit[b & 0x0f];
  }

  /** Inserts the hex representation of the given byte array. */
  public static String setValue( byte[] bytes)
  {
    if (bytes != null)
    {
      StringBuffer string=new StringBuffer(bytes.length*2);
      for (int i=0; i<bytes.length;++i)
      {
      	string.append(byteToHexHi(bytes[i]));
        string.append(byteToHexLo(bytes[i]));
      }
      return string.toString();
    }
    else return "";
  }

 

[byte]

das ist der shift operator. b wird um 4 bits nach rechts geschoben.

 

[Guest]

Danke für deine Antwort.

Ich war gerade etwas länger weg. Tut mir leid, dass das Feedback erst jetzt kommt.

Also der Operator würde bedeuten:

1100 0111 >> 0000 1100

Was bedeutet dann das & 0x0F?
eine UND-Verknüpfung?

0000 1100 &
0000 1111 =
0000 1100

Irgendwo muss ich da ne Fehler haben glaube ich.

 

[Bleiglanz]

sollte eigentlich überflüssig sein,

denn durch das >> kommen ja von links eh nullen rein...hmm...

aber ich glaub, dass >> mit vorzeichen shiftet, weshalb der autor eher >>> hätte nehmen sollen...?

 

[byte]

Was bedeutet dann das & 0x0F?
eine UND-Verknüpfung?

0000 1100 &
0000 1111 =
0000 1100

Irgendwo muss ich da ne Fehler haben glaube ich.

genau richtig. & ist der bitweise AND vergleich. falsch ist der vergleich in diesem fall nicht, nur überflüssig, wie bleiglanz schon sagte und du schon richtig erkannt hast.

 

[Guest]

Hallo noch mal

ganz so einfach ist die Sache doch nicht wie gedacht.
Die Ausgabe unterscheidet sich sehr wohl wenn ich das & 0xff weglasse:

           byte b = (byte)0xc7;          
           System.out.println("1: " + b);		// Ausgabe = 1: -57
           System.out.println("2: " + (b & 0xFF));	// Ausgabe = 1: 199

Und ich glaube ich habe auch eine Erklärung dafür.

zu 1:
Bei der Ausgabe von b mit Hilfe von println() wird b in int konvertiert
int ist 4 byte lang und der Wert im Speicher sollte so aussehen
1000 0000 1100 0111 ( die erste 1 ist für das negative Vorzeichen)
Die Anzeige ist korrekt da das Byte als negativ gekennzeichnet ist.

zu 2:
b wird wieder in int konvertiert
die 4 byte int sehen wieder gleich aus
1000 0000 1100 0111
jetzt kommt aber die UND-Verknüpfung mit 0x00FF (die 00 werden automatisch eingefügt)
0000 0000 1111 1111
Ergebnis:
0000 0000 1100 0111
Weil es jetzt ein int ist und es keine führende 1 hat muss es positiv sein und der Wert ist 199

Das sind alles Vermutungen aber ich glaube es passt zusammen und ich habe keinen Fehler gemacht.


Würde mich tierisch interessieren ob ich recht habe

Christian

 

[Reinhold]

schau dir mal das an:www.uni-klu.ac.at/~thaichho/javahandbuch/k100028.html#sectlevel3id004006002

gruß,
reinhold

 

[Guest]

die funktionalität steht das ist kein Problem.
Mir gehts nur noch ums Verständnis und da bringt mich der Link nicht viel weiter.

3. Zeile bei zu 2: müsse eigentlich
1111 1111 1100 0111 anstatt 1000 0000 1100 0111 sein.

 

[Bleiglanz]

warum müsste? kann doch nicht sein

& 00FF

setzt eben die bits 31-16 auf null, ganz einfach

 

[Reinhold]

der link könnte schon helfen, wenn du ihn genau liest:

ein byte hat standardmäßig den wertebereich -128..127. wenn es aber nun aus programmtechnischen oder sonstigen gründen erforderlich ist, die werte 0..255 verwenden zu können ohne dafür einen short oder int zu verwenden, so kann man dies realisieren indem man & 0xff verwendet. dabei wird das high-byte sozusagen ignoriert, also -wie du schon erkannt hast- das vorzeichenbit weggeschnitten. somit hat man 'nach außen hin' zwar immer noch ein byte, intern repräsentiert das byte jetzt aber den wertebereich 0..255. somit spart man sich 1 bzw. 3 zusätzliche bytes, die für eine short oder int variable nötig wären.

gruß,
reinhold