1# int.to_bytes() — Python 3.2+
2number = 1024
3
4# Big-endian (network byte order)
5big = number.to_bytes(4, byteorder='big')
6print(big)    # b'\x00\x00\x04\x00'
7
8# Little-endian (x86 native order)
9little = number.to_bytes(4, byteorder='little')
10print(little) # b'\x00\x04\x00\x00'
11
12# Convert back
13int.from_bytes(big, byteorder='big')      # 1024
14int.from_bytes(little, byteorder='little') # 1024
15
16# Using struct module (C-compatible layout)
17import struct
18
19packed = struct.pack('>I', 1024)  # > = big-endian, I = unsigned 32-bit
20print(packed)  # b'\x00\x00\x04\x00'
21
22unpacked = struct.unpack('>I', packed)[0]  # 1024

1import java.nio.ByteBuffer;
2import java.nio.ByteOrder;
3
4int number = 1024;
5
6// Big-endian (default for ByteBuffer and network protocols)
7byte[] big = ByteBuffer.allocate(4).putInt(number).array();
8// [0, 0, 4, 0]
9
10// Little-endian
11byte[] little = ByteBuffer.allocate(4)
12    .order(ByteOrder.LITTLE_ENDIAN)
13    .putInt(number)
14    .array();
15// [0, 4, 0, 0]
16
17// Convert back
18int fromBig = ByteBuffer.wrap(big).getInt();  // 1024
19int fromLittle = ByteBuffer.wrap(little)
20    .order(ByteOrder.LITTLE_ENDIAN)
21    .getInt();  // 1024
22
23// Manual bit shifting (no ByteBuffer)
24byte[] manual = new byte[] {
25    (byte)(number >> 24),
26    (byte)(number >> 16),
27    (byte)(number >> 8),
28    (byte)number
29};

1int number = 1024;
2
3// BitConverter uses system endianness (usually little-endian on x86)
4byte[] bytes = BitConverter.GetBytes(number);
5// [0, 4, 0, 0] on little-endian systems
6
7// Check system endianness
8Console.WriteLine(BitConverter.IsLittleEndian);  // True on x86
9
10// Convert back
11int result = BitConverter.ToInt32(bytes, 0);  // 1024
12
13// Force big-endian (network byte order)
14byte[] bigEndian = BitConverter.GetBytes(number);
15if (BitConverter.IsLittleEndian)
16    Array.Reverse(bigEndian);
17// [0, 0, 4, 0]
18
19// Using BinaryPrimitives (.NET Core 2.1+) — no allocation
20Span<byte> buffer = stackalloc byte[4];
21BinaryPrimitives.WriteInt32BigEndian(buffer, 1024);
22BinaryPrimitives.WriteInt32LittleEndian(buffer, 1024);
23
24int value = BinaryPrimitives.ReadInt32BigEndian(buffer);

1// Using DataView for explicit endianness control
2const buffer = new ArrayBuffer(4);
3const view = new DataView(buffer);
4
5// Big-endian (default)
6view.setInt32(0, 1024, false);  // false = big-endian
7console.log(new Uint8Array(buffer));  // [0, 0, 4, 0]
8
9// Little-endian
10view.setInt32(0, 1024, true);   // true = little-endian
11console.log(new Uint8Array(buffer));  // [0, 4, 0, 0]
12
13// Convert back
14const big = view.getInt32(0, false);     // 1024
15const little = view.getInt32(0, true);   // 1024
16
17// Node.js Buffer
18const buf = Buffer.alloc(4);
19buf.writeInt32BE(1024, 0);  // Big-endian
20buf.writeInt32LE(1024, 0);  // Little-endian
21
22const value = buf.readInt32BE(0);  // 1024

1#include <stdint.h>
2#include <string.h>
3#include <arpa/inet.h>  // for htonl/ntohl
4
5int32_t number = 1024;
6
7// Method 1: memcpy (preserves native endianness)
8uint8_t bytes[4];
9memcpy(bytes, &number, sizeof(number));
10
11// Method 2: Bit shifting (explicit big-endian)
12bytes[0] = (number >> 24) & 0xFF;
13bytes[1] = (number >> 16) & 0xFF;
14bytes[2] = (number >> 8)  & 0xFF;
15bytes[3] = number & 0xFF;
16
17// Method 3: htonl for network byte order (big-endian)
18uint32_t network_order = htonl((uint32_t)number);
19memcpy(bytes, &network_order, 4);
20
21// Convert back
22int32_t restored = ((int32_t)bytes[0] << 24) |
23                   ((int32_t)bytes[1] << 16) |
24                   ((int32_t)bytes[2] << 8)  |
25                   bytes[3];

1import (
2    "encoding/binary"
3    "fmt"
4)
5
6number := int32(1024)
7buf := make([]byte, 4)
8
9// Big-endian
10binary.BigEndian.PutUint32(buf, uint32(number))
11fmt.Println(buf)  // [0 0 4 0]
12
13// Little-endian
14binary.LittleEndian.PutUint32(buf, uint32(number))
15fmt.Println(buf)  // [0 4 0 0]
16
17// Convert back
18value := binary.BigEndian.Uint32(buf)