android，kotlin 将 Long 转换为十六进制字符串

Question

将 java 代码转换为 kotlin，似乎 kotlin 有 Long.toString(16) ，但不确定继续调用java是否更好，有什么建议更好吗？

java.lang.Long.toHexString(theLong)

调用:

which:

public static String toHexString(long i) {
        return toUnsignedString0(i, 4);
    }

static String toUnsignedString0(long val, int shift) {
        // assert shift > 0 && shift <=5 : "Illegal shift value";
        int mag = Long.SIZE - Long.numberOfLeadingZeros(val);
        int chars = Math.max(((mag + (shift - 1)) / shift), 1);
        char[] buf = new char[chars];

        formatUnsignedLong(val, shift, buf, 0, chars);
        // Android-changed: Use regular constructor instead of one which takes over "buf".
        // return new String(buf, true);
        return new String(buf);
    }

     static int formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {
        int charPos = len;
        int radix = 1 << shift;
        int mask = radix - 1;
        do {
            buf[offset + --charPos] = Integer.digits[((int) val) & mask];
            val >>>= shift;
        } while (val != 0 && charPos > 0);

        return charPos;
    }

或 Kotlin

theLong.toString(16)

调用

public actual inline fun Long.toString(radix: Int): String = java.lang.Long.toString(this, checkRadix(radix))

which:
public static String toString(long i, int radix) {
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;
        if (radix == 10)
            return toString(i);
        char[] buf = new char[65];
        int charPos = 64;
        boolean negative = (i < 0);

        if (!negative) {
            i = -i;
        }

        while (i <= -radix) {
            buf[charPos--] = Integer.digits[(int)(-(i % radix))];
            i = i / radix;
        }
        buf[charPos] = Integer.digits[(int)(-i)];

        if (negative) {
            buf[--charPos] = '-';
        }

        return new String(buf, charPos, (65 - charPos));
    }

Answer 1

kotlin.Long.toString(radix: Int)是有符号的，这意味着它将返回一个带有负号的字符串，用于负值(或者如果我们从无符号数的角度考虑，则值超过 2^63 - 1)。

Long.toHexString(long i)是无符号的，你永远不会看到负号前缀。该方法还针对 2 的幂进行了优化，使用移位运算符而不是除法，因此性能可能会稍好一些。然而，这实际上应该是您最关心的问题。

因此，如果您不打算格式化超过 2^63 - 1 的值，请使用 Kotlin 的函数，否则使用 Java 的。第三种选择是使用 ULong.toString如果您想避免使用 Java 方法。