Java'da değer ve 0xff ne yapar?

Aşağıdaki Java koduna sahibim:

byte value = 0xfe; // corresponds to -2 (signed) and 254 (unsigned)
int result = value & 0xff;

Sonuç, yazdırıldığında 254'tür, ancak bu kodun nasıl çalıştığı hakkında hiçbir fikrim yok. Eğer &operatör sadece bit bazında, o zaman neden bir bayt ve bunun yerine bir tamsayı yol açmaz mı?

result8 bitin valueen düşük 8 bit içine yerleştirilmesinden kaynaklanan (işaretsiz) değere ayarlar result.

Bunun gibi bir şeyin gerekli olmasının nedeni byte, Java'da imzalı bir tür olmasıdır. Az önce yazdıysanız:

int result = value;

o resultzaman ff ff ff feyerine değerle sonuçlanır 00 00 00 fe. Diğer bir incelik, &yalnızca ¹int değerleri üzerinde çalışacak şekilde tanımlanmış olmasıdır , yani ne olur:

1. valuebir int( ff ff ff fe) olarak yükseltilir .
2. 0xffbir intdeğişmezdir ( 00 00 00 ff).
3. İçin &istenen değeri vermek için uygulanır result.

(Nokta için bu dönüşüm intolur önce& operatör uygulanır.)

1 _{Pekala, tam olarak değil. &Operatör çalışır longya işlenen bir ise, hem değerler long. Ama açık değil byte. Java dil belirtimi bakın bölümler 15.22.1 ve 5.6.2 .}

Gönderen http://www.coderanch.com/t/236675/java-programmer-SCJP/certification/xff

Onaltılık değişmez değeri 0xFF eşittir int (255). Java, int'i 32 bit olarak temsil eder. İkili olarak şöyle görünür:

00000000 00000000 00000000 11111111

Herhangi bir sayı üzerinde biraz VE bu değerle (255) biraz akıllıca yaptığınızda, sayının en düşük 8 biti hariç tümünü maskeleyecektir (SIFIR yapacaktır) (olduğu gibi olacaktır).

... 01100100 00000101 & ...00000000 11111111 = 00000000 00000101

&% gibi bir şeydir, ancak gerçekten değil .

Ve neden 0xff? bu ((2'nin kuvveti) - 1). Hepsi ((2'nin kuvveti) - 1) (örneğin 7, 255 ...)% operatörü gibi davranacaktır.

O zaman
ikili olarak 0, tümü sıfırdır ve 255 şuna benzer:

00000000 00000000 00000000 11111111

Ve -1 buna benziyor

11111111 11111111 11111111 11111111

Bitsel VE 0xFF değerini ve 0 ile 255 arasında herhangi bir değeri yaptığınızda, sonuç değerle tam olarak aynıdır. Ve 255'ten yüksek herhangi bir değer varsa, sonuç yine de 0-255 arasında olacaktır.

Ancak, yaparsanız:

-1 & 0xFF

sen alırsın

00000000 00000000 00000000 11111111-1'in orijinal değerine eşit DEĞİLDİR ( 11111111ondalık olarak 255'tir).

Birkaç bit daha fazla manipülasyon: (Soruyla ilgili değil)

X >> 1 = X/2
X << 1 = 2X

Belirli bir bitin ayarlanmış (1) olup olmadığını (0) kontrol edin ve ardından

 int thirdBitTobeChecked =   1 << 2   (...0000100)
 int onWhichThisHasTobeTested = 5     (.......101)

 int isBitSet = onWhichThisHasTobeTested  & thirdBitTobeChecked;
 if(isBitSet > 0) {
  //Third Bit is set to 1 
 } 

Belirli bir biti ayarlayın (1)

 int thirdBitTobeSet =   1 << 2    (...0000100)
 int onWhichThisHasTobeSet = 2     (.......010)
 onWhichThisHasTobeSet |= thirdBitTobeSet;

Belirli bir biti yeniden ayarla (0)

int thirdBitTobeReSet =   ~(1 << 2)  ; //(...1111011)
int onWhichThisHasTobeReSet = 6      ;//(.....000110)
onWhichThisHasTobeReSet &= thirdBitTobeReSet;

ÖZELVEYA

Yalnızca XOR işlemini iki kez gerçekleştirirseniz, aynı değerle sonuçlanacağını unutmayın.

byte toBeEncrypted = 0010 0110
byte salt          = 0100 1011

byte encryptedVal  =  toBeEncrypted ^ salt == 0110 1101
byte decryptedVal  =  encryptedVal  ^ salt == 0010 0110 == toBeEncrypted :)

XOR ile bir mantık daha

if     A (XOR) B == C (salt)
then   C (XOR) B == A
       C (XOR) A == B

Yukarıdakiler, aşağıdaki gibi geçici olmadan iki değişkeni değiştirmek için kullanışlıdır

a = a ^ b; b = a ^ b; a = a ^ b;

VEYA

a ^= b ^= a ^= b;

Çok sayıda kodu azaltmaya yardımcı olur. Zaman zaman 8 bitten oluşan RGB değerlerinde kullanılır.

0xff anlamına gelirken 24 (0) 'ın ve 8 (1' s) gibi00000000 00000000 00000000 11111111

Değişkeni etkin bir şekilde maskeler, böylece yalnızca son 8 bitteki değeri bırakır ve bitlerin geri kalanını yok sayar

Renk değerlerini özel bir formattan standart RGB değerlerine (8 bit uzunluğunda) dönüştürmeye çalışmak gibi durumlarda en çok görülür.

Harika Açıklama Buraya bakın

32 bit format sisteminde onaltılık değer 0xff, 00000000000000000000000011111111bunun 255(15*16^1+15*16^0)ondalık olarak olduğunu gösterir. ve bitsel & işleç, ilk işlenenle aynı 8 en sağdaki biti maskeler.