JAVA Bitwise code purpose , &

Question

// following code prints out Letters aA bB cC dD eE ....

class UpCase {
public static void main(String args[]) {
 char ch;

 for(int i = 0; i < 10; i++) {
  ch = (char)('a' + i);
  System.out.print(ch);

  ch = (char)((int) ch & 66503);

  System.out.print(ch + " ")
  }
 }
}

Still learning Java but struggling to understand bitwise operations. Both codes work but I don't understand the binary reasons behind these codes. Why is (int) casted back to ch and what is 66503 used for that enables it to print out different letter casings.

//following code displays bits within a byte

class Showbits {
  public static void main(String args[]) {
  int t;
  byte val;

  val = 123;
  for(t = 128; t > 0; t = t/2) {
   if((val & t) != 0) 
    System.out.print("1 ");
    else System.out.print("0 ");
   }

  }
 }
 //output is 0 1 1 1 1 0 1 1

For this code's output what's the step breakdown to achieve it ? If 123 is 01111011 and 128 as well as 64 and 32 is 10000000 shouldnt the output be 00000000 ? As & turns anything with 0 into a 0 ? Really confused.

"128 as well as 64 and 32 is 10000000" Why do you think three different numbers are the same number? — Max
– Max, Commented Jul 9, 2018 at 12:31
Thats what it shows on most online binary converters maybe a few difference in zeros — BradleyPeh
– BradleyPeh, Commented Jul 9, 2018 at 12:42
"maybe a few difference in zeros" lol Tell that to my bank account if you think 100 and 100000 are the same number. — Max
– Max, Commented Jul 9, 2018 at 12:47
Thats why I'm asking as I'm learning and understanding if I could be wrong. Do you go to the doctor and ask him for flu medication but find out you have Cancer instead cause you "thought" the symptoms were similar ? Some stuff could be the same thing but have different meaning, I don't know yet, everyones learning relax pal. — BradleyPeh
– BradleyPeh, Commented Jul 9, 2018 at 13:07

pmcarpan · Accepted Answer · 2018-07-09 13:06:42Z

2

Second piece of code(Showbits):

The code is actually converting decimal to binary. The algorithm uses some bit magic, mainly the AND(&) operator.

Consider the number 123 = 01111011 and 128 = 10000000. When we AND them together, we get 0 or a non-zero number depending whether the 1 in 128 is AND-ed with a 1 or a 0.

  10000000
& 01111011
----------
  00000000

In this case, the answer is a 0 and we have the first bit as 0. Moving forward, we take 64 = 01000000 and, AND it with 123. Notice the shift of the 1 rightwards.

  01000000
& 01111011
----------
  01000000

AND-ing with 123 produces a non-zero number this time, and the second bit is 1. This procedure is repeated.

First piece of code(UpCase):

Here 65503 is the negation of 32.

 32 = 0000 0000 0010 0000
~32 = 1111 1111 1101 1111

Essentially, we subtract a value of 32 from the lowercase letter by AND-ing with the negation of 32. As we know, subtracting 32 from a lowercase ASCII value character converts it to uppercase.

edited Jul 9, 2018 at 13:06

answered Jul 9, 2018 at 12:52

pmcarpan

6606 silver badges13 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

BradleyPeh Over a year ago

Thanks man clear and concise explanation. Finally manage to piece it together

Max · Accepted Answer · 2018-07-09 12:49:45Z

UpCase

The decimal number 66503 represented by a 32 bit signed integer is 00000000 00000001 00000011 11000111 in binary.

The ASCII letter a represented by a 8 bit char is 01100001 in binary (97 in decimal).

Casting the char to a 32 bit signed integer gives 00000000 00000000 00000000 01100001.

&ing the two integers together gives:

00000000 00000000 00000000 01100001
00000000 00000001 00000011 11000111
===================================
00000000 00000000 00000000 01000001

which casted back to char gives 01000001, which is decimal 65, which is the ASCII letter A.

Showbits

No idea why you think that 128, 64 and 32 are all 10000000. They obviously can't be the same number, since they are, well, different numbers. 10000000 is 128 in decimal.

What the for loop does is start at 128 and go through every consecutive next smallest power of 2: 64, 32, 16, 8, 4, 2 and 1.

These are the following binary numbers:

128: 10000000
 64: 01000000
 32: 00100000
 16: 00010000
  8: 00001000
  4: 00000100
  2: 00000010
  1: 00000001

So in each loop it &s the given value together with each of these numbers, printing "0 " when the result is 0, and "1 " otherwise.

Example:

val is 123, which is 01111011.

So the loop will look like this:

128: 10000000 & 01111011 = 00000000 -> prints "0 "
 64: 01000000 & 01111011 = 01000000 -> prints "1 "
 32: 00100000 & 01111011 = 00100000 -> prints "1 "
 16: 00010000 & 01111011 = 00010000 -> prints "1 "
  8: 00001000 & 01111011 = 00001000 -> prints "1 "
  4: 00000100 & 01111011 = 00000000 -> prints "0 "
  2: 00000010 & 01111011 = 00000010 -> prints "1 "
  1: 00000001 & 01111011 = 00000001 -> prints "1 "

Thus the final output is "0 1 1 1 1 0 1 1", which is exactly right.

Collectives™ on Stack Overflow

JAVA Bitwise code purpose , &

2 Answers 2

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related