Java Reference
InDepth Information
true
. In other words, it evaluates to
false
if both operands are
false
or if both
operands are
true
. Unlike the
&&
and

operators, this one must always evalu‐
ate both operands. The
^
operator is much more commonly used as a bitwise
operator on integer operands. With
boolean
operands, this operator is equiva‐
lent to the
!=
operator.
a
x
Bitwise and Shift Operators
The bitwise and shift operators are lowlevel operators that manipulate the individ‐
ual bits that make up an integer value. The bitwise operators are not commonly
used in modern Java except for lowlevel work (e.g., network programming). They
are used for testing and setting individual flag bits in a value. In order to understand
their behavior, you must understand binary (base2) numbers and the two's comple‐
ment format used to represent negative integers.
You cannot use these operators with floatingpoint,
boolean
, array, or object
operands. When used with
boolean
operands, the
&
,

, and
\^
operators perform a
different operation, as described in the previous section.
If either of the arguments to a bitwise operator is a
long
, the result is a
long
. Other‐
wise, the result is an
int
. If the left operand of a shift operator is a
long
, the result is
a
long
; otherwise, the result is an
int
. The operators are:
Bitwise complement (
~
)
The unary
~
operator is known as the bitwise complement, or bitwise NOT,
operator. It inverts each bit of its single operand, converting 1s to 0s and 0s to
1s. For example:
byte
b
=
~
12
;
// ~00001100 = => 11110011 or 13 decimal
flags
=
flags
&
~
f
;
// Clear flag f in a set of flags
Bitwise AND (
&
)
This operator combines its two integer operands by performing a Boolean
AND operation on their individual bits. The result has a bit set only if the cor‐
responding bit is set in both operands. For example:
10
&
7
// 00001010 & 00000111 = => 00000010 or 2
if
((
flags
&
f
)
!=
0
)
// Test whether flag f is set
When used with
boolean
operands,
&
is the infrequently used Boolean AND
operator described earlier.
Bitwise OR (

)
This operator combines its two integer operands by performing a Boolean OR
operation on their individual bits. The result has a bit set if the corresponding
bit is set in either or both of the operands. It has a zero bit only where both
corresponding operand bits are zero. For example:
10

7
// 00001010  00000111 = => 00001111 or 15
flags
=
flags

f
;
// Set flag f