Byte

A Byte in Kotlin is an 8-bit signed two’s complement integer. It represents the smallest integer data type available in the language’s standard library, strictly enforcing a value range from -128 (Byte.MIN_VALUE) to 127 (Byte.MAX_VALUE) inclusive.

At the JVM level, a non-nullable Byte compiles directly to the Java primitive byte. If the type is declared as nullable (Byte?) or used as a generic type parameter, Kotlin boxes the value into the java.lang.Byte wrapper class, which incurs a memory allocation overhead.

Instantiation and Syntax

Kotlin does not provide a specific literal suffix for Byte (unlike L for Long). A Byte must be instantiated through explicit type declaration or by invoking the toByte() conversion function on another numeric type.

// Explicit type declaration (compiler infers the literal fits in 8 bits)
val explicitByte: Byte = 127

// Explicit conversion from an Int literal
val convertedByte: Byte = 42.toByte()

// Conversion from Hexadecimal and Binary literals
val hexByte: Byte = 0x7F.toByte()
val binByte: Byte = 0b0111_1111.toByte()

Type Promotion in Arithmetic

Kotlin does not define arithmetic operators that return a Byte. When performing standard arithmetic operations (+, -, *, /, %) on Byte operands, the compiler automatically promotes the values to Int before executing the operation. This prevents silent overflow during intermediate calculations.

To store the result back into a Byte, an explicit downcast via toByte() is mandatory.

val a: Byte = 50
val b: Byte = 50

// The expression (a + b) evaluates to an Int
val sumInt: Int = a + b

// Explicit conversion is required to assign the result to a Byte
val sumByte: Byte = (a + b).toByte()

Bitwise Operations

Kotlin does not support direct bitwise operations (shl, shr, ushr, and, or, xor, inv) on Byte types. To perform bitwise manipulation, the Byte must be explicitly widened to an Int or Long.

val mask: Byte = 0b0000_1111
val flag: Byte = 0b0000_0101

// Compilation error: Unresolved reference: and
// val result = mask and flag 

// Correct approach: Widen to Int first
val bitwiseResult: Int = mask.toInt() and flag.toInt()
val finalByte: Byte = bitwiseResult.toByte()

Arrays

To handle collections of Byte values without the performance penalty of boxing, Kotlin provides the ByteArray class. This maps directly to the Java primitive array byte[]. Using Array<Byte> instead will result in an array of boxed java.lang.Byte objects.

// Unboxed primitive array (JVM: byte[])
val primitiveBytes: ByteArray = byteArrayOf(0x01, 0x02, 0x03)
val initializedBytes = ByteArray(5) { 0 }

// Boxed object array (JVM: Byte[])
val boxedBytes: Array<Byte> = arrayOf(1.toByte(), 2.toByte(), 3.toByte())

Master Kotlin with Deep Grasping Methodology!

Learn More