Tablica Bajtów

Czesc, czołem!

 byte[] bytes = new byte[4];
        bytes[0] = (15 & 0xFF0000) >> 24;
        bytes[1] = (15 & 0x00FF00) >> 16;
        bytes[2] = (15 & 0x0000FF) >> 8;
        bytes[0] = 15 & 0xFF;

        System.out.println(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]);

Mam taki kod a pytanie to skad wiem w ilu bajtach zapisze dana liczbe ? w jaki sposob to szybko policzyc..
ad2 dlaczego przy liczbie np 10000 działa jakos dziwnie ? (liczba z kosmosu)

O co Ci chodzi ? byte to jeden bajt, int to 4 bajty, short 2, long 8... standard. A jaki wynik powinien byc wg Ciebie ?

[losowa nazwa] napisał(a)

O co Ci chodzi ? byte to jeden bajt, int to 4 bajty, short 2, long 8... standard. A jaki wynik powinien byc wg Ciebie ?

chodzi o to ze takim sposobem

byte[] bytes = new byte[4];
        bytes[0] = (15 & 0xFF0000) >> 24;
        bytes[1] = (15 & 0x00FF00) >> 16;
        bytes[2] = (15 & 0x0000FF) >> 8;
        bytes[3] = 15 & 0xFF;

        System.out.println(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]);

zapisuje liczbe i odczytuje poprawnie ale tylko o małej wartosc a jesli zamiast 15 dam np 1000 to nie działa poprawnie..
nawet jesli zrobie tak

 byte[] bytes = new byte[8];
        bytes[0] = (590 & 0xFF0000) >> 56;
        bytes[1] = (590 & 0x00FF00) >> 48;
        bytes[2] = (590 & 0x0000FF) >> 40;
        bytes[3] = (590 & 0x0000FF) >> 32;
        bytes[4] = (590 & 0x0000FF) >> 24;
        bytes[5] = (590 & 0x0000FF) >> 16;
        bytes[6] = (590 & 0x0000FF) >> 8;
        bytes[7] = 590 & 0xFF;

        System.out.println(bytes[0] << 56 | bytes[1] << 48 | bytes[2] << 40
                         | bytes[3] << 32 | bytes[4] << 24 | bytes[5] << 16
                         | bytes[6] << 8  | bytes[7]);

czyli zapisuje na 8 bajtach tez nie działa, i skoro mowiłes ze inta zapisze na 4 bajtach a jego zakres to od -2,147,483,648 do 2,147,483,647, dlaczego wiec kod powyzej (ten na 4 bajtach) nie działa ? nie czaje co robie zle ;|

Nie rozumiem Twoich przesunięć i tej tablicy 8 bajtów.

int n = ...
byte[] bytes = new byte[4];
bytes[0] = (byte)((n & 0xFF000000) >> 24);
bytes[1] = (byte)((n & 0x00FF0000) >> 16);
bytes[2] = (byte)((n & 0x0000FF00) >> 8);
bytes[3] = (byte)((n & 0x000000FF) >> 0);
System.out.println(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3] << 0);

Ja również chwile nad tym spędziłem i tez nie rozumiem...co Ty właściwie zamierzasz osiągnąć?

hmm all right gdy liczba jest mniejsza od 500 a przecież int ma wielki zakres i mieści się na 4 bajtach i już tego nie czaje przykład :

Poprawnie

int n = 50;
        byte[] bytes = new byte[4];
        bytes[0] = (byte)((n & 0xFF000000) >> 24);
        bytes[1] = (byte)((n & 0x00FF0000) >> 16);
        bytes[2] = (byte)((n & 0x0000FF00) >> 8);
        bytes[3] = (byte)((n & 0x000000FF) >> 0);
        System.out.println(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3] << 0);

wynik: 50

zle
Poprawnie

int n = 500;
        byte[] bytes = new byte[4];
        bytes[0] = (byte)((n & 0xFF000000) >> 24);
        bytes[1] = (byte)((n & 0x00FF0000) >> 16);
        bytes[2] = (byte)((n & 0x0000FF00) >> 8);
        bytes[3] = (byte)((n & 0x000000FF) >> 0);
        System.out.println(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3] << 0);

wynik: -12

dlaczego nie 500 ?

Zeby było zabawniej w innych jezykach działa na 50 i na 500 bez problemów!

...tak na oko to
w ostatnim przesunięciu brakuje rzutowania na int.
jak byte przesuniesz o 24 bity w lewo to wyjdzie zero..
więc te -12 wyjdzie tylko z bytes[3] << 0, bo pozostałe sekcje się wyzerują

A jednak nie do końca, poprawne rozwiązanie wygląda tak:

System.out.println( (bytes[0]&0xFF)<<24 | (bytes[1]&0xFF)<<16 | (bytes[2]&0xFF)<<8 | (bytes[3]&0xFF) );

Chodzi o to, że domyślna konwersja do int'a przenosi najstarszy bit z byte do najstarszego bitu w int'cie i stąd ten syf.

  int n = 500;

         int[] tablica = new int[4];

         System.out.println(tablica[0]);
         tablica[0]= (int) ((n & 0xFF000000) >> 24);
         System.out.println(tablica[0]);
         System.out.println();

         System.out.println(tablica[1]);
        tablica[1]= (int) ((n & 0x00FF0000) >> 16);
        System.out.println(tablica[1]);
        System.out.println();

        System.out.println(tablica[2]);
        tablica[2]= (int) ((n & 0x0000FF00) >> 8);
        System.out.println(tablica[2]);
        System.out.println();

          System.out.println(tablica[3]);
         tablica[3]= (int) ((n & 0x000000FF) >> 0);
          System.out.println(tablica[3]);
          System.out.println();

         System.out.println(tablica[0] << 24 | tablica[1] << 16|tablica[2] << 8 |tablica[3] << 0);

po zamianie na int wszystko ładnie działa i również możesz przesuwać.
jeżeli musisz działać na byte to lepiej rzutuj poszczególne wyniki.
Błąd występuje dlatego , (przypuszczam) że chodzi o formę zapisu oraz przechowywanie liczby ze znakiem. Nie wiem jaki jest zapis w javie ale pewnie U2.

THX! faktycznie teraz działa :)

Powyższy wątek podsunął mi takie pytanie: Mamy liczbę (typu byte) b=a₇a₆a₅a₄a₃a₂a₁a₀. Jak uzyskać liczbę (typu int) i=00....0a₇a₆a₅a₄a₃a₂a₁a₀?

Sam sobie odpowiedziałem

i = (int)b & 0x000000FF;

Zapisanie liczby typu int w postaci tablicy bajtów wygląda tak:

int n = ...
byte[] bytes = new byte[4];
bytes[0] = (byte)((n & 0xFF000000) >> 24);
bytes[1] = (byte)((n & 0x00FF0000) >> 16);
bytes[2] = (byte)((n & 0x0000FF00) >> 8);
bytes[3] = (byte)((n & 0x000000FF) >> 0);
System.out.println((bytes[0] & 0x000000FF) << 24 | (bytes[1] & 0x000000FF) << 16 | (bytes[2] & 0x000000FF) << 8  | (bytes[3] & 0x000000FF) << 0);