## 1. Overview

Java provides a set of bitwise operators. Those operators allow us to conveniently manipulate individual bits of a number.

However, when we compare the result of a bitwise operation, we might fall into a common pitfall.

In this quick tutorial, we'll discuss why we may encounter the Java compile-time error “bad operand types for binary operator”, and how to resolve the problem.

## 2. Introduction to the Problem

As usual, we'll understand the problem through an example. But, first, let's take a look at a simple method:

``````public void checkNumber() {
List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
intList.forEach(i -> {
if (i & 1 == 1) {
System.out.println(i + " is odd.");
} else {
System.out.println(i + " is even.");
}
});
}
``````

As we can see, the checkNumber method walks through intList, and checks and outputs if each number is even or odd.

We should note that the odd-checking logic in the method is not implemented in a common way: i % 2 == 1. Instead, we perform the bitwise AND (&) operation on an Integer number (i) and 1. If the result is 1, we know the integer i is an odd number: i & 1 ==1.

However, when we try to test the method above, the code surprisingly doesn't compile:

``````java: bad operand types for binary operator '&'
first type:  java.lang.Integer
second type: boolean``````

Next, let's understand what the cause of the problem is and how to solve it.

## 3. Understanding Java Operator Precedence

First of all, the error message is pretty straightforward. It says we attempt to do a bitwise AND on a boolean type and an Integer type.

However, it's weird as we literally wrote “i & 1” in the code. Why does the compiler think a boolean type participates in the bitwise AND operation?

This is because the “==” operator has higher precedence than the “&” operator. That is to say the expression “i & 1 == 1” is the same as “i & (1 == 1)“. Thus, we have “i & true (boolean)“.

Now, we may ask: “Ok, == has higher precedence than &. But why does ‘i % 2 == 1‘ work as expected?”

To answer that question, we need to take a closer look at Java operators' precedence rule.

Java has provided quite a number of operators. In practice, we often use different operators together. Therefore, understanding the precedence of Java operators is essential. Otherwise, we may have an unexpected result.

Next, let's have a look at the Java operator precedence rule (the higher in the table an operator appears, the higher precedence it has):

Operators Precedence
postfix expr++ expr
unary ++exprexpr +exprexpr ~ !
multiplicative * / %
shift << >> >>>
relational < > <= >= instanceof
equality == !=
bitwise AND &
bitwise exclusive OR ^
bitwise inclusive OR |
logical AND &&
logical OR ||
ternary ? :
assignment = += -= *= /= %= &= ^= |= <<= >>= >>>=

As we can see in the list above, the modulo operator (%) has higher precedence than the equality operator (==). On the other hand, the bitwise AND operator (&) is below the equality operator (==) in the table.

That's why “i % 2 == 1” works as expected but “i & 1 == 1” does not.

We've encountered a compile-time error in our example. So, we can detect the problem relatively early. However, imagine some implementation with the operator precedence bug compiles but produces a wrong result. Finding the real cause of the problem could unnecessarily take us much time.

So, it's worth keeping the Java operator precedence rule in mind.

## 4. Fixing the Problem

Now that we understand the cause of the problem, fixing the problem isn't a hard job. We just need to add parentheses to the bitwise AND operation:

``if (i & 1 == 1)  -->  if ((i & 1) == 1)``

After the fix, if we run the method once again, we'll see the compiler doesn't complain anymore, and we receive the expected output:

``````1 is odd.
2 is even.
3 is odd.
4 is even.
5 is odd.
6 is even.
7 is odd.``````

## 5. Conclusion

In this quick article, we've analyzed the compilation error “bad operand types for binary operator” through a bitwise AND operation example.

Further, we've discussed Java operators' precedence rule.

Finally, we've fixed the problem.

### Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

>> CHECK OUT THE COURSE
{"ft_lang_label":"__label__en","ft_lang_prob":0.87830645,"math_prob":0.96290666,"size":4144,"snap":"2023-14-2023-23","text_gpt3_token_len":1048,"char_repetition_ratio":0.13768116,"word_repetition_ratio":0.021592442,"special_character_ratio":0.27895752,"punctuation_ratio":0.14981273,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9960136,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2023-06-04T19:59:16Z\",\"WARC-Record-ID\":\"<urn:uuid:43d10226-4787-4607-b6ef-c82f2fef12bc>\",\"Content-Length\":\"120647\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:9f143144-6edc-4061-80b4-e3a5af3c54ad>\",\"WARC-Concurrent-To\":\"<urn:uuid:e811df87-24d8-47c1-9143-de38eb92e24e>\",\"WARC-IP-Address\":\"172.66.40.248\",\"WARC-Target-URI\":\"https://www.baeldung.com/java-bad-operand-types\",\"WARC-Payload-Digest\":\"sha1:CTIK5W3TZJVWEL6JW7RXIVOPHQ5NN3YT\",\"WARC-Block-Digest\":\"sha1:LXL2P6QMZDVKCZSBD6Z24VE3BMPCQOHJ\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2023/CC-MAIN-2023-23/CC-MAIN-2023-23_segments_1685224650264.9_warc_CC-MAIN-20230604193207-20230604223207-00263.warc.gz\"}"}