我的编程空间，编程开发者的网络收藏夹
学习永远不晚
位置：首页-资讯-后端开发

Java字符串编码解码性能提升的技巧分享

2024-04-02 19:55

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号
获取短信验证
立即预约

请填写图片验证码后获取短信验证码

看不清楚，换张图片

免费获取短信验证码

Java字符串编码解码性能提升的技巧分享

1.常见字符串编码

常见的字符串编码有：

LATIN1 只能保存ASCII字符，又称ISO-8859-1。

UTF-8 变长字节编码，一个字符需要使用1个、2个或者3个byte表示。由于中文通常需要3个字节表示，中文场景UTF-8编码通常需要更多的空间，替代的方案是GBK/GB2312/GB18030。

UTF-16 2个字节，一个字符需要使用2个byte表示，又称UCS-2 (2-byte Universal Character Set)。根据大小端的区分，UTF-16有两种形式，UTF-16BE和UTF-16LE，缺省UTF-16指UTF-16BE。Java语言中的char是UTF-16LE编码。

GB18030 变长字节编码，一个字符需要使用1个、2个或者3个byte表示。类似UTF8，中文只需要2个字符，表示中文更省字节大小，缺点是在国际上不通用。

为了计算方便，内存中字符串通常使用等宽字符，Java语言中char和.NET中的char都是使用UTF-16。早期Windows-NT只支持UTF-16。

2.编码转换性能

UTF-16和UTF-8之间转换比较复杂，通常性能较差。

如下是一个将UTF-16转换为UTF-8编码的实现，可以看出算法比较复杂，所以性能较差，这个操作也无法使用vector API做优化。

static int encodeUTF8(char[] utf16, int off, int len, byte[] dest, int dp) {
    int sl = off + len, last_offset = sl - 1;

    while (off < sl) {
        char c = utf16[off++];
        if (c < 0x80) {
            // Have at most seven bits
            dest[dp++] = (byte) c;
        } else if (c < 0x800) {
            // 2 dest, 11 bits
            dest[dp++] = (byte) (0xc0 | (c >> 6));
            dest[dp++] = (byte) (0x80 | (c & 0x3f));
        } else if (c >= '\uD800' && c < '\uE000') {
            int uc;
            if (c < '\uDC00') {
                if (off > last_offset) {
                    dest[dp++] = (byte) '?';
                    return dp;
                }

                char d = utf16[off];
                if (d >= '\uDC00' && d < '\uE000') {
                    uc = (c << 10) + d + 0xfca02400;
                } else {
                    throw new RuntimeException("encodeUTF8 error", new MalformedInputException(1));
                }
            } else {
                uc = c;
            }
            dest[dp++] = (byte) (0xf0 | ((uc >> 18)));
            dest[dp++] = (byte) (0x80 | ((uc >> 12) & 0x3f));
            dest[dp++] = (byte) (0x80 | ((uc >> 6) & 0x3f));
            dest[dp++] = (byte) (0x80 | (uc & 0x3f));
            off++; // 2 utf16
        } else {
            // 3 dest, 16 bits
            dest[dp++] = (byte) (0xe0 | ((c >> 12)));
            dest[dp++] = (byte) (0x80 | ((c >> 6) & 0x3f));
            dest[dp++] = (byte) (0x80 | (c & 0x3f));
        }
    }
    return dp;
}

由于Java中char是UTF-16LE编码，如果需要将char[]转换为UTF-16LE编码的byte[]时，可以使用sun.misc.Unsafe#copyMemory方法快速拷贝。比如：

static int writeUtf16LE(char[] chars, int off, int len, byte[] dest, final int dp) {
    UNSAFE.copyMemory(chars
            , CHAR_ARRAY_BASE_OFFSET + off * 2
            , dest
            , BYTE_ARRAY_BASE_OFFSET + dp
            , len * 2
    );
    dp += len * 2;
    return dp;
}

3.Java String的编码

不同版本的JDK String的实现不一样，从而导致有不同的性能表现。char是UTF-16编码，但String在JDK 9之后内部可以有LATIN1编码。

3.1. JDK 6之前的String实现

static class String {
    final char[] value;
    final int offset;
    final int count;
}

在Java 6之前，String.subString方法产生的String对象和原来String对象共用一个char[] value，这会导致subString方法返回的String的char[]被引用而无法被GC回收。于是使得很多库都会针对JDK 6及以下版本避免使用subString方法。

3.2. JDK 7/8的String实现

static class String {
    final char[] value;
}

JDK 7之后，字符串去掉了offset和count字段，value.length就是原来的count。这避免了subString引用大char[]的问题，优化也更容易，从而JDK7/8中的String操作性能比Java 6有较大提升。

3.3. JDK 9/10/11的实现

static class String {
    final byte code;
    final byte[] value;

    static final byte LATIN1 = 0;
    static final byte UTF16  = 1;
}

JDK 9之后，value类型从char[]变成byte[]，增加了一个字段code，如果字符全部是ASCII字符，使用value使用LATIN编码；如果存在任何一个非ASCII字符，则用UTF16编码。这种混合编码的方式，使得英文场景占更少的内存。缺点是导致Java 9的String API性能可能不如JDK 8，特别是传入char[]构造字符串，会被做压缩为latin编码的byte[]，有些场景会下降10%。

4.快速构造字符串的方法

为了实现字符串是不可变特性，构造字符串的时候，会有拷贝的过程，如果要提升构造字符串的开销，就要避免这样的拷贝。

比如如下是JDK8的String的一个构造函数的实现

public final class String {
    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }
}

在JDK8中，有一个构造函数是不做拷贝的，但这个方法不是public，需要用一个技巧实现MethodHandles.Lookup & LambdaMetafactory绑定反射来调用，文章后面有介绍这个技巧的代码。

public final class String {
    String(char[] value, boolean share) {
        // assert share : "unshared not supported";
        this.value = value;
    }
}

快速构造字符的方法有三种：

  • 使用MethodHandles.Lookup & LambdaMetafactory绑定反射
  • 使用JavaLangAccess的相关方法
  • 使用Unsafe直接构造

这三种方法，1和2性能差不多，3比1和2略慢，但都比直接new字符串要快得多。JDK8使用JMH测试的数据如下:

Benchmark                          Mode  Cnt       Score       Error   Units
StringCreateBenchmark.invoke      thrpt    5  784869.350 ±  1936.754  ops/ms
StringCreateBenchmark.langAccess  thrpt    5  784029.186 ±  2734.300  ops/ms
StringCreateBenchmark.unsafe      thrpt    5  761176.319 ± 11914.549  ops/ms
StringCreateBenchmark.newString   thrpt    5  140883.533 ±  2217.773  ops/ms

在JDK 9之后，对全部是ASCII字符的场景，直接构造能达到更好的效果。

4.1 基于MethodHandles.Lookup & LambdaMetafactory绑定反射的快速构造字符串的方法

4.1.1 JDK8快速构造字符串

public static BiFunction<char[], Boolean, String> getStringCreatorJDK8() throws Throwable {
   Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
   constructor.setAccessible(true);
    MethodHandles lookup = constructor.newInstance(
          String.class
             , -1 // Lookup.TRUSTED
             );
    
    MethodHandles.Lookup caller = lookup.in(String.class);
  
    MethodHandle handle = caller.findConstructor(
                String.class, MethodType.methodType(void.class, char[].class, boolean.class)
                );

    CallSite callSite = LambdaMetafactory.metafactory(
            caller
            , "apply"
            , MethodType.methodType(BiFunction.class)
            , handle.type().generic()
            , handle
            , handle.type()
            );

    return (BiFunction) callSite.getTarget().invokeExact();
}

4.1.2 JDK 11快速构造字符串的方法

public static ToIntFunction<String> getStringCode11() throws Throwable {
    Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
    constructor.setAccessible(true);
    MethodHandles.Lookup lookup = constructor.newInstance(
            String.class
            , -1 // Lookup.TRUSTED
    );

    MethodHandles.Lookup caller = lookup.in(String.class);
    MethodHandle handle = caller.findVirtual(
            String.class, "coder", MethodType.methodType(byte.class)
   );

    CallSite callSite = LambdaMetafactory.metafactory(
            caller
            , "applyAsInt"
            , MethodType.methodType(ToIntFunction.class)
            , MethodType.methodType(int.class, Object.class)
            , handle
            , handle.type()
    );

    return (ToIntFunction<String>) callSite.getTarget().invokeExact();
}
if (JDKUtils.JVM_VERSION == 11) {
    Function<byte[], String> stringCreator = JDKUtils.getStringCreatorJDK11();

    byte[] bytes = new byte[]{'a', 'b', 'c'};
    String apply = stringCreator.apply(bytes);
    assertEquals("abc", apply);
}

4.1.3 JDK 17快速构造字符串的方法

在JDK 17中，MethodHandles.Lookup使用Reflection.registerFieldsToFilter对lookupClass和allowedModes做了保护，网上搜索到的通过修改allowedModes的办法是不可用的。

在JDK 17中，要通过配置JVM启动参数才能使用MethodHandlers。如下：

--add-opens java.base/java.lang.invoke=ALL-UNNAMED
public static BiFunction<byte[], Charset, String> getStringCreatorJDK17() throws Throwable {
    Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, Class.class, int.class);
    constructor.setAccessible(true);
    MethodHandles.Lookup lookup = constructor.newInstance(
           String.class
            , null
            , -1 // Lookup.TRUSTED
    );

    MethodHandles.Lookup caller = lookup.in(String.class);
    MethodHandle handle = caller.findStatic(
            String.class, "newStringNoRepl1", MethodType.methodType(String.class, byte[].class, Charset.class)
    );

    CallSite callSite = LambdaMetafactory.metafactory(
            caller
            , "apply"
            , MethodType.methodType(BiFunction.class)
            , handle.type().generic()
            , handle
            , handle.type()
    );
    return (BiFunction<byte[], Charset, String>) callSite.getTarget().invokeExact();
}
if (JDKUtils.JVM_VERSION == 17) {
    BiFunction<byte[], Charset, String> stringCreator = JDKUtils.getStringCreatorJDK17();

    byte[] bytes = new byte[]{'a', 'b', 'c'};
    String apply = stringCreator.apply(bytes, StandardCharsets.US_ASCII);
    assertEquals("abc", apply);
}

4.2 基于JavaLangAccess快速构造

通过SharedSecrets提供的JavaLangAccess，也可以不拷贝构造字符串，但是这个比较麻烦，JDK 8/11/17的API都不一样，对一套代码兼容不同的JDK版本不方便，不建议使用。

JavaLangAccess javaLangAccess = SharedSecrets.getJavaLangAccess();
javaLangAccess.newStringNoRepl(b, StandardCharsets.US_ASCII);

4.3 基于Unsafe实现快速构造字符串

public static final Unsafe UNSAFE;
static {
    Unsafe unsafe = null;
    try {
        Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafeField.setAccessible(true);
        unsafe = (Unsafe) theUnsafeField.get(null);
    } catch (Throwable ignored) {}
    UNSAFE = unsafe;
}

////////////////////////////////////////////

Object str = UNSAFE.allocateInstance(String.class);
UNSAFE.putObject(str, valueOffset, chars);

注意：在JDK 9之后，实现是不同，比如:

Object str = UNSAFE.allocateInstance(String.class);
UNSAFE.putByte(str, coderOffset, (byte) 0);
UNSAFE.putObject(str, valueOffset, (byte[]) bytes);

4.4 快速构建字符串的技巧应用：

如下的方法格式化日期为字符串，性能就会非常好。

public String formatYYYYMMDD(Calendar calendar) throws Throwable {
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH) + 1;
    int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);

    
    byte y0 = (byte) (year / 1000 + '0');
    byte y1 = (byte) ((year / 100) % 10 + '0');
    byte y2 = (byte) ((year / 10) % 10 + '0');
    byte y3 = (byte) (year % 10 + '0');
    byte m0 = (byte) (month / 10 + '0');
    byte m1 = (byte) (month % 10 + '0');
    byte d0 = (byte) (dayOfMonth / 10 + '0');
    byte d1 = (byte) (dayOfMonth % 10 + '0');

    if (JDKUtils.JVM_VERSION >= 9) {
        byte[] bytes = new byte[] {y0, y1, y2, y3, m0, m1, d0, d1};

        if (JDKUtils.JVM_VERSION == 17) {
            return JDKUtils.getStringCreatorJDK17().apply(bytes, StandardCharsets.US_ASCII);
        }

        if (JDKUtils.JVM_VERSION <= 11) {
            return JDKUtils.getStringCreatorJDK11().apply(bytes);
        }

        return new String(bytes, StandardCharsets.US_ASCII);
    }

    char[] chars = new char[]{
            (char) y0, 
            (char) y1, 
            (char) y2, 
            (char) y3, 
            (char) m0,
            (char) m1, 
            (char) d0, 
            (char) d1
    };

    if (JDKUtils.JVM_VERSION == 8) {
        return JDKUtils.getStringCreatorJDK8().apply(chars, true);
    }

    return new String(chars);
}

5.快速遍历字符串的办法

无论JDK什么版本，String.charAt都是一个较大的开销，JIT的优化效果并不好，无法消除参数index范围检测的开销，不如直接操作String里面的value数组。

public final class String {
    private final char value[];
    
    public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }
}

在JDK 9之后的版本，charAt开销更大

public final class String {
    private final byte[] value;
    private final byte coder;
    
    public char charAt(int index) {
        if (isLatin1()) {
            return StringLatin1.charAt(value, index);
        } else {
            return StringUTF16.charAt(value, index);
        }
    }
}

5.1 获取String.value的方法

获取String.value的方法有如下：

  • 使用Field反射
  • 使用Unsafe

Unsafe和Field反射在JDK 8 JMH的比较数据如下：

Benchmark                         Mode  Cnt        Score       Error   Units
StringGetValueBenchmark.reflect  thrpt    5   438374.685 ±  1032.028  ops/ms
StringGetValueBenchmark.unsafe   thrpt    5  1302654.150 ± 59169.706  ops/ms

5.1.1 使用反射获取String.value

static Field valueField;
static {
    try {
        valueField = String.class.getDeclaredField("value");
        valueField.setAccessible(true);
    } catch (NoSuchFieldException ignored) {}
}

////////////////////////////////////////////

char[] chars = (char[]) valueField.get(str);

5.1.2 使用Unsafe获取String.value

static long valueFieldOffset;
static {
    try {
        Field valueField = String.class.getDeclaredField("value");
        valueFieldOffset = UNSAFE.objectFieldOffset(valueField);
    } catch (NoSuchFieldException ignored) {}
}

////////////////////////////////////////////

char[] chars = (char[]) UNSAFE.getObject(str, valueFieldOffset);
static long valueFieldOffset;
static long coderFieldOffset;
static {
    try {
        Field valueField = String.class.getDeclaredField("value");
        valueFieldOffset = UNSAFE.objectFieldOffset(valueField);
        
        Field coderField = String.class.getDeclaredField("coder");
        coderFieldOffset = UNSAFE.objectFieldOffset(coderField);
        
    } catch (NoSuchFieldException ignored) {}
}

////////////////////////////////////////////

byte coder = UNSAFE.getObject(str, coderFieldOffset);
byte[] bytes = (byte[]) UNSAFE.getObject(str, valueFieldOffset);

6.更快的encodeUTF8方法

当能直接获取到String.value时，就可以直接对其做encodeUTF8操作，会比String.getBytes(StandardCharsets.UTF_8)性能好很多。

6.1 JDK8高性能encodeUTF8的方法

public static int encodeUTF8(char[] class="lazy" data-src, int offset, int len, byte[] dst, int dp) {
    int sl = offset + len;
    int dlASCII = dp + Math.min(len, dst.length);

    // ASCII only optimized loop
    while (dp < dlASCII && class="lazy" data-src[offset] < '\u0080') {
        dst[dp++] = (byte) class="lazy" data-src[offset++];
    }

    while (offset < sl) {
        char c = class="lazy" data-src[offset++];
        if (c < 0x80) {
            // Have at most seven bits
            dst[dp++] = (byte) c;
        } else if (c < 0x800) {
            // 2 bytes, 11 bits
            dst[dp++] = (byte) (0xc0 | (c >> 6));
            dst[dp++] = (byte) (0x80 | (c & 0x3f));
        } else if (c >= '\uD800' && c < ('\uDFFF' + 1)) { //Character.isSurrogate(c) but 1.7
            final int uc;
            int ip = offset - 1;
            if (c >= '\uD800' && c < ('\uDBFF' + 1)) { // Character.isHighSurrogate(c)
                if (sl - ip < 2) {
                    uc = -1;
                } else {
                    char d = class="lazy" data-src[ip + 1];
                    // d >= '\uDC00' && d < ('\uDFFF' + 1)
                    if (d >= '\uDC00' && d < ('\uDFFF' + 1)) { // Character.isLowSurrogate(d)
                        uc = ((c << 10) + d) + (0x010000 - ('\uD800' << 10) - '\uDC00'); // Character.toCodePoint(c, d)
                    } else {
                        dst[dp++] = (byte) '?';
                        continue;
                    }
                }
            } else {
                //
                if (c >= '\uDC00' && c < ('\uDFFF' + 1)) { // Character.isLowSurrogate(c)
                    dst[dp++] = (byte) '?';
                    continue;
                } else {
                    uc = c;
                }
            }

            if (uc < 0) {
                dst[dp++] = (byte) '?';
            } else {
                dst[dp++] = (byte) (0xf0 | ((uc >> 18)));
                dst[dp++] = (byte) (0x80 | ((uc >> 12) & 0x3f));
                dst[dp++] = (byte) (0x80 | ((uc >> 6) & 0x3f));
                dst[dp++] = (byte) (0x80 | (uc & 0x3f));
                offset++; // 2 chars
            }
        } else {
            // 3 bytes, 16 bits
            dst[dp++] = (byte) (0xe0 | ((c >> 12)));
            dst[dp++] = (byte) (0x80 | ((c >> 6) & 0x3f));
            dst[dp++] = (byte) (0x80 | (c & 0x3f));
        }
    }
    return dp;
}

使用encodeUTF8方法举例

char[] chars = UNSAFE.getObject(str, valueFieldOffset);
// ensureCapacity(chars.length * 3)
byte[] bytes = ...; // 
int bytesLength = IOUtils.encodeUTF8(chars, 0, chars.length, bytes, bytesOffset);

这样encodeUTF8操作，不会有多余的arrayCopy操作，性能会得到提升。

6.1.1 性能测试比较

测试代码

public class EncodeUTF8Benchmark {
    static String STR = "01234567890ABCDEFGHIJKLMNOPQRSTUVWZYZabcdefghijklmnopqrstuvwzyz一二三四五六七八九十";
    static byte[] out;

    static long valueFieldOffset;

    static {
        out = new byte[STR.length() * 3];
        try {
            Field valueField = String.class.getDeclaredField("value");
            valueFieldOffset = UnsafeUtils.UNSAFE.objectFieldOffset(valueField);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

    @Benchmark
    public void unsafeEncodeUTF8() throws Exception {
        char[] chars = (char[]) UnsafeUtils.UNSAFE.getObject(STR, valueFieldOffset);
        int len = IOUtils.encodeUTF8(chars, 0, chars.length, out, 0);
    }

    @Benchmark
    public void getBytesUTF8() throws Exception {
        byte[] bytes = STR.getBytes(StandardCharsets.UTF_8);
        System.arraycopy(bytes, 0, out, 0, bytes.length);
    }

    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder()
                .include(EncodeUTF8Benchmark.class.getName())
                .mode(Mode.Throughput)
                .timeUnit(TimeUnit.MILLISECONDS)
                .forks(1)
                .build();
        new Runner(options).run();
    }
}

测试结果

EncodeUTF8Benchmark.getBytesUTF8      thrpt    5  20690.960 ± 5431.442  ops/ms
EncodeUTF8Benchmark.unsafeEncodeUTF8  thrpt    5  34508.606 ±   55.510  ops/ms

从结果来看，通过unsafe + 直接调用encodeUTF8方法， 编码的所需要开销是newStringUTF8的58%。

6.2 JDK9/11/17高性能encodeUTF8的方法

public static int encodeUTF8(byte[] class="lazy" data-src, int offset, int len, byte[] dst, int dp) {
    int sl = offset + len;
    while (offset < sl) {
        byte b0 = class="lazy" data-src[offset++];
        byte b1 = class="lazy" data-src[offset++];

        if (b1 == 0 && b0 >= 0) {
            dst[dp++] = b0;
        } else {
            char c = (char)(((b0 & 0xff) << 0) | ((b1 & 0xff) << 8));
            if (c < 0x800) {
                // 2 bytes, 11 bits
                dst[dp++] = (byte) (0xc0 | (c >> 6));
                dst[dp++] = (byte) (0x80 | (c & 0x3f));
            } else if (c >= '\uD800' && c < ('\uDFFF' + 1)) { //Character.isSurrogate(c) but 1.7
                final int uc;
                int ip = offset - 1;
                if (c >= '\uD800' && c < ('\uDBFF' + 1)) { // Character.isHighSurrogate(c)
                    if (sl - ip < 2) {
                        uc = -1;
                    } else {
                        b0 = class="lazy" data-src[ip + 1];
                        b1 = class="lazy" data-src[ip + 2];
                        char d = (char) (((b0 & 0xff) << 0) | ((b1 & 0xff) << 8));
                        // d >= '\uDC00' && d < ('\uDFFF' + 1)
                        if (d >= '\uDC00' && d < ('\uDFFF' + 1)) { // Character.isLowSurrogate(d)
                            uc = ((c << 10) + d) + (0x010000 - ('\uD800' << 10) - '\uDC00'); // Character.toCodePoint(c, d)
                        } else {
                            return -1;
                        }
                    }
                } else {
                    //
                    if (c >= '\uDC00' && c < ('\uDFFF' + 1)) { // Character.isLowSurrogate(c)
                        return -1;
                    } else {
                        uc = c;
                    }
                }

                if (uc < 0) {
                    dst[dp++] = (byte) '?';
                } else {
                    dst[dp++] = (byte) (0xf0 | ((uc >> 18)));
                    dst[dp++] = (byte) (0x80 | ((uc >> 12) & 0x3f));
                    dst[dp++] = (byte) (0x80 | ((uc >> 6) & 0x3f));
                    dst[dp++] = (byte) (0x80 | (uc & 0x3f));
                    offset++; // 2 chars
                }
            } else {
                // 3 bytes, 16 bits
                dst[dp++] = (byte) (0xe0 | ((c >> 12)));
                dst[dp++] = (byte) (0x80 | ((c >> 6) & 0x3f));
                dst[dp++] = (byte) (0x80 | (c & 0x3f));
            }
        }
    }
    return dp;
}

使用encodeUTF8方法举例

byte coder = UNSAFE.getObject(str, coderFieldOffset);
byte[] value = UNSAFE.getObject(str, coderFieldOffset);

if (coder == 0) {
    // ascii arraycopy
} else {
    // ensureCapacity(chars.length * 3)
    byte[] bytes = ...; // 
    int bytesLength = IOUtils.encodeUTF8(value, 0, value.length, bytes, bytesOffset);
}

这样encodeUTF8操作，不会有多余的arrayCopy操作，性能会得到提升。

7.重要提醒

上面这些技巧都不是给新手使用的，使用不当会容易导致BUG，如果没彻底搞懂，请不要使用！

以上就是Java字符串编码解码性能提升的技巧分享的详细内容，更多关于Java字符串编码解码的资料请关注编程网其它相关文章！

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

阅读原文内容投诉

Java字符串编码解码性能提升的技巧分享

下载Word文档到电脑，方便收藏和打印～

下载Word文档

相关文章

猜你喜欢

Java字符串编码解码性能提升的技巧分享

2024-04-02

Java字符串编码解码性能怎么提升

这篇“Java字符串编码解码性能怎么提升”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Java字符串编码解码性能怎么提升”文
2023-06-30

Java 中的5个代码性能提升技巧

2024-04-02

分享5个Java接口性能提升的通用技巧

作为后端开发人员，我们总是在编写各种API。这些API在服务初期可能表现不错，但随着用户数量的增长，一开始响应很快的API越来越慢，这时候你就需要考虑如何优化你的API性能了。在这篇文章中，我总结了一些行之有效的API性能优化技巧，希望能给有需要的朋友一些帮助
2023-01-03

5个可以在Golang中优化代码以提高性能的技巧分享

作为一名软件工程师，确保你的代码高效且性能良好是非常重要的。本文主要和大家分享5个可以在Golang中优化代码以提高性能的技巧，希望对大家有所帮助
2023-03-19

热门标签

Linux(148)PHP(127)Java(102)正则表达式(101)JavaScript(69)最佳实践(67)jQuery(44)MySQL(39)Docker(37)C语言(36)性能优化(34)Python(34)XML(28)string(27)第三方库(23)回调函数(23)ZIP(22)数组(22)可扩展性(22)字符串比较(21)find(20)RPM(20)Go(20)grep(19)ASP.NETCore(19)XML解析器(19)事件(19)事件处理程序(19)StringBuilder(18)Nginx(18)

编程热搜

  • Python 学习之路 - Python
    一、安装Python34Windows在Python官网（https://www.python.org/downloads/）下载安装包并安装。Python的默认安装路径是：C:\Python34配置环境变量：【右键计算机】--》【属性】-
    Python 学习之路 - Python
  • chatgpt的中文全称是什么
    chatgpt的中文全称是生成型预训练变换模型。ChatGPT是什么ChatGPT是美国人工智能研究实验室OpenAI开发的一种全新聊天机器人模型，它能够通过学习和理解人类的语言来进行对话，还能根据聊天的上下文进行互动，并协助人类完成一系列
    chatgpt的中文全称是什么
  • C/C++中extern函数使用详解
    C/C++中extern函数使用详解
  • C/C++可变参数的使用
    可变参数的使用方法远远不止以下几种，不过在C,C++中使用可变参数时要小心，在使用printf()等函数时传入的参数个数一定不能比前面的格式化字符串中的’%’符号个数少，否则会产生访问越界，运气不好的话还会导致程序崩溃
    C/C++可变参数的使用
  • css样式文件该放在哪里
    css样式文件该放在哪里
  • php中数组下标必须是连续的吗
    php中数组下标必须是连续的吗
  • Python 3 教程
    Python 3 教程 Python 的 3.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0 在设计的时候没有考虑向下兼容。 Python
    Python 3 教程
  • Python pip包管理
    一、前言    在Python中， 安装第三方模块是通过 setuptools 这个工具完成的。 Python有两个封装了 setuptools的包管理工具： easy_install  和  pip ， 目前官方推荐使用 pip。    
    Python pip包管理
  • ubuntu如何重新编译内核
    ubuntu如何重新编译内核
  • 改善Java代码之慎用java动态编译
    改善Java代码之慎用java动态编译
查看更多

编程资源站

  • 资料下载
  • 历年试题
2021年下半年软考高级信息系统项目管理师高频考点精选资料
2021下半年软考高级信息系统技术知识点记忆口诀精选资料
2021下半年软考《信息系统项目管理师》考试真题及答案精选资料
2021下半年软考高级考试备考攻略精选资料
2021年软考高级《信息系统项目管理师》巩固练习题汇总精选资料
2021下半年软考高级信息系统项目管理师30个易考知识点汇总精选资料
2021下半年软考高级知识点这样记，还担心记不住吗精选资料
2021年下半年软考高级考试重点汇总精选资料
2021下半年软考高级信息系统项目管理师计算公式汇总精选资料
2021年下半年软考高级《信息系统项目管理师》模拟试题精选资料
查看更多
信息系统项目管理师选择题每日一练（2024）历年试题
2023年下半年信息系统项目管理师综合知识真题演练历年试题
查看更多

目录

本网页已闲置超过3分钟，按键盘任意键或点击空白处，即可回到网页
最新资讯更多
    友情链接编程网

    反馈

    我要
    反馈