Java byte[] returns same string even if byte[] array is changed to add some padding

Question

I am learning to understand the bits/bytes concept for String. I tried to change the byte[] array for given string however I am surprised to see that even when I changed byte [] the string representation is same. Following is my code sample. Can someone help to understand why and also if possible please share tutorial having more insight on byte and Sting relation.

public class HelloWorld{

    //Add padding to input value to 
    public static byte[] addPadding(byte[] inData, int offset, int len) {

        byte[] bp = null;
        int padChars = 8;               // start with max padding value
        int partial = (len + 1) % padChars;     // calculate how many extra bytes exist
        if (partial == 0) padChars = 1;         // if none, set to only pad with length byte
        else padChars = padChars - partial + 1; // calculate padding size to include length

        bp = new byte[len + padChars];
        bp[0] = Byte.parseByte(Integer.toString(padChars));
        System.arraycopy(inData, offset, bp, 1, len);
        return bp;
    }
    //remove padding added while decryption
         public static byte[] removePadding(byte[] inData) {

                byte[] bp = null;
                int dataLength = 0;
                int padLength = 0;
                padLength = inData[0];
                dataLength = inData.length - padLength;
                bp = new byte[dataLength];
                System.arraycopy(inData, 1, bp, 0, dataLength);      
                return bp;
          } 

     public static void main(String []args){

        String inputString = "I like coding :-)";
        byte[] byteArrayOfString = inputString.getBytes();
        System.out.println("Original String: " + new String (byteArrayOfString));
        byteArrayOfString = addPadding(byteArrayOfString, 0, byteArrayOfString.length);
        //Add padding 
        System.out.println("String after adding pad: " + new String (byteArrayOfString));
        //remove padding
        byteArrayOfString = removePadding(byteArrayOfString);
        System.out.println("String after removing pad: " + new String (byteArrayOfString));


     }
}

Following is output when I ran this program:

Original String: I like coding :-)
String after adding pad: I like coding :-)
String after removing pad: I like coding :-)

Surprisingly all output are same. Curious why?

humm, you are right, i added equality check it shows not equal //Check for equality if(inputStringAfterPadding.equals(inputStringAfterRemovePadding)) { System.out.println("String after padding is same as after removing padding XXXX"); } else { System.out.println("String after padding is not same as after removing padding :-):-)"); } — joy
– joy, Commented Jan 26, 2016 at 17:47
how come even after changing the first byte position of string it didn't change the display — joy
– joy, Commented Jan 26, 2016 at 17:48

rgettman · Accepted Answer · 2016-01-26 17:48:23Z

It did print extra characters; you just didn't see them. I added quote characters before and after each string print, and here's my output looks in IntelliJ.

Original String: "I like coding :-)"
String after adding pad: " I like coding :-)      "
String after removing pad: "I like coding :-)"

However, when I ran this code in a terminal window, I got this, like you did:

Original String: "I like coding :-)"
String after adding pad: "I like coding :-)"
String after removing pad: "I like coding :-)"

Also, and importantly, I heard a terminal beep.

The padding is done with the character number 7, a.k.a. \u0007, which is the bell character. IntelliJ apparently just prints a space, but my PuTTY terminal made the beep properly. The trailing spaces appear to be gone as well.

Printing the byte array contents in addPadding before returning it reveals the byte array contents.

System.out.println(Arrays.toString(bp));

This is the output:

[7, 73, 32, 108, 105, 107, 101, 32, 99, 111, 100, 105, 110, 103, 32, 58, 45, 41, 0, 0, 0, 0, 0, 0]

The bell character 7 is first, followed by the characters of the string, followed by null characters 0 (\u0000). IntelliJ must be printing those as spaces also; the PuTTY terminal doesn't print them.

In conclusion, the padding is there; you're just not seeing the characters being printed. Depending on your method of output, you may be hearing one of them.

Andy Turner · Accepted Answer · 2016-01-26 17:46:44Z

They're not the same. The padded string just contains non-printed characters.

    String inputString = "I like coding :-)";
    byte[] byteArrayOfString = inputString.getBytes();
    String original = new String (byteArrayOfString);
    System.out.println("Original String: " + original);
    byteArrayOfString = addPadding(byteArrayOfString, 0, byteArrayOfString.length);
    //Add padding 
    String addPadding = new String (byteArrayOfString);
    System.out.println("String after adding pad: " + addPadding);
    //remove padding
    byteArrayOfString = removePadding(byteArrayOfString);
    String removePadding = new String (byteArrayOfString);
    System.out.println("String after removing pad: " + removePadding);

    System.out.println(Arrays.toString(original.toCharArray()));
    System.out.println(Arrays.toString(addPadding.toCharArray()));
    System.out.println(Arrays.toString(removePadding.toCharArray()));

Prints

Original String: I like coding :-)
String after adding pad: I like coding :-)
String after removing pad: I like coding :-)
[I,  , l, i, k, e,  , c, o, d, i, n, g,  , :, -, )]
[, I,  , l, i, k, e,  , c, o, d, i, n, g,  , :, -, ), , , , , , ]
[I,  , l, i, k, e,  , c, o, d, i, n, g,  , :, -, )]

(See http://ideone.com/vjNWeZ.)

Collectives™ on Stack Overflow

Java byte[] returns same string even if byte[] array is changed to add some padding

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related