I/O Streams for Kotlin


I would like to start from thanking all Kotlin creators! :slight_smile:

I have read “Kotlin in Action” book and it best book about programming that I read recently!
Thanks a lot for authors of this book!

Since this summer I become a big fan of Kotlin!
I see no reason continue writing on Java in new projects now (at least in internal projects).

I learning Kotlin in writing code and feel pleasure in comparing with Java and C# (and sure enough C++ :).

I have created I/O library on Kotlin for my personal reasons, but I think it can be useful for other Kotlin users. Especially Kotlin hasn’t own I/O library at moment.

I have published my library named the ‘binary-streams’ on BitBucket and Maven Central.

Summary of the binary-streams:
Author: Alexander Kornilov
Version: 0.1
License: Apache v2.0
Project URL: https://bitbucket.org/akornilov/binary-streams
API documentation: https://akornilov.bitbucket.io/doc/binary-streams
Design document (very light :): https://bitbucket.org/akornilov/binary-streams/downloads/binary-streams.pdf
Gradle dependency on Maven Central: compile ‘org.bitbucket.akornilov.kotlin:binary-streams:0.1’
Maven Central: https://repo.maven.apache.org/maven2/org/bitbucket/akornilov/kotlin/binary-streams/0.1/

Main features:

  • Extended support of data streams with configurable byte-order.
  • The size of an integer in bytes is arbitrary for data streams.
  • Integers with a size larger than 64-bit are supported using the BigInteger .
  • Possibility to choose signed or unsigned representation of an integer.
  • Unsigned integer (64-bits and more) using the BigInteger .
  • Float and Double with specified byte order.
  • Hint about fetch ability.
  • Read or write an arbitrary number of bits from the BitStream .
  • Can seek to a specified bit in the BitStream .
  • Build-in support of string encoding: ASCII, UTF-8, UTF-16LE, UTF-16BE, UTF-32LE, UTF-32BE.
  • Detection and writing BOM for text files.
  • Reading chars as code points at all.
  • Reads all lines from a text file in " .useLines " Kotlin style.
  • String encoding and byte order might be set for all stream or specified in place.
  • Input or output buffering on the fly with a specified buffer size.
  • Stream implementation for random access file with reading and writing buffering.
  • Stream implementation to read or write from kotlin.ByteArray .
  • Adapters for java.io.InputStream and java.io.OutputStream .
  • Helpful tools to make easy work with bits, code-points and other binary operations in StreamUtils.kt .

Classes diagram (from design document):

Code examples (from design document):
// Creates stream over java.io.InputStream with default stream byte order big-endian and default buffer size 4096.
FileInputStream(“file.bin”).toBinaryBufferedStream(byteOrder = ByteOrder.BigEndian).use { stream ->

// Reads byte as unsigned integer

// Reads Double with specified in place byte-order

// Skips ten bytes

// Reads BigInteger with size 10 bytes and unsigned representation
stream.readLong(10, false)

// Can read three bytes?

// Reads UTF-16 string contains 20 code points
stream.readString(StringEncoding.UTF16, 20)


// Creates stream over java.io.OutputStream with native byte order and default string encoding UTF-8
FileOutputStream(“file.bin”).toBinaryStream().use { stream ->

// Writes single byte

// Writes long value using += operator
val longValue = 0xFE30023L
stream += longValue

// Flushes data

// Write code point 65 in UTF32 encoding
stream.writeChar(65, StringEncoding.UTF32)

// Writes BOM in current stream encoding

// Writes line in current stream encoding

// Writes double value


// Creates stream for random access file for read/write and default read buffer 4096:
File(“file.bin”).openBinaryStream(false).use { stream ->

// Try detect BOM
if (stream.tryDetectBom()) {
    // The BOM was detected and default stream encoding and byte order were updated.

// Seeks to last 20 bytes of the file.
stream.position = stream.size - 20L

// Reads Int value from the stream
val intValue: Int = stream.read()

// Writes Int value

// Seeks to begin of the file
stream.position = 0

// Reads signed integer with size 3 bytes.
stream.readInt(3, true)

// Reads all lines to the end of file
stream.forLines {
    for (line in it) {


// Reads all lines from file in UTF-32
FileInputStream(“file_urf32.txt”).toBinaryBufferedStream(encoding = StringEncoding.UTF32).useLines {
for (line in it) {

// Opens BitStream and read/write bits.
BitStream(File(“file.bin”).openBinaryStream(false)).use { stream ->

// Seeks to 99 byte
stream.position = 99

// Seeks to 3rd bit in 99 byte
stream.offset = 3

// Seeks to 451 bit
stream.bitPosition = 451L

// Reads byte

// Read bit

// Read 33 bits as signed integer
stream.readBits(33, true)

// Write bit 1
stream += true

// Write bit 0
stream += false

// Write 4 bits
stream.write(0b1101, 4)

// Read 128 bits to BigInteger as unsigned
stream.readBigInteger(128, false)


// Creates stream over ByteArray
val byteStream = StreamByteArea(ByteArea(16))

// Reads Short

// Seek in stream
byteStream.position = 10