Use Cases: Images, Tables, and Buffers

Arrays are not just abstract collections in textbook algorithms; they form the operational foundation of multimedia processing, network communication, and operating system kernels.

1. Bitmaps and Digital Image Representation

Every digital image displayed on an Android screen is fundamentally a multidimensional or flattened 1D array of pixel color data.

ARGB_8888 Format

In Android's standard Bitmap.Config.ARGB_8888:

• Each pixel requires 4 bytes: Alpha (1B), Red (1B), Green (1B), Blue (1B).
• A 1080p screen (1920 × 1080 pixels) consists of:

  1920 × 1080 × 4 bytes = 8,294,400 bytes ≈ 8.29 MB

Copy code// Accessing pixel color at (x, y) in a 1D pixel buffer
fun getPixel(pixels: IntArray, width: Int, x: Int, y: Int): Int {
    val index = (y * width) + x
    return pixels[index]
}

Image filters (blur, grayscale, brightness) are simply loop operations modifying this contiguous array.

2. Audio Processing and PCM Buffers

Digital audio is produced by capturing sound wave amplitudes at regular intervals (e.g., 44.1 kHz = 44,100 samples per second).

Each sample is stored as a 16-bit signed integer (Short) or 32-bit float in a contiguous audio buffer:

Copy code// Stereo audio buffer: Left and Right channels interleaved
// [L0, R0, L1, R1, L2, R2, ...]
val audioBuffer = ShortArray(1024)

// Modifying amplitude (volume control)
fun adjustVolume(buffer: ShortArray, factor: Float) {
    for (i in buffer.indices) {
        buffer[i] = (buffer[i] * factor).toInt().coerceIn(-32768, 32767).toShort()
    }
}

Because audio hardware requires continuous, uninterrupted sample streaming to prevent audible clicks or pops, contiguous arrays with direct DMA (Direct Memory Access) are mandatory.

3. Network and I/O Byte Buffers

When downloading data over HTTP/TCP via OkHttp or reading files from disk, data arrives in chunks of raw bytes:

Copy codeval buffer = ByteArray(4096) // 4KB read buffer
var bytesRead: Int
while (inputStream.read(buffer).also { bytesRead = it } != -1) {
    outputStream.write(buffer, 0, bytesRead)
}

Using fixed arrays prevents allocating new heap objects for every network packet, keeping garbage collection pressure to a minimum.

Summary