Lossy conversion from int to byte?

It throws this error message because you are trying to assign a sign value with an internal value byte

. This is a potentially decreasing operation: intuitively, you cannot put all possible values int

into byte

.

The Java language requires you to use translation (byte)

when you assign an int-value to an expression byte

.

There are two places where you do this:

   cryptedByte[i] = (data[i] + 13) % 256;

   decryptedByte[i] = (data[i] * 256) - 13;

      

        
        
        
      

    

In the first case, the value of the expression is in the range 0 to 255 ... but the Java values byte

are in the range -128 to +127.

In the second case, the values ​​of the expression can range from (-128 * 256) - 13

to `(+127 * 256) - 13. This is clearly not appropriate.

But this is actually a moot point. Java does not allow variations of the above code, even if you (a smart person) can prove that the range of the expression will "match" in byte

. The JLS prohibits this. (The Java compiler doesn't have to be a general theorem proof !!)

The only situation where an int-valued expression can be assigned byte

without using the cast type is when the expression is a compile-time constant expression and the actual value of the expression is in the range byte

.

If you are interested, it is stated in JLS 15.2 Assignment Contexts , which says:

Also, if the expression is a constant expression (§15.28) of type byte, short, char, or int:

• A narrowing primitive conversion can be used if the type of the variable is byte, short, or char, and the value of the constant expression is represented in the type of the variable.

(You have to chase what the spec means "constant expression" and "narrowing primitive transformation". I'll leave that for interested people to do for myself.)

then I would add (byte) casting before 13 and 256?

Nope. You need to pass the entire expression; eg.

   cryptedByte[i] = (byte) ((data[i] + 13) % 256);

      

        
        
        
      

    

You have problems here.

cryptedByte[i] = (data[i] + 13) % 256;

      

        
        
        
      

    

and here

decryptedByte[i] = (data[i] * 256) - 13;

      

        
        
        
      

    

256

and 13

are type literals int

. When you perform operations on them and on a type that takes up less memory (in this example byte

), the type is promoted: data[i]

implicitly converted (promoted) to the type int

. Thus, both of these expressions are evaluated before int

. And you know what happens when you convert an int to a byte, right? You may lose data. This is because it is byte

limited to less memory than int

.

You just need to cast when assigning each byte when it is inside a variable, so java can make sure everything is between -127 and 127, which is the ascii range. The following should work:

public class Rot13Crypt extends CryptStream
{
    public Rot13Crypt(StreamPair theStreams)
    {
        super(theStreams);
    }
    protected byte [] cryptData(byte [] data, int len)
    {
        byte [] cryptedByte = new byte[len];
        for(int i = 0; i < len; i++)
        {
            cryptedByte[i] = (byte) (data[i] + 13) % 256;
        }
        return cryptedByte;
    }
    protected byte [] decryptData(byte [] data, int len)
    {
        byte [] decryptedByte = new byte[len];
        for(int i = 0; i < len; i++)
        {
            decryptedByte[i] = (byte) (data[i] * 256) - 13;
        }
        return decryptedByte;
    }

      

        
        
        
      

    

}

A byte is 8 bits in size and 32 bits in size. Thus, some information may be lost when performing this conversion!