class Bitlogic { 
	public static void main(String args []) { 
		String binary[] = { "OOOO", "0001", "0010",
                            "0011", "0100", "0101",
                            "0110", "0111", "1000",
                            "1001", "1010", "1011",
                            "1100", "1101", "1110",
                            "1111" }; 
		int a = 3;   //     0+2+1  или двоичное 0011 
		int b = 6;   //     4+2+0  или двоичное 0110 
		int c = a | b; 
		int d = a & b; 
		int e = a ^ b; 
		int f = (~a & b) | (a & ~b); 
		int g = ~a & 0x0f; 
		System.out.println(" a = " + binary[a]); 
		System.out.println(" b = " + binary[b]); 
		System.out.println(" ab = " + binary[c]); 
		System.out.println(" a&b = " + binary[d]); 
		System.out.println(" a^b = " + binary[e]); 
		System.out.рrintln("~a&b|а^~Ь = " + binary[f]); 
		System.out.println(" ~a = " + binary[g]); 
		}
	} 

Ниже приведен результат, полученный при выполнении этой программы:

Ниже приведен результат, полученный при выполнении этой программы:

С: \> Java BitLogic 
	a = 0011 
	b = 0110 
	a | b = 0111 
	a & b = 0010 
	a ^ b = 0101 
	~a & b | a & ~b = 0101 
	~а = 1100 

Сдвиги влево и вправо

Оператор << выполняет сдвиг влево всех битов своего левого операнда на число позиций, заданное правым операндом. При этом часть битов в левых разрядах выходит за границы и теряется, а соответствующие правые позиции заполняются нулями. В предыдущей главе уже говорилось об автоматическом повышении типа всего выражения до int в том слу-чае если в выражении присутствуют операнды типа int или целых типов меньшего размера. Если же хотя бы один из операндов в выражении имеет тип long, то и тип всего выражения повышается до long.

Оператор >> означает в языке Java сдвиг вправо. Он перемещает все биты своего левого операнда вправо на число позиций, заданное правым операндом. Когда биты левого операнда выдвигаются за самую правую позицию слова, они теряются. При сдвиге вправо освобождающиеся старшие (левые) разряды сдви-гаемого числа заполняются предыдущим содержимым знакового разряда. Такое поведение называют расширением знакового разряда.

В следующей программе байтовое значение преобразуется в строку, содержащую его шестнадцатиричное представление. Обратите внимание - сдвинутое значение приходится маскировать, то есть логически умножать на значение 0х0f, для того, чтобы очистить заполняемые в результате расширения знака биты и по-низить значение до пределов, допустимых при индексировании массива шестнадцатиричных цифр.

class  HexByte { 
	static public void main(String args[]) { 
		char hex[] = { '0', '1, '2', '3', '4', '5', '6',
                       '7', '8', '9', 'a', 'b', 'c', 'd',
                      'e', 'f }; 
		byte b = (byte) 0xf1; 
		System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] +
                            hex[b & 0x0f]); 
		}
	} 

Ниже приведен результат работы этой программы:

	С:\> java HexByte 
	b = 0xf1 

Беззнаковый сдвиг вправо

Часто требуется, чтобы при сдвиге вправо расширение знакового раз-ряда не происходило, а освобождающиеся левые разряды просто запол-нялись бы нулями.

class ByteUShift   { 
	static public void main(String args[]) { 
		char hex[] = { '0', '1', '2', '3', '4',
                       '5', '6', '7', '8', '9',
                       'а', 'b', 'с', 'd', 'e',
                       'f' }; 
		byte b = (byte) 0xf1; 
		byte c = (byte) (b >> 4); 
		byte d = (byte) (b >> 4); 
		byte e = (byte) ((b & 0xff) >> 4); 
		System.out.println(" b = 0x" + hex(b >> 4) & 0x0f] +
                            hex[b & 0x0f]); 
		System.out.println(" b >> 4 =  0x" + 
							hex[(c >> 4) & 0x0f] +
                            hex[c & 0x0f]); 
		System.out.println("b >>> 4 = 0x" + 
							hex[(d >> 4) & 0x0f] +
                            hex[d & 0x0f]); 
		System.out.println("(b & 0xff) >> 4 = 0x" +
                            hex[(e >> 4) & 0x0f] + 
                            hex[e & 0x0f]); 
		}
	} 

Для этого примера переменную b можно было бы инициализировать произвольным отрицательным числом, мы использовали число с шест-надцатиричным представлением 0xf1. Переменной с присваивается ре-зультат знакового сдвига b вправо на 4 разряда. Как и ожидалось, рас-ширение знакового разряда приводит к тому, что 0xf1 превращается в 0xff. Затем в переменную d заносится результат беззнакового сдвига b вправо на 4 разряда. Можно было бы ожидать, что в результате d со-держит 0x0f, однако на деле мы снова получаем 0xff. Это - результат расширения знакового разряда, выполненного при автоматическом по-вышении типа переменной b до int перед операцией сдвига вправо. На-конец, в выражении для переменной е нам удается добиться желаемого результата - значения 0x0f. Для этого нам пришлось перед сдвигом вправо логически умножить значение переменной b на маску 0xff, очис-тив таким образом старшие разряды, заполненные при автоматическом повышении типа. Обратите внимание, что при этом уже нет необходи-мости использовать беззнаковый сдвиг вправо, поскольку мы знаем со-стояние знакового бита после операции AND.

	С: \> java ByteUShift 
	b = 0xf1 
	b >> 4 = 0xff 
	b >>> 4 = 0xff 
	b & 0xff) >> 4 = 0x0f 

Битовые операторы присваивания

Так же, как и в случае арифметических операторов, у всех бинарных битовых операторов есть родственная форма, позволяющая автоматичес-ки присваивать результат операции левому операнду. В следующем примере создаются несколько целых переменных, с ко-торыми с помощью операторов, указанных выше, выполняются различ-ные операции.

class OpBitEquals { 
	public static void main(String args[]) { 
		int a = 1; 
		int b = 2; 
		int с = 3; 
		a |= 4; 
		b >>= 1; 
		с <<= 1; 
		а ^= с; 
		System.out.println("a = " + a); 
		System.out.println("b = " + b); 
		System.out.println("c = " + c); 
		}
	} 

Результаты исполнения программы таковы:

	С:\> Java OpBitEquals 
	а = 3 
	b = 1 
	с = 6 

Операторы отношения

Для того, чтобы можно было сравнивать два значения, в Java имеется набор операторов, описывающих отношение и равенство. Список таких операторов приведен в таблице.

class BoolLogic { 
	public static void main(String args[]) { 
		boolean a = true; 
		boolean b = false; 
		boolean с = a | b; 
		boolean d = a & b; 
		boolean e = a ^ b; 
		boolean f = (!a & b) | (a & !b); 
		boolean g = !a; 
		System.out.println(" a = " + a); 
		System.out.println(" b = " + b); 
		System.out.println(" a|b = " + c); 
		System.out.println(" a&b = " + d); 
		System.out.println(" a^b = " + e); 
		System.out.println("!a&b|a&!b = " + f); 
		System.out.println(" !a = " + g); 
		}
	} 


С: \> Java BoolLogic 
	а = true 
	b = false 
	a|b = true 
	a&b = false 
	a^b = true 
	!a&b|a&!b = true 
	!a = false 

	выражение1? выражение2: выражениеЗ 

class Ternary { 
	public static void main(String args[]) { 
		int a = 42; 
		int b = 2; 
		int c = 99; 
		int d = 0; 
		int e = (b == 0) ? 0 : (a / b); 
		int f = (d == 0) ? 0 : (c / d); 
		System.out.println("a = " + a); 
		System.out.println("b = " + b); 
		System.out.println("c = " + c); 
		System.out.println("d = " + d); 
		System.out.println("a / b = " + e); 
		System.out.println("c / d = " + f); 
		}
	} 

С: \>java Ternary 

	а = 42 
	b = 2 
	с = 99 
	d = 0 
	a / b = 21 
	с / d  = 0 

	а >> b + 3