美文网首页
kotlin中ByteArray与基本类型的转换工具(位运算)

kotlin中ByteArray与基本类型的转换工具(位运算)

作者: swallowsonny | 来源:发表于2019-07-17 10:41 被阅读0次

安卓与硬件通讯过程中(例如：蓝牙，串口等)，经常会遇到ByteArray的解析，故而依据node.js中Buffer的API编写了ByteArray扩展工具类，解决ByteArray与基本类型转换之间的符号及大小端问题，简单高效。
github地址：https://github.com/swallowsonny/ConvertExt

项目引入

implementation 'com.swallowsonny:convert-ext:1.0.4'

主要功能

  • ByteArray与十六进制字符串，ASCII字符串的相互转换
  • ByteArray与浮点数的相互转换
  • ByteArray与整型的相互转换
  • ByteArray与时间的相互转换
  • ByteArray读取、替换、插入指定的ByteArray

基本使用

与Node.js中Buffer的读写API几乎完全一致。

byteArray.toHexString([hasSpace])

  • hasSpace Boolean 字节间是否需要空格隔开。默认值: true。
  • 返回: String
    将字节数组转换为十六进制字符串。
val ba = byteArrayOf(1, 2, 3, 4)
println(ba.toHexString())         // 01 02 03 04
println(ba.toHexString(false))    // 01020304

byteArray.toAsciiString([hasSpace])

  • hasSpace Boolean 字节间是否需要空格隔开。默认值: false。
  • 返回: String
    将字节数组转换为ASCII字符串。
val ba = byteArrayOf(0x49 ,0x20 ,0x4C ,0x6F ,0x76 ,0x65 ,0x20 ,0x51 ,0x4D ,0x54)
println(ba.toAsciiString()) // I Love QMT

hexString.hex2ByteArray()

  • 返回: ByteArray
    将16进制字符串转换为字节数组，自动去除空格
val str = "01 02 03 04"
val str1 = "01020304"
println(str.hex2ByteArray())    // byteArrayOf(1, 2, 3, 4)
println(str1.hex2ByteArray())   // byteArrayOf(1, 2, 3, 4)

asciiString.ascii2ByteArray([hasSpace])

  • hasSpace Boolean 是否需要移除空格。默认值: false。
  • 返回: String
    将ASCII字符串转换为字节数组ByteArray 
val str = "I Love QMT"
println(str.ascii2ByteArray().toHexString())    // 49 4C 6F 76 65 51 4D 54
println(str.ascii2ByteArray().toAsciiString())  // ILoveQMT
println(str.ascii2ByteArray(true).toHexString()) // 49 20 4C 6F 76 65 20 51 4D 54
println(str.ascii2ByteArray(true).toAsciiString())  // I Love QMT

byteArray.readFloatBE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: float
    从指定 offset 处的 byteArray 读取 32 位大端序浮点数。
val str = "I Love QMT"
val ba = byteArrayOf(1, 2, 3, 4)
println(ba.readFloatBE(0)) // 2.3879393E-38

byteArray.readFloatLE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: float
    从指定 offset 处的 buf 读取 32 位小端序浮点数。
val ba = byteArrayOf(1, 2, 3, 4)
println(ba.readFloatLE(0)) // 1.5399896E-36

byteArray.readInt8([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 1。 默认值: 0。
  • 返回: 有符号的 int
    从指定 offset 处的byteArray读取有符号的 8 位整数。
val ba = byteArrayOf(-1, 5)
println(ba.readInt8(0)) // 打印-1
println(ba.readInt8(1)) // 打印5
println(ba.readInt8(2)) // 抛异常

byteArray.readUInt8([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 1。 默认值: 0。
  • 返回: 无符号的 int
    从指定 offset 处的 byteArray 读取无符号 8 位整数。
val ba = byteArrayOf(1, -2)
println(ba.readUInt8(0)) // 打印1
println(ba.readUInt8(1)) // 打印254
println(ba.readInt8(2)) // 抛异常

byteArray.readInt16BE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 2。 默认值: 0。
  • 返回: int
    从指定的 offset 处的 byteArray 读取有符号的大端序 16 位整数。
val ba = byteArrayOf(0, 5)
println(ba.readInt16BE()) // 打印5
val ba1 = byteArrayOf(1, 0, 5)
println(ba1.readInt16BE(1)) // 打印5

byteArray.readUInt16BE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 2。 默认值: 0。
  • 返回: int
    从指定的 offset 处的 byteArray 读取无符号的大端序 16 位整数。
val ba = byteArrayOf(0x12, 0x34, 0x56)
println(ba.readUInt16BE(0)) // 打印4660  ==> 0x1234
println(ba.readUInt16BE(1)) // 打印13398 ==> 0x3456

byteArray.readInt16LE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 2。 默认值: 0。
  • 返回: int
    从指定的 offset 处的 byteArray 读取有符号的小端序 16 位整数。
val ba = byteArrayOf(0x12, 0x34, 0x56)
println(ba.readInt16LE(0)) // 打印13330 ==> 0x3412
println(ba.readInt16LE(0).toString(16)) // 打印3412
println(ba.readInt16LE(1)) // 打印22068 ==> 0x5634
println(ba.readInt16LE(1).toString(16)) // 打印5634

byteArray.readUInt16LE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 2。 默认值: 0。
  • 返回: int
    从指定的 offset 处的 byteArray 读取无符号的小端序 16 位整数。
val ba = byteArrayOf(0x12, 0x34, 0x56)
println(ba.readUInt16LE(0)) //  打印13330 ==> 0x3412
println(ba.readUInt16LE(0).toString(16)) // 打印3412
println(ba.readUInt16LE(1)) // 打印22068 ==> 0x5634
println(ba.readUInt16LE(1).toString(16)) // 打印5634

byteArray.readInt32BE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: int
    从指定的 offset 处的 byteArray 读取有符号的大端序 32 位整数。
val ba = byteArrayOf(0x12, 0x34, 0x56, 0x78)
println(ba.readInt32BE(0)) // 打印305419896 ==> 0x12345678
println(ba.readInt32BE(0).toString(16)) // 打印12345678

byteArray.readUInt32BE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: int
    从指定的 offset 处的 byteArray 读取无符号的大端序 32 位整数。
val ba = byteArrayOf(0x12, 0x34, 0x56, 0x78)
println(ba.readUInt32BE(0)) // 打印305419896 ==> 0x12345678
println(ba.readUInt32BE(0).toString(16)) // 打印12345678

byteArray.readInt32LE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: int
    从指定的 offset 处的 byteArray 读取有符号的小端序 32 位整数。
val ba = byteArrayOf(0x12, 0x34, 0x56, 0x78)
println(ba.readInt32LE(0)) // 打印2018915346 ==> 0x78563412
println(ba.readInt32LE(0).toString(16)) // 打印78563412

byteArray.readUInt32LE([offset])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: int
    从指定的 offset 处的 byteArray 读取无符号的小端序 32 位整数。
val ba = byteArrayOf(0x12, 0x34, 0x56, 0x78)
println(ba.readUInt32LE(0)) // 打印2018915346 ==> 0x78563412
println(ba.readUInt32LE(0).toString(16)) // 打印78563412

byteArray.readTimeBE([offset[, pattern]])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • pattern String 转换为时间的格式。默认值：yyyy-MM-dd HH:mm:ss
  • 返回: String
    从指定的 offset 处的 byteArray 读取4字节的大端序时间戳根据规则转换为时间字符串。
val ba = byteArrayOf(0x61, 0x9B.toByte(), 0xBE.toByte(), 0x80.toByte())
println(ba.readTimeBE()) // 打印2021-11-23 00:00:00
println(ba.readTimeBE(0, "yyyy-MM-dd")) // 打印2021-11-23

byteArray.readTimeLE([offset[, pattern]])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • pattern String 转换为时间的格式。默认值：yyyy-MM-dd HH:mm:ss
  • 返回: String
    从指定的 offset 处的 byteArray 读取4字节的小端序时间戳根据规则转换为时间字符串。
val ba = byteArrayOf(0x80.toByte(), 0xBE.toByte(), 0x9B.toByte(), 0x61)
println(ba.readTimeLE()) // 打印2021-11-23 00:00:00
println(ba.readTimeLE(0, "yyyy-MM-dd")) // 打印2021-11-23

byteArray.readStringBE(offset, byteLength[, encoding[, hasSpace]])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size。 默认值: 0。
  • byteLength int 字符串字节长度。
  • encoding String hex / ascii。默认值：hex。
  • hasSpace Boolean 是否有空格。默认值：false。
  • 返回: String
    从指定的 offset 处的 byteArray 读取byteLength长度的字节根据编码转化为大端序的字符串。
val ba = ByteArray(10)
ba.writeStringBE("I Love QMT", 0, "ascii")
println(ba.toHexString()) // 49 20 4C 6F 76 65 20 51 4D 54
println(ba.readStringBE(0, 10, "ascii")) // I Love QMT
println(ba.readStringBE(0, 10, "hex")) // 49 20 4C 6F 76 65 20 51 4D 54

byteArray.readStringLE(offset, byteLength[, encoding[, hasSpace]])

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size。 默认值: 0。
  • byteLength int 字符串字节长度。
  • encoding String hex / ascii。默认值：hex。
  • hasSpace Boolean 是否有空格。默认值：false。
  • 返回: String
    从指定的 offset 处的 byteArray 读取byteLength长度的字节根据编码转化为小端序的字符串。
val ba = ByteArray(10)
ba.writeStringLE("I Love QMT", 0, "ascii")
println(ba.toHexString()) // 54 4D 51 20 65 76 6F 4C 20 49
println(ba.readStringLE(1, 10, "ascii")) // I Love QMT
println(ba.readStringLE(1, 10, "hex")) // 54 4D 51 20 65 76 6F 4C 20 49

byteArray.readByteArrayBE(offset, byteLength)

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size。 默认值: 0。
  • byteLength int 需要读取的字节长度
  • 返回: ByteArray
    从指定的 offset 处的 byteArray 读取byteLength长度的大端序字节。
val ba = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09)
val ba1 = ba.readByteArrayBE(0, 2)
val ba2 = ba.readByteArrayBE(0, 9)
val ba3 = ba.readByteArrayBE(2, 10)
println(ba1.toHexString()) // 01 02
println(ba2.toHexString()) // 01 02 03 04 05 06 07 08 09
println(ba3.toHexString()) // 03 04 05 06 07 08 09

byteArray.readByteArrayLE(offset, byteLength)

  • offset int 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size。 默认值: 0。
  • byteLength int 需要读取的字节长度
  • 返回: ByteArray
    从指定的 offset 处的 byteArray 读取byteLength长度的小端序字节。
val ba = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09)
val ba1 = ba.readByteArrayLE(0, 2)
val ba2 = ba.readByteArrayLE(0, 9)
val ba3 = ba.readByteArrayLE(2, 10)
println(ba1.toHexString()) // 02 01
println(ba2.toHexString()) // 09 08 07 06 05 04 03 02 01
println(ba3.toHexString()) // 09 08 07 06 05 04 03

byteArray.writeStringBE(str[, offset[, encoding]])

  • str String 需要写入的字符串
  • offset int 开始读取之前要跳过的字节数。 默认值: 0。
  • encoding String str的编码类型 hex / ascii。默认值：hex。
  • 返回: ByteArray
    将字符串str根据编码encoding大端序写入byteArray指定的offset。
val ba = ByteArray(15)
ba.writeStringBE("01 02 03 04", 0, "hex")
ba.writeStringBE("abcde", 5, "ascii")
println(ba.toHexString()) // 01 02 03 04 00 61 62 63 64 65 00 00 00 00 00

byteArray.writeStringLE(str[, offset[, encoding]])

  • str String 需要写入的字符串
  • offset int 开始读取之前要跳过的字节数。 默认值: 0。
  • encoding String str的编码类型 hex / ascii。默认值：hex。
  • 返回: ByteArray
    将字符串str根据编码encoding小端序写入byteArray指定的offset。
val ba = ByteArray(15)
ba.writeStringLE("01 02 03 04", 0, "hex")
ba.writeStringLE("abcde", 5, "ascii")
println(ba.toHexString()) // 04 03 02 01 00 65 64 63 62 61 00 00 00 00 00

byteArray.writeStringBE(str, offset, length[, encoding])

  • str String 需要写入的字符串
  • offset int 开始读取之前要跳过的字节数。 默认值: 0。
  • length int 要写入字符串的长度。
  • encoding String str的编码类型 hex / ascii。默认值：hex。
  • 返回: ByteArray
    将字符串str根据长度length与编码encoding大端序写入byteArray指定的offset。
val ba = ByteArray(15)
ba.writeStringBE("01 02 03 04", 0, 2)
ba.writeStringBE("abcde", 5, 3, "ascii")
println(ba.toHexString()) // 01 02 00 00 00 61 62 63 00 00 00 00 00 00 00

byteArray.writeStringLE(str, offset, length[, encoding])

  • str String 需要写入的字符串
  • offset int 开始读取之前要跳过的字节数。 默认值: 0。
  • length int 要写入字符串的长度。
  • encoding String str的编码类型 hex / ascii。默认值：hex。
  • 返回: ByteArray
    将字符串str根据长度length与编码encoding小端序写入byteArray指定的offset。
val ba = ByteArray(15)
ba.writeStringLE("01 02 03 04", 0, 2)
ba.writeStringLE("abcde", 5, 3, "ascii")
println(ba.toHexString()) // 04 03 00 00 00 65 64 63 00 00 00 00 00 00 00

byteArray.writeFloatBE(value[, offset])

  • value int 要写入 byteArray 的浮点数。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: ByteArray
    将 value按大端序写入 byteArray 中指定的 offset。
val ba = ByteArray(15)
ba.writeFloatBE(3.1415926f)
println(ba.toHexString()) // 40 49 0F DA 00 00 00 00 00 00 00 00 00 00 00
println(ba.readFloatBE()) // 3.1415925

byteArray.writeFloatLE(value[, offset])

  • value int 要写入 byteArray 的浮点数。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: ByteArray
    将 value按小端序写入 byteArray 中指定的 offset。
val ba = ByteArray(15)
ba.writeFloatLE(3.1415926f)
println(ba.toHexString()) // DA 0F 49 40 00 00 00 00 00 00 00 00 00 00 00
println(ba.readFloatLE()) // 3.1415925

byteArray.writeInt8(value[, offset])

  • value int 要写入 byteArray 的整数。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 1。 默认值: 0。
  • 返回: ByteArray
    将 value 写入 byteArray 中指定的 offset。 value 必须是有效的有符号 8 位整数。
val ba = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09)
println(ba.writeInt8(10).toHexString())     // 0A 02 03 04 05 06 07 08 09
println(ba.writeInt8(11, 1).toHexString())  // 0A 0B 03 04 05 06 07 08 09
println(ba.writeInt8(11, 11).toHexString()) // The value of "offset" is out of range. It must be >= 0 and <= 8. Received 11

byteArray.writeInt16BE(value[, offset])

  • value int 要写入 byteArray 的整数。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 2。 默认值: 0。
  • 返回: ByteArray
    将 value 作为大端序写入 byteArray 中指定的 offset。
val ba = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09)
println(ba.writeInt16BE(10).toHexString())      // 00 0A 03 04 05 06 07 08 09
println(ba.writeInt16BE(11, 3).toHexString())   // 00 0A 03 00 0B 06 07 08 09

byteArray.writeInt16LE(value[, offset])

  • value int 要写入 byteArray 的整数。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 2。 默认值: 0。
  • 返回: ByteArray
    将 value 作为小端序写入 byteArray 中指定的 offset。
val ba = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09)
println(ba.writeInt16LE(10).toHexString())      // 0A 00 03 04 05 06 07 08 09
println(ba.writeInt16LE(11, 3).toHexString())   // 0A 00 03 0B 00 06 07 08 09

byteArray.writeInt32BE(value[, offset])

  • value int 要写入 byteArray 的整数。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: ByteArray
    将 value 作为大端序写入 byteArray 中指定的 offset。
val ba = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09)
println(ba.writeInt32BE(10).toHexString())      // 00 00 00 0A 05 06 07 08 09
println(ba.writeInt32BE(11, 4).toHexString())   // 00 00 00 0A 00 00 00 0B 09

byteArray.writeInt32LE(value[, offset])

  • value int 要写入 byteArray 的整数。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • 返回: ByteArray
    将 value 作为小端序写入 byteArray 中指定的 offset。
val ba = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09)
println(ba.writeInt32LE(10).toHexString())      // 0A 00 00 00 05 06 07 08 09
println(ba.writeInt32LE(11, 4).toHexString())   // 0A 00 00 00 0B 00 00 00 09

byteArray.writeTimeBE(time[, offset[, pattern]])

  • time String 要写入 byteArray 的时间字符串。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • pattern String 时间格式。默认值：yyyy-MM-dd HH:mm:ss
  • 返回: ByteArray
    将 time 作为大端序写入 byteArray 中指定的 offset，占用四个字节。
val ba = ByteArray(15)
ba.writeTimeBE("2021-11-23 14:20:52")
println(ba.toHexString())   // 61 9C 88 44 00 00 00 00 00 00 00 00 00 00 00
println(ba.readTimeBE())    // 2021-11-23 14:20:52

byteArray.writeTimeLE(time[, offset[, pattern]])

  • time String 要写入 byteArray 的时间字符串。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - 4。 默认值: 0。
  • pattern String 时间格式。默认值：yyyy-MM-dd HH:mm:ss
  • 返回: ByteArray
    将 time 作为小端序写入 byteArray 中指定的 offset，占用四个字节。
val ba = ByteArray(15)
ba.writeTimeLE("2021-11-23 14:20:52")
println(ba.toHexString())   // 44 88 9C 61 00 00 00 00 00 00 00 00 00 00 00
println(ba.readTimeLE())    // 2021-11-23 14:20:52

byteArray.writeByteArrayBE(byteArray[, offset[, length]])

  • byteArray ByteArray 要写入 byteArray 的字节数组。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - length。 默认值: 0。
  • length int 要写入字节数组的长度。默认值：byteArray.size。
  • 返回: ByteArray
    将 byteArray 根据指定的长度截取作为大端序写入 byteArray 中指定的 offset。
val ba = ByteArray(15)
ba.writeByteArrayBE(byteArrayOf(0x01, 0x02, 0x03, 0x04))
println(ba.toHexString()) // 01 02 03 04 00 00 00 00 00 00 00 00 00 00 00

ba.writeByteArrayBE(byteArrayOf(0x05, 0x06, 0x07, 0x08), 4, 2)
println(ba.toHexString()) // 01 02 03 04 05 06 00 00 00 00 00 00 00 00 00

byteArray.writeByteArrayLE(byteArray[, offset[, length]])

  • byteArray ByteArray 要写入 byteArray 的字节数组。
  • offset int开始写入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - length。 默认值: 0。
  • length int 要写入字节数组的长度。默认值：byteArray.size。
  • 返回: ByteArray
    将 byteArray 根据指定的长度截取作为小端序写入 byteArray 中指定的 offset。
val ba = ByteArray(15)
ba.writeByteArrayLE(byteArrayOf(0x01, 0x02, 0x03, 0x04))
println(ba.toHexString()) // 04 03 02 01 00 00 00 00 00 00 00 00 00 00 00

ba.writeByteArrayLE(byteArrayOf(0x05, 0x06, 0x07, 0x08), 4, 2)
println(ba.toHexString()) // 01 02 03 04 05 06 00 00 00 00 00 00 00 00 00

byteArray.insertByteArrayBE(insertArray[, origrinalIndex[, insertArrayOffset[, insertArrayLength]]])

  • insertArray ByteArray 要插入 byteArray 的字节数组。
  • origrinalIndex int开始插入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - length。 默认值: 0。
  • insertArrayOffset int 要插入字节数组跳过的字节数。
  • insertArrayLength int 要插入字节数组的长度。默认值：insertArray.size - insertArrayOffset。
  • 返回: ByteArray
    将 insertArray 根据指定的索引insertArrayOffset与长度insertArrayLength截取作为大端序插入 byteArray 中指定的 origrinalIndex。返回插入后的字节数组。
val ba = ByteArray(15)
val insertArray = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06)
val result = ba.insertByteArrayBE(insertArray, 1, 1)
println(result.toHexString()) // 00 02 03 04 05 06 00 00 00 00 00 00 00 00 00 00 00 00 00 00

byteArray.insertByteArrayLE(insertArray[, origrinalIndex[, insertArrayOffset[, insertArrayLength]]])

  • insertArray ByteArray 要插入 byteArray 的字节数组。
  • origrinalIndex int开始插入之前要跳过的字节数。 必须满足 0 <= offset <= byteArray.size - length。 默认值: 0。
  • insertArrayOffset int 要插入字节数组跳过的字节数。
  • insertArrayLength int 要插入字节数组的长度。默认值：insertArray.size - insertArrayOffset。
  • 返回: ByteArray
    将 insertArray 根据指定的索引insertArrayOffset与长度insertArrayLength截取作为小端序插入 byteArray 中指定的 origrinalIndex。返回插入后的字节数组。
val ba = ByteArray(15)
val insertArray = byteArrayOf(0x01, 0x02, 0x03, 0x04, 0x05, 0x06)
val result = ba.insertByteArrayLE(insertArray, 1, 1)
println(result.toHexString()) // 00 05 04 03 02 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00

相关文章

  • kotlin中ByteArray与基本类型的转换工具(位运算)

    安卓与硬件通讯过程中(例如：蓝牙，串口等)，经常会遇到ByteArray的解析，故而依据node.js中Buffe...

  • 笔记整理（Swift基本语法一）

    类型推导 基本运算 相通类型之间才能进行运算 Swift 中没有隐私转换 Int 类型转换成Double类型，使用...

  • Kotlin学习笔记——基础语法篇之数据类型

    一、基本数据类型 Kotlin的数据类型 声明变量 Kotlin的类型转换 强制类型转换 数据转换函数 在kotl...

  • kotlin学习笔记_3

    kotlin的Number类型没有char 但是转换的时候有tochar() 函数 完整的位运算操作 (只能对 I...

  • Javascript面试题

    1 引用类型和基本类型 1.1 原始对象 1.2 引用类型 2 类型转换 运算过程的转换原则： string与nu...

  • C概念及循环

    一，类型转换运算 二，位运算 位与：& 位或：| 非：~ 异或：^ 左移：<< 右移：>> 三，赋值操作符 =：在...

  • Kotlin基础之字符串

    字符串与其他基本类型的转换 注意：Kotlin中字符串是基本数据类型；在Java中是引用类型的，Java中引用类型...

  • 14重载运算与类型转换

    14重载运算与类型转换 14.1基本概念 Operator重载的运算符包含返回类型、参数列表以及函数体。 左侧运算...

  • Java数据类型转换

    Java的类型转换可分为基本类型和引用类型的数据转换。 基本类型的转换 类型转换主要在赋值、方法调用、算术运算三种...

  • Kotlin基础学习篇：各类关键字学习

    1、Kotlin 继承open关键字 2、Kotlin 类型转换 3、Kotlin智能转换 4、Kotlin 中A...

网友评论

      本文标题：kotlin中ByteArray与基本类型的转换工具(位运算)

      本文链接：https://www.haomeiwen.com/subject/hcfokctx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|kotlin中ByteArray与基本类型的转换工具(位运算)|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！