CodeGym/Help with Java Tasks/Where to get a deeper understanding of what is done here?...

Level 24

Amsterdam

01.02.2021
869views
13comments

Where to get a deeper understanding of what is done here?

Question about the task

Resolved

Basically 2 questions: 1) I do not understand how we compare two byte[]. What does it return. I'm looking for a detailed description of the calculation 2) To display the byte[] as a binary String there are parts in the code that I can't find the meaning of. What exactly are we doing in the print()?? As you can tell I just copied and pasted the answer without any understanding, obviously ;-).

package com.codegym.task.task21.task2101;

/*
Determine the network address

*/

public class Solution {
    public static void main(String[] args) {
        byte[] ip = new byte[]{(byte) 192, (byte) 168, 1, 2};
        byte[] mask = new byte[]{(byte) 255, (byte) 255, (byte) 254, 0};
        byte[] netAddress = getNetAddress(ip, mask);
        print(ip);          //11000000 10101000 00000001 00000010
        print(mask);        //11111111 11111111 11111110 00000000
        print(netAddress);  //11000000 10101000 00000000 00000000
    }

    public static byte[] getNetAddress(byte[] ip, byte[] mask) {
        byte[] netAddress = new byte[4];
//how does this work?
        //we compare each bit of the first byte[] with the first bit of the second byte[]
        //what does this return?
        //clueless as what we are comparing
        for (int i = 0; i < netAddress.length; i++) {
            netAddress[i] = (byte) (ip[i] & mask[i]);
        }

        return netAddress;
    }


    public static void print(byte[] bytes) {
        for(byte bit : bytes) {
            //replace(' ', '0') this add zero's if the binaryString is shorter than 8? not sure
            //what does this do? (bit & 0xFF)
            String bitResult = String.format("%8s", Integer.toBinaryString(bit & 0xFF)).replace(' ', '0');
            //we convert the bit into a string of chars of 1 or 0??
            System.out.print(bitResult + " ");
        }
        System.out.println();
    }
}

Comments (13)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

1 February 2021, 14:54

For the getNetAddress() method: bitwise operators In the print() method: Without copying the code from another place, you can figure out how to get the correct answer - Print out the results of a few things:

// result 11000000
System.out.println("binary of int 192: " + Integer.toBinaryString(192));
// result 11111111111111111111111111000000
System.out.println("binary of byte 192: " + Integer.toBinaryString((byte)192));

You can see there is quite a difference in the binary versions of 192 as an int and as a byte. This is because a byte can only store 255 numbers between the range of -128 to 127, of which 192 is outside of that range. When you convert a large number type into a smaller number type, the bytes flip. When you stay within the amount (192 is within 255), when the flip occurs it follows the rule of 2's complement, where the bytes flip and you add one. It flips to: 10111111 (this is the opposite of int 192 of 11000000) Then you add 1 to get to: 1100000 Which is -64, and the binary of -64 as an integer is: 11111111111111111111111111000000, which is the result of Integer.toBinaryString((byte) 192):

System.out.println("binary of byte 192: " + Integer.toBinaryString((byte)192));
System.out.println("binary of int -64: " + Integer.toBinaryString(-64));

If you notice, the lower level bits (the first 8) of -64 and 192 are exactly the same. Now you have a problem with all those leading 1's.

Guadalupe Gagnon

Level 37 , Tampa, United States

1 February 2021, 15:10

This is were 0xFF comes in. If you output the binary string of that you will find it to be "11111111", which is equal to 255. Here is how I figured that out:

// result "11111111"
System.out.println("binary of int 0xFF: " + Integer.toBinaryString(0xFF));
int max1 = Integer.parseInt("11111111",2);
// result 255
System.out.println("getting '11111111' to number: " + max1);

In bytes this is just a series of 8 ones. If you use an AND operator on that and -64:

//11111111111111111111111111000000
//                      & 11111111
//  _____________________________
//000000000000000000000001100000

You can use 0xFF or 255 for the same exact results:
System.out.println("result of AND operation on (byte)192 & 0xFF: "+Integer.toBinaryString((byte)192 & 0xFF));
        System.out.println("result of AND operation on (byte)192 & 255: "+Integer.toBinaryString((byte)192 &255));

The String.format() with "%8s" just outputs whatever result you get to 8 characters long and the replace(' ', '0') fills any blank spaces with 0. This works with all the bytes in the byte[].

Liliane Top Backend Developer at Procura

1 February 2021, 15:11

Hi there, thanks for helping me. I read the article of CodeGym on bitwise but not sure where my thinking goes wrong... In your explanation I get confused by the following: byte can only store 255 numbers between the range of -128 to 127, of which 192 is outside of that range. //this part understood When you convert a large number type into a smaller number type, the bytes flip. //I do not know what you are stating here? Do you mean that if a number is outside the range of -128 to 127 the conversion of that number into binary flips? Meaning the 0 => 1 and 1 => 0? When you stay within the amount (192 is within 255), //how does this work? I understand that the range is only between -128 to 127 when the flip occurs it follows the rule of 2's complement, where the bytes flip and you add one. //does this mean where all the extra '1' are coming from. We flip each bit so if the number contains 8 bits you get an extra 8 '1' ? It flips to://what are we flipping here? Now you really lost me 🤯 I do not know what you are doing here?? 10111111 (this is the opposite of int 192 of 11000000) Then you add 1 to get to: 1100000 Which is -64, and the binary of -64 as an integer is: 11111111111111111111111111000000, which is the result of Integer.toBinaryString((byte) 192):

Liliane Top Backend Developer at Procura

1 February 2021, 15:16

This confused me : We're parsing a string to an int and we get a binary number? Is that because of the 2 as second parameter? So we are not parsing an String to an int but to a byte?

int max1 = Integer.parseInt("11111111",2);

Liliane Top Backend Developer at Procura

1 February 2021, 15:18

I do not understand this part as there are no ' ' empty spaces in the String nor byte so why replace them with a '0'?? The String.format() with "%8s" just outputs whatever result you get to 8 characters long and the replace(' ', '0') fills any blank spaces with 0. This works with all the bytes in the byte[].

Liliane Top Backend Developer at Procura

1 February 2021, 15:21

Also why do we need the '255' or it's equivalent. I feel so clueless. As I read a couple of articles on this subject but I do not get it. I'm not sure what part in my knowledge is lacking to be able to get this...

Guadalupe Gagnon

Level 37 , Tampa, United States

1 February 2021, 15:56

solution

post 1: So byte is only an 8 bit number and int is a 32 bit number. Both of these use the highest most bit (the left most) to signify negative or not where if the bit is 0 then the number is positive and if the bit is 1 then the number is negative. The binary of int 192 is "11000000" (it doesn't show all the leading 0's). When you convert 129 to a byte, which it can not store the full amount, the bytes flip to "10111111" , (and flip does mean 0's become 1 and 1's become 0), where the highest bit (the left most bit) signifies that it is a negative number. Then 1 bit is added to that, so : 10111111 + 1 ------------- 11000000 << Which is binary of -64 post 2: Integer.parseInt("11111111",2) Yes, the second argument (2 in this case) means the String literal of the first argument is in that base. If no second argument is put in then it defaults to the standard base 10 we use. The result is always an int in base 10. So:

// base 16 result: 183717394
System.out.println(Integer.parseInt("AF34E12", 16));
// base 32, result: 576116
System.out.println(Integer.parseInt("HIJK", 32));

post 3: There are no empty spaces in the example of 192 that I give, but what about 1 or 2 or any other lower number:

// result: (7 spaces) 1
System.out.println(String.format("%8s", Integer.toBinaryString(1 & 0xFF)));
// result: (6 spaces) 10
System.out.println(String.format("%8s", Integer.toBinaryString(2 & 0xFF)));

Guadalupe Gagnon

Level 37 , Tampa, United States

1 February 2021, 16:03

solution

post 4: Because the binary of 255 is 8 1's. The AND operator, in booleans, will result in TRUE only if both operands are true, or false otherwise. On bits it works the same exact way in that it will be 1 if both bits are 1 or 0 otherwise. It compares each bit of one operand with the bit in the exact spot of the second operand: ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 & ------------------------- 1 1 0 0 0 0 0 0 Because the bits of lower negative numbers (like those that result in converting an int of 128-255 to a byte) are going to have 20 some odd leading 1's, you need to use the AND operator on a binary of exactly 8 1's to change those extra bits to 0 and get the exact number that you want.

Liliane Top Backend Developer at Procura

1 February 2021, 16:58

I would have given up without you. Thank you for the crystal clear explanation. You are my hero today!🦹‍♀️🙏🙏🙏

Guadalupe Gagnon

Level 37 , Tampa, United States

1 February 2021, 17:10

I suggest playing around with the conversions that I demonstrated here, with your own numbers. Try to predict the results before running the program. It may not be 100% clear today, but it should start to represent some semblance of sanity. Try to figure out what will happen if you convert an int larger than 255 to a byte, say 257. *hint* more than 1 'flip' will occur

// first flip
System.out.println((byte) 127 );
System.out.println((byte) 128 );

// second flip
System.out.println((byte) 255 );
System.out.println((byte) 256 );
System.out.println((byte) 257 );

Liliane Top Backend Developer at Procura

2 February 2021, 10:02

haha that is exactly on my program for today I also reading the chapter on Operators in Thinking of Java by Bruce Eckel. I think that I should pace myself. I have the tendency of going too fast without fully understanding the concept. Thanks again for your suggestions. Very much appreciated!

Andrei

Level 41

9 March 2021, 15:39

💀💀💀💀💀💀💀💀 - i think i need to dedicate a few hours just for this thread, lol

Jurij Thmsn

Level 29 , Flensburg, Germany

10 June 2021, 13:04

I didn't get the solutions I found online either, so I just did this step by step. Probably not efficient, but at least I understood what is done.

System.out.printf("%08d ",Integer.parseInt(Integer.toBinaryString(Byte.toUnsignedInt(b))));