Java число в byte

Java: Convert Int to a Byte

In Java, an int is a 32-bit signed integer, while a byte is a 8-bit signed integer. Converting an int to a byte can be useful in certain situations, such as when working with binary data or when sending data over a network. In this article, we will explore different ways to convert an int to a byte in Java. We will first discuss the traditional method of using type casting and then look at the use of bit shifting / bit masking.

Note that when converting from int to byte, the value of the int will be truncated to fit within the 8-bit range of a byte if the int is larger than that range. This can lead to data loss and should be taken into consideration when using these methods.

Casting Ints to Bytes

One of the simplest ways to convert an int to a byte in Java is to use type casting. Type casting is the process of converting one data type to another. In this case, we are converting an int to a byte. The syntax for type casting is to place the target data type in parentheses before the variable or value that needs to be converted.

For example, the following code converts the int variable myInt to a byte:

int myInt = 128; byte myByte = (byte) myInt; 

In this case, the value of myInt (128) is larger than the maximum value that can be stored in a byte (127), so the value will be truncated to fit in the 8-bit range. The resulting value of myByte will be -128.

Another way to convert int to byte is by using bit shifting and bit masking. Bit shifting is the process of moving the bits of a binary number to the left or right. Bit works by using a binary mask to extract or modify specific bits in a binary number. More specifically, this works by truncating the integer to the size of a byte.

The following code shows how to convert an int to a byte by using bit masking:

int myInt = 128; byte myByte = (byte) (myInt & 0xff); 

Get free courses, guided projects, and more

No spam ever. Unsubscribe anytime. Read our Privacy Policy.

This code first performs a bitwise AND operation between myInt and the hexadecimal value 0xff (which is the equivalent to 255 in decimal). This sets all bits higher than the 8th bit to zero, effectively truncating the value of myInt to fit within the 8-bit range of a byte. Then, the result is casted to the byte type.

This method is a bit more explicit in how the conversion actually happens since you have more control over the truncation.

Using Conversion Helpers

Another way to convert an int to a byte (or vice versa) in Java is by using the Byte and Integer classes. The Byte class, for example, provides a static method called toUnsignedInt that can be used for the conversion, while the Integer class provides a method called byteValue that can be used to convert an int to a byte.

First, let’s see how to convert a byte to an integer, which we can achieve with Byte.toUnsignedInt . Here is an example:

byte myByte = -128; int myInt = Byte.toUnsignedInt(myByte); 

In this case, the value of myByte is -128, which is out of the range of the signed byte, but since the method toUnsignedInt is used, it will convert the byte to an unsigned int and the result will be 128.

Similarly, you can use the Integer class to convert an int to a byte. Here’s an example of using the Integer class and its helper method to convert an int to a byte:

Integer myInt = new Integer(200); byte myByte = myInt.byteValue(); 

The method byteValue() will convert the int to a byte. Similar to type casting, if the int is larger than the range of byte, the int will be truncated to fit within the 8-bit range of a byte.

Using the Integer class can be useful when working with integers and need to convert them to bytes in a more readable way, without the need of type casting or bit manipulation, which can be more prone to issues.

Conclusion

In summary, there are several ways to convert an int to a byte in Java, including using type casting, bit shifting and bit masking, and the Integer class method byteValue() . Each method has its own use cases and it’s important to choose the right one based on the specific requirements of your project. For example, do you need a signed or unsigned conversion? In general, using the Integer class method byteValue() is more readable and less prone to error.

Источник

Приведение примитивных типов. Приведение типа int к типу short и byte

Почему, если привести какие-нибудь значения типа int к типу short или byte , результаты бывают неожиданными? Давайте разбираться!

 int i = 450; byte b = (byte)i; System.out.println(b); 

Неожиданно, но этому есть логическое объяснение, более того, это действие можно сделать собственноручно. Для этого, нам нужно перевести 450 из десятичной системы в двоичную:

 450/2. 0 225/2. 1 112/2. 0 56/2. 0 28/2. 0 14/2. 0 7/2. 1 3/2. 1 1/2. 1 

В правый столбик от числа мы записываем его остаток от деления на 2, а под самим числом пишем результат деления нашего числа на два, если остаток 0. Если остаток 1, то ниже записываем целую часть от деления на два. (Онлайн калькулятор с объяснением вычислений). В итоге, мы получаем, что в двоичной системе счисления 450 = 11100 0010 . Любое число типа int занимает 4 байта или 32 бита, где каждый бит — это 0 или 1. В нашем случае заняты только 9 битов, и в принципе наш int i = 450 в двоичной системе выглядит так:

 0000_0000_0000_0000_0000_0001_1100_0010 

Мы хотим записать нашу переменную в переменную типа byte , но число типа byte занимает 1 байт (следует из названия этого типа) или 8 бит. Поэтому лишние биты слева просто отбрасываются, и в итоге мы получаем:

Диапазон значений типа byte : -128 до 127. Каждое число занимает 8 бит и у каждого числа крайний левый бит — знаковый бит(sign bit). У всех положительных чисел он равен 0, у всех отрицательных он равен 1. Спешить переводить наш результат, полученный выше, в 10-ную систему не нужно, т.к. мы получили дополнительный код искомого числа, а не прямой. Крайний бит слева получился равен 1, следовательно число у нас отрицательное, а у отрицательных чисел прямой и обратный код не совпадает, в отличие от положительных. Если бы знаковый бит был равен 0, то мы могли бы сразу перевести число в десятичную систему счисления и получить: 66. Но знаковый бит отрицательный, поэтому сначала дополнительный код нужно перевести в прямой и добавить к ответу знак минус. Для наглядности и тренировки, сначала попробуем получить дополнительный код какого-нибудь числа, например -15. Для этого в прямом коде его положительного представления (числа 15) нужно поменять все 0 на 1 и наоборот (получить обратный код, также называют инверсный), а затем добавить к результату единицу. В десятичной системе 15 = 0000 1111 ; Обратный код (меняем все 0 на 1 и наоборот) = 1111 0000 ; Дополнительный код(прибавляем единицу):

 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 0 1 

1. Отнимаем единицу и получаем обратный код. Удобно делать так, записать дополнительный код в ответ и смотреть, к чему нужно прибавить единицу, чтобы получить такой дополнительный код. Начинаем с крайнего правого разряда и смотрим: к чему нужно прибавить 1 чтобы получить 0? К 1, получим 10, 0 уходит в ответ, а единичка на следующий разряд. Далее, что нужно прибавить к 0, чтобы получить один. Единицу, но так как мы с предыдущего разряда имеем единичку, то в ответ пишем 0. Далее, чтобы получить 0, что нужно прибавить к 0? Конечно, 0. Так ещё 4 раза. И остались последние 2 разряда, где к 0 надо что-то прибавить, чтобы получить 1. Конечно, в обоих случаях нужно прибавить 1. Итого:

 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 

 int i = 10_000_000; short s = (short)i; System.out.println(s); // -27008 

1. 10.000.000 в 10-ной системе счисления = 0000 0000 1001 1000 1001 0110 1000 0000 в 2-ной. В Java число типа int занимает 4 байта, а short — 2 байта, или 16 бит, поэтому отсекаем слева до 16 цифр: 1001 0110 1000 0000 . Крайний левый бит(старший бит, он же знаковый бит) получился равен 1. Значит перед нами дополнительный код отрицательного числа, поэтому переходим к следующему пункту.
2. Переводим в обратный код:

 1 0 0 1 0 1 1 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 1 1 0 1 0 0 0 0 0 0 0 

Обратный код: 1001 0110 0111 1111 ;

Инвертируем и получаем прямой код: 0110 1001 1000 0000 .

Переводим в двоичную систему счисления и получаем положительное представление нашего числа: 1∙2^14+1∙2^13+1∙2^11+1∙2^8+1∙2^7 = 16384+8192+2048+256+128 = 27008.

Добавляем минус и получаем ответ: -27008

Ссылка на онлайн-калькулятор прямого, обратного и дополнительного кода. Также на этом сайте под калькулятором есть немного теории об обратном и дополнительном коде.

Источник

Convert Int to Byte in Java

1. Int to Byte Conversion in Java
2. Int to Byte Conversion and Vice Versa in Java
3. Int to Byte Unsigned Conversion in Java
4. Int to Byte Conversion and Vice Versa Using Java 8
5. Int to Byte Using byteValue() Method in Java

This tutorial introduces how to convert int to the byte in Java.

In Java, int and byte both are primitive types and used to store numeric values. Both are used to store signed, and unsigned values but have different storage ranges. The byte range is -128 to 127 and the int range is -2,147,483,648 to 2,147,483,647 . So, clearly, we can see that int can store a large value than byte type.

While converting int to byte, some data gets lost due to memory. Let’s see some examples.

Int to Byte Conversion in Java

In this example, we convert int to byte by casting and see if the int value exceeds out of byte’s range. If it does, then it’s converted into a negative value. It means if a value is larger than the byte range, then it gets converted to negative. So, when we convert a large value to byte type, we get a different result than int type.

public class SimpleTesting  public static void main(String[] args)  int a = 127; // byte max positive range  System.out.println("int value = "+a);  byte b = (byte) a;  System.out.println("byte value = "+b);  a = 130; // Out of positive byte range  System.out.println("int value = "+a);  b = (byte) a;  System.out.println("byte value = "+b);  > > 

int value = 127 byte value = 127 int value = 130 byte value = -126 

Int to Byte Conversion and Vice Versa in Java

To convert an int type to a byte type, we need to use explicit typecasting. However, to convert the byte to int, we don’t need any explicit casting. Java does this implicitly. See the example below.

public class SimpleTesting  public static void main(String[] args)  int a = 230;  System.out.println("int value = "+a);  byte b = (byte) a;  System.out.println("byte value = "+b);  a = b;  System.out.println("int value = "+a);  > > 

int value = 230 byte value = -26 int value = -26 

Int to Byte Unsigned Conversion in Java

We did sign conversion in all the above examples, but if you want unsigned conversion, then use the code below. Here, we used the & 0xFF code, along with the int value, to get an unsigned conversion. See the example below.

public class SimpleTesting  public static void main(String[] args)  int a = 230;  System.out.println("int value = "+a);  byte b = (byte) a;  System.out.println("byte value = "+b);  a = b & 0xFF;  System.out.println("int value = "+a);  > > 

int value = 230 byte value = -26 int value = 230 

Int to Byte Conversion and Vice Versa Using Java 8

If you are working with Java 8, or a higher version, then use the toUnsignedInt() method of the Byte class to get an unsigned conversion. See the example below.

public class SimpleTesting  public static void main(String[] args)  int a = 230;  System.out.println("int value = "+a);  byte b = (byte) a;  System.out.println("byte value = "+b);  a = Byte.toUnsignedInt(b);  System.out.println("int value = "+a);  > > 

int value = 230 byte value = -26 int value = 230 

Int to Byte Using byteValue() Method in Java

We can also use the byteValue() method of the Integer class to get the byte value after conversion. This method returns a signed value. So, use it only if you want to get a signed result. See the example below.

public class SimpleTesting  public static void main(String[] args)  int a = 230;  System.out.println("int value = "+a);  Integer i = a;  byte b = i.byteValue();  System.out.println("byte value = "+b);  > > 

int value = 230 byte value = -26 

Related Article — Java Int

Related Article — Java Byte

Источник