Java中十进制字符串转十六进制的性能解读

目录

• 1. 避免字符串分割，直接遍历字符数组
• 2. 使用预分配容量的 StringBuilder
• 3. 手动实现数字转十六进制，避免 String.format
• 4. 批量处理字符，减少方法调用开销
• 5. 处理奇数长度字符串的优化
• 6. 避免正则表达式（如果不需要）
• 优化后的完整代码
• 性能对比测试js
• 性能优化总结

在 Java 中优化十进制字符串转十六进制的性能，可以从减少对象创建、避免正则表达式、使用高效数据结构等方面js入手。

以下是具体的优化方案：

1. 避免字符串分割，直接遍历字符数组

原始方法（频繁创建子字符串）：

String twoChars = decimalStr.substring(i, i + 2);
int decimalValue = Integer.parseInt(twoChars);

优化方法（直接解析字符数组）：

int value = (decimalStr.charAt(i) - '0') * 10 + 
           (decimalStr.charAt(i + 1) - '0');

2. 使用预分配容量的 StringBuilder

优化前（默认容量，可能多次扩容）：

StringBuilder hexBuilder = new StringBuilder();

优化后（预分配容量，减少扩容次数）：

StringBuilder hexBuilder = new StringBuilder(decimalStr.length() / 2);

3. 手动实现数字转十六进制，避免 String.format

原始方法（使用格式化，开销较大）：

String hexPart = String.format("%02X", decimalValue);

优化方法（手动转换，性能更高）：

char[] hexChars = new char[2];
hexChars[0] = toHexChar(decimalValue >>> 4);  // 高4位
hexChars[1] = toHexChar(decimalValue & 0xF);  // 低4位
hexBuilder.append(hexChars);

// 辅助方法：将0-15的数字转为十六进制字符
private static char toHexChar(int num) {
    return (char) (num < 10 ? num + '0' : num - 10 + 'A');
}

4. 批量处理字符，减少方法调用开销

public static String decimalToHex(String decimalStr) {
    int length = decimalStr.length();
    if (length == 0) return "";
    
    char[] decimalChars = decimalStr.toCharArray();
    char[] hexChars = new char[(length + 1) / 2 * 2]; // 结果数组
    
    int hexIndex = 0;
    for (int i = 0; i < length; i += 2) {
        int d1 = decimalChars[i] - '0';
        int value = d1;
        
        // 检查是否有第二个字符
        if (i + 1 < length) {
            int d2 = decimalChars[i + 1] - '0';
            value = value * 10 + d2;
        }
        
        // 转换为十六进制字符
        hexChars[hexIndex++] = toHexChar(value >>> 4);
        hexChars[hexIndex++] = toHexChar(value & 0xF);
    }
    
    return new String(hexChars, 0, hexIndex);
}

5. 处理奇数长度字符串的优化

对于奇数长度的输入，最后一个字符单独处理：

// 处理最后一个字符（如果长度为奇数）
if (length % 2 != 0) {
    int d = decimalChars[length - 1] - '0';
    hexChars[hexIndex++] = '0';
    hexChars[hexIndex++] = toHexChar(d);
}

6. 避免正则表达式（如果不需要）

优化前（使用正则过滤非数字字符）：

decimalStr = decimalStr.replaceAll("[^0-9]", "");

优化后（手动过滤，性能更高）：

// 手动过滤非数字字符
int filteredLength = 0;
for (int i = 0; i < length; i++) {
编程    char c = decimalStr.charAt(i);
    if (c >= '0' && c <= '9') {
        decimalChars[filteredLength++] = c;
    }
}

优化后的完整代码

public static String decimalToHex(String decimalStr) {
    if (decimalStr == null || decimalStr.isEmpty()) {
        return "";
    }
    
    char[] decimalChars = decimalStr.toCharArray();
    int length = decimalChars.length;
    
    // 预分配结果数组（足够大）
    char[] hexChars = new char[length * 2];
    int hexIndex = 0;
    
    // 处理每两个字符
    for (int i = 0; i < length - 1; i += 2) {
        int d1 = decimalChars[i] - '0';
        int d2 = decimalChars[i + 1] - '0';
        int value = d1 * 10 + d2;
        
        hexChars[hexIndex++] = toHexChar(value >>> 4);
        hexChars[hexIndex++] = toHexChar(value & 0xF);
    }
    
    // 处理最后一个字符（如果长度为奇数）
    if (length % 2 != 0) {
        int d = decimalChars[length - 1] - '0';
        hexChars[hexIndex++] = '0';
        hexChars[hexIndex++] = toHexChar(d);
    }
    
    return new String(hexChars, 0, hexIndex);
}

private static char toHexChar(inKAqgGFZreGt num) {
    return (char) (num < 10 ? num + '0' : num - 10 + 'A');
}

性能对比测试

对 100 万次转换进行js基准测试（输入："255015"）：

性能优化总结

1）减少对象创建：避免 substring、Integer.parseInt 和 String.format。

2）使用基本数据类型：直接操作 char[] 数组，而非字符串。

3）预分配内存：为 StringBuilder 或字符数组预分配足够容量。

4）减少方法调用：内联简单方法（如字符转换）。

5）手动解析字符：直接计算数值，而非依赖库方法。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。