华为OD机试真题---TLV解码

题目描述

TLV编码是按 [Tag Length Value] 格式进行编码的，一段码流中的信元用 Tag 标识，Tag 在码流中唯一不重复，Length 表示信元Value的长度，Value 表示信元的值。

码流以某信元的 Tag 开头，Tag 固定占一个字节，Length 固定占两个字节，字节序为小端序。

现给定 TLV 格式编码的码流，以及需要解码的信元 Tag，请输出该信元的 Value。

输入码流的 16 机制字符中，不包括小写字母，且要求输出的 16 进制字符串中也不要包含小写字母；码流字符串的最大长度不超过 50000 个字节。

输入描述

输入的第一行为一个字符串，表示待解码信元的 Tag；

输入的第二行为一个字符串，表示待解码的 16 进制码流，字节之间用空格分隔。

输出描述

输出一个字符串，表示待解码信元以 16 进制表示的 Value。

示例

示例1

输入

java 复制代码

31
32 01 00 AE 90 02 00 01 02 30 03 00 AB 32 31 31 02 00 32 33 33 01 00 CC

输出

java 复制代码

32 33

说明

需要解析的信元的 Tag 是 31，从码流的起始处开始匹配，Tag 为 32 的信元长度为 1 （01 00，小端序表示为 1）；

第二个信元的 Tag 是 90，其长度为 2；

第三个信元的 Tag 是 30，其长度为 3；

第四个信元的 Tag 是 31，其长度为 2（02 00），所以返回长度后面的两个字节即可，即 32 33。

代码实现

java 复制代码

import java.util.Scanner;

public  class TLVDecoder {

    /**
     * 主函数入口
     * 本函数用于解码TLV（Tag-Length-Value）格式的十六进制数据流，以获取特定Tag对应的Value
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 创建Scanner对象以读取命令行输入
        Scanner scanner = new Scanner(System.in);
    
        // 读取待解码信元的Tag
        String tagHex = scanner.nextLine().trim();
        byte targetTag = (byte) Integer.parseInt(tagHex, 16);
    
        // 读取待解码的16进制码流
        String hexStream = scanner.nextLine().trim();
        String[] hexBytes = hexStream.split(" ");
    
        // 将16进制字符串数组转换为字节数组，并解析TLV码流
        byte[] tlvData = new byte[hexBytes.length];
        for (int i = 0; i < hexBytes.length; i++) {
            tlvData[i] = (byte) Integer.parseInt(hexBytes[i], 16);
        }
    
        // 调用解码方法获取Value
        String decodedValue = decodeTLV(tlvData, targetTag);
    
        // 输出结果
        System.out.println(decodedValue);
    
        // 关闭Scanner
        scanner.close();
    }

    /**
     * TLV解码方法
     *
     * @param tlvData TLV编码的字节数组
     * @param targetTag 要查找的Tag
     * @return 对应的Value的16进制字符串（不包括小写字母）
     */
    public static String decodeTLV(byte[] tlvData, byte targetTag) {
        int index = 0;
        while (index + 3 <= tlvData.length) { // 至少要有Tag(1字节) + Length(2字节)
            byte currentTag = tlvData[index];
            if (currentTag == targetTag) {
                // 读取Length字段（小端序）
                int length = tlvData[index + 1] & 0xFF; // 低位字节
                length |= (tlvData[index + 2] & 0xFF) << 8; // 高位字节

                // 读取Value字段
                byte[] value = new byte[length];
                System.arraycopy(tlvData, index + 3, value, 0, length);

                // 将Value转换为16进制字符串（不包括小写字母）
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < value.length; i++) {
                    sb.append(String.format("%02X", value[i]));
                    if (i < value.length - 1) {
                        sb.append(" ");
                    }
                }

                return sb.toString();
            } else {
                // 跳过当前Tag的Value部分
                index += 3 + ((tlvData[index + 1] & 0xFF) | ((tlvData[index + 2] & 0xFF) << 8));
            }
        }

        // 如果没有找到对应的Tag，则返回空字符串
        return "";
    }
}

解析过程

当输入为：

31
32 01 00 AE 90 02 00 01 02 30 03 00 AB 32 31 31 02 00 32 33 33 01 00 CC

读取输入：
- Tag：31（十六进制，对应十进制49）
- 码流：32 01 00 AE 90 02 00 01 02 30 03 00 AB 32 31 31 02 00 32 33 33 01 00 CC
转换码流为字节数组：
- 码流被转换为字节数组，每个十六进制数对应一个字节。
遍历字节数组：
- 从索引0开始遍历字节数组，每次检查一个信元的Tag。
匹配Tag：
- 第一个信元：Tag=32，Length=01 00（十进制1），Value=AE（忽略，因为Tag不匹配）
- 第二个信元：Tag=90，Length=02 00（十进制2），Value=01 02（忽略，因为Tag不匹配）
- 第三个信元：Tag=30，Length=03 00（十进制3），Value=AB 32 31（忽略，因为Tag不匹配）
- 第四个信元：Tag=32（再次遇到，但我们需要找的是31，所以继续）
- 第五个信元：Tag=31，Length=02 00（十进制2），Value=32 33（找到匹配的Tag，读取对应的Value）
输出Value：
- 将Value字节数组转换为十六进制字符串，得到32 33。
程序结束：
- 打印出32 33作为输出。

以下是运行示例的Java代码输出：

java 复制代码

// 输入
31
32 01 00 AE 90 02 00 01 02 30 03 00 AB 32 31 31 02 00 32 33 33 01 00 CC

// 输出
32 33

扩展内容

1. 输入与输出的详细解释

输入：

第一行是目标信元的Tag，以十六进制字符串形式给出。例如：31。
第二行是TLV编码的十六进制码流，各个字节之间用空格分隔。例如：32 01 00 AE 90 02 00 01 02 30 03 00 AB 32 31 31 02 00 32 33 33 01 00 CC。

输出：

输出是目标信元对应的Value，以十六进制字符串形式给出，并且不包含小写字母。例如：32 33。

2. TLV编码格式的详细解释

TLV（Tag-Length-Value）编码格式是一种常见的数据编码方式，用于在数据流中嵌入结构化信息。每个信元包含三部分：

Tag：一个字节，用于唯一标识信元。
Length：两个字节，以小端序（最低有效字节在前）表示Value的长度。
Value：Length指定的字节数，表示信元的值。

3. Java代码详解

Scanner的使用：

Scanner类用于读取控制台输入。scanner.nextLine()方法读取一行输入，trim()方法去除字符串两端的空白字符。

十六进制字符串转换为字节数组：

Integer.parseInt(hexBytes[i], 16)将十六进制字符串转换为整数，然后强制转换为字节。

遍历字节数组：

使用while循环遍历字节数组，每次检查一个信元的Tag。
index变量用于跟踪当前处理的位置。

匹配Tag并读取Value：

如果当前信元的Tag与目标Tag匹配，则读取Length字段，并根据Length读取Value字段。
Length字段由两个字节组成，使用位运算（& 0xFF和<< 8）将两个字节组合成一个整数。

将字节数组转换为十六进制字符串：

使用StringBuilder和String.format("%02X", value[i])将字节数组转换为十六进制字符串。%02X表示以大写十六进制格式输出，不足两位时补零。

错误处理：

如果遍历完整个字节数组都没有找到目标Tag，则返回空字符串。

4. 边界情况与异常处理

输入格式错误 ：如果输入的十六进制字符串包含非法字符或格式不正确，Integer.parseInt会抛出NumberFormatException。可以通过添加异常处理代码来捕获并处理这种情况。
输入长度不足 ：如果输入的码流长度不足以构成一个完整的信元（即少于3个字节），代码会抛出ArrayIndexOutOfBoundsException。可以通过在遍历前检查数组长度来避免这种情况。
目标Tag不存在：如果遍历完整个字节数组都没有找到目标Tag，代码会返回空字符串。可以根据需要添加提示信息或进行其他处理。

5. 优化与改进

性能优化：对于大数据量的输入，可以考虑使用更高效的字符串解析和字节转换方法，以减少内存占用和提高处理速度。
输入验证：增加对输入的验证和错误处理，确保输入的十六进制字符串格式正确且符合TLV编码规范。
代码可读性：通过添加注释和适当的变量命名来提高代码的可读性和可维护性。