Побитови оператори на Java

В днешния урок ще се запознаем с побитовите оператори на Java и ще разгледаме примери How да работим с тях. Вероятно сте запознати с думата „бит“. Ако не, нека си припомним Howво означава :) Битът е най-малката единица информация в компютъра. Името му идва от двоична цифра . Битът може да бъде изразен с едно от две числа: 1 or 0. Съществува специална двоична бройна система, базирана на единици и нули. Тук няма да се ровим в математическа джунгла. Само ще отбележим, че всяко число в Java може да бъде преобразувано в двоична форма. За да направите това, трябва да използвате класовете обвивки. Например, ето How можете да направите това за int :

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(Integer.toBinaryString(x));
   }
}

Изход от конзолата: 101010110 1010 10110 (добавих интервала, за да е по-лесно за четене) е числото 342 в десетичната система. Ние всъщност разбихме това число на отделни битове: нули и единици. Операциите, извършвани върху битове, се наричат ​​побитови .

• ~ - побитово НЕ.

Този оператор е много прост: той преминава през всеки бит от нашето число и обръща бита: нулите стават единици, а единиците стават нули. Ако го приложим към нашето число 342, ето Howво се случва: 101010110 е 342, представено като двоично число 010101001 е стойността на израза ~342 Нека се опитаме да приложим това на практика:

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(~x);
   }
}

Конзолен изход: 169 169 е нашият резултат ( 010101001 ) в познатата десетична система :)

• & - побитово И

Както можете да видите, изглежда доста подобно на логическото И ( && ). Сигурно си спомняте, че операторът && връща true само ако и двата операнда са true . Побитово & работи по подобен начин: сравнява две числа малко по малко. Сравнението дава трето число. Например, нека вземем числата 277 и 432: 110110000 е 277, представено като двоично число, 1000101011 е 432, представено като двоично число След това операторът & сравнява първия бит от горното число с първия бит от долното число. Тъй като това е оператор И, резултатът ще бъде 1 само ако и двата бита са 1. Във всеки друг случай резултатът е 0. 100010101 && оператор Първо сравняваме първите битове на двете числа, след това вторите битове, след това третите и т.н. Както можете да видите, само в два случая и двата съответни бита в числата са равни на 1 (първият и петият бит). Всички други сравнения дадоха 0s. Така в крайна сметка получихме числото 10001000. В десетичната система то отговаря на числото 272. Да проверим:

public class Main {

   public static void main(String[] args) {
       System.out.println(277&432);
   }
}

Конзолен изход: 272

• | - побитово ИЛИ.

Този оператор работи по същия начин: сравнява две числа малко по малко. Само сега, ако поне един от битовете е 1, тогава резултатът е 1. Нека да разгледаме същите числа (277 и 432): 100010101 | 110110000 _______________ 110110101 - резултат от | оператор Тук получаваме различен резултат: единствените битове, които остават нули, са онези битове, които са бor нули и в двете числа. Резултатът е числото 110110101. В десетичната система то отговаря на числото 437 Да проверим:

public class Main {

   public static void main(String[] args) {
       System.out.println(277|432);
   }
}

Изход от конзолата: 437 Изчислихме всичко правилно! :)

• ^ - побитово XOR (изключващо ИЛИ)

Все още не сме срещали този оператор. Но в това няма нищо сложно. Той е подобен на обикновения оператор ИЛИ. Има една разлика: обикновеното ИЛИ връща true, ако поне един операнд е true. Но не е задължително да е един: ако и двата операнда са верни, резултатът е верен. Но изключителното ИЛИ връща true само ако точно един от операндите е true. Ако и двата операнда са верни, обикновеното ИЛИ връща истина („поне един верен“), но XOR връща невярно. Ето защо се нарича изключително ИЛИ. Знаейки How работят предишните побитови оператори, вероятно лесно можете да изчислите 277 ^ 432. Но нека се поразровим заедно още веднъж :) 100010101 ^ 110110000 _______________ 010100101 - резултат от ^оператор Това е нашият резултат. Тези битове, които са еднакви и в двете числа, дават 0 (което означава, че тестът "само един" е неуспешен). Но битовете, които образуваха двойка 0-1 or 1-0, станаха единици. Нашият резултат е числото 010100101. В десетичната система то съответства на числото 165. Да видим дали изчисленията ни са верни:

public class Main {

   public static void main(String[] args) {
       System.out.println(277^432);
   }
}

Конзолен изход: 165 Супер! Всичко е точно Howто си мислехме :) Сега е време да се запознаем с операторите за битови смени. Името говори само за себе си. Взимаме няHowво число и местим битовете му наляво or надясно :) Да видим How изглежда:

Преместване наляво

Преместване на битове наляво се обозначава с << Ето един пример:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(Integer.toBinaryString(x));
       System.out.println(Integer.toBinaryString(z));
   }
}

В този пример числото x = 64 се нарича стойност. Това са частите от стойността, които ще изместим. Ще изместим битовете наляво (можете да познаете това по посоката на оператора << ) В двоичната система числото 64 = 1000000 Числото y = 3 се нарича разстояние на изместване. Разстоянието на изместване показва колко бита надясно/наляво искате да изместите битовете на числото x В нашия пример ще ги изместим 3 бита наляво. За да видите по-ясно процеса на смяна, погледнете снимката. В този пример използваме int s. Ints заемат 32 бита в паметта на компютъра. Ето How изглежда нашето оригинално число 64: И сега вземаме всеки от нашите битове и буквално ги преместваме наляво с 3 места: Вижте Howво имаме. Както можете да видите, всички наши битове са се изместor и са добавени още 3 нули от ръба на диапазона. Три, защото преместихме с 3. Ако бяхме преместor с 10, щяха да се добавят 10 нули. Така изразът x << y означава "преместване на битовете на числото x наляво с y места". Резултатът от нашия израз е числото 1000000000, което е 512 в десетичната система. Да проверим:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

Изход за конзолата: 512 На място! Теоретично, битовете могат да се преместват безкрайно, но тъй като нашето число е int , имаме само 32 двоични цифри. От тях 7 вече са заети от 64 (1 000 000). Следователно, ако преместим 27 места наляво, единственото ни ще излезе извън обхвата на типа данни и ще бъде изгубено. Ще останат само нули!

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 26;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

Конзолен изход: 0 Както се очакваше, този се премести отвъд 32-те налични бита и изчезна. Завършихме с 32-битово число, състоящо се само от нули. Естествено, това съответства на 0 в десетичната система. Ето едно просто правило за запомняне на премествания наляво: За всяко изместване наляво числото се умножава по 2. Нека се опитаме да изчислим следния израз без изображения на битове 111111111 << 3 Трябва да умножим числото 111111111 по 2 . В резултат на това получаваме 888888888. Нека да напишем code и да проверим:

public class Main {

   public static void main(String[] args) {
       System.out.println(111111111 << 3);
   }
}

Конзолен изход: 888888888

Shift надясно

Тази операция се обозначава с >> . Прави същото, но в другата посока! :) Няма да преоткриваме колелото. Нека опитаме със същото int 64.

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 2;// Shift distance

       int z = (x >> y);
       System.out.println(z);
   }
}

В резултат на изместване надясно с 2, двете крайни нули в нашето число излизат извън диапазона и се губят. Получаваме 10 000, което съответства на числото 16 в десетичната система Изход на конзолата: 16 Ето едно просто правило за запомняне на премествания надясно: Всяко преместване надясно се дели на две, изхвърляйки всеки остатък. Например, 35 >> 2 означава, че трябва да разделим 35 на 2 два пъти, като изхвърлим остатъците 35/2 = 17 (изхвърлете остатъка 1) 17/2 = 8 (изхвърлете остатъка 1) В крайна сметка 35 >> 2 трябва е равно на 8. Нека проверим:

public class Main {

   public static void main(String[] args) {
       System.out.println(35 >> 2);
   }
}

Конзолен изход: 8

Предимство на оператора в Java

Докато пишете и четете code, често ще намерите изрази, които комбинират няколко операции. Много е важно да разберете реда, в който ще бъдат изпълнени (в противен случай може да се изненадате от резултата). Тъй като Java има много операции, на всяка от тях е определено място в специална table:

Приоритет на оператора

Всички операции се извършват отляво надясно, като се вземе предвид техният приоритет. Например, ако пишем

int x  = 6 - 4/2;

тогава първо ще се извърши операцията за деление ( 4/2 ). Въпреки че е на второ място, той има по-висок приоритет. Скобите и скобите показват максимален приоритет. Сигурно го помните от учorще. Например, ако ги добавите към израза

int x  = (6 - 4)/2;

тогава първо се извършва изваждането, тъй като е оградено в скоби. Приоритетът на логическия && оператор е доста нисък (вижте tableта), така че обикновено ще бъде последен. Например:

boolean x = 6 - 4/2 > 3 && 12*12 <= 119;

Този израз ще бъде изпълнен Howто следва:

• 4/2 = 2

boolean x = 6 - 2 > 3 && 12*12 <= 119;

• 12*12 = 144

boolean x = 6 - 2 > 3 && 144 <= 119;

• 6-2 = 4

boolean x = 4 > 3 && 144 <= 119;

След това се изпълняват операторите за сравнение:

• 4 > 3 = вярно

boolean x = true && 144 <= 119;

• 144 <= 119 = невярно

boolean x = true && false;

И накрая, операторът И ( && ) ще бъде изпълнен последен.

boolean x = true && false;
boolean x = false;

Например операторът add( + ) има по-висок приоритет от оператора за сравнение != (не е равно); Следователно в израза

boolean x = 7 != 6+1;

първо ще се изпълни операцията 6+1, след това проверката 7 != 7 (която се оценява като false) и накрая присвояването на резултата (false) към променливата x (присвояването обикновено има най-нисък приоритет от всички оператори ; вижте масата). уф! Беше огромен урок, но вие го направихте! Ако не сте разбрали напълно някои от този or предишните уроци, не се притеснявайте. Ще засягаме тези теми повече от веднъж в бъдеще. Няколко урока по CodeGym за логически и числови операции. Няма да стигнем до тях скоро, но няма нищо лошо да ги прочетете сега.