Java字符串編碼解碼性能提升的技巧分享
1.常見(jiàn)字符串編碼
常見(jiàn)的字符串編碼有：
LATIN1 只能保存ASCII字符，又稱ISO-8859-1。
UTF-8 變長(zhǎng)字節(jié)編碼，一個(gè)字符需要使用1個(gè)、2個(gè)或者3個(gè)byte表示。由于中文通常需要3個(gè)字節(jié)表示，中文場(chǎng)景UTF-8編碼通常需要更多的空間，替代的方案是GBK/GB2312/GB18030。
UTF-16 2個(gè)字節(jié)，一個(gè)字符需要使用2個(gè)byte表示，又稱UCS-2 (2-byte Universal Character Set)。根據(jù)大小端的區(qū)分，UTF-16有兩種形式，UTF-16BE和UTF-16LE，缺省UTF-16指UTF-16BE。Java語(yǔ)言中的char是UTF-16LE編碼。
GB18030 變長(zhǎng)字節(jié)編碼，一個(gè)字符需要使用1個(gè)、2個(gè)或者3個(gè)byte表示。類似UTF8，中文只需要2個(gè)字符，表示中文更省字節(jié)大小，缺點(diǎn)是在國(guó)際上不通用。
為了計(jì)算方便，內(nèi)存中字符串通常使用等寬字符，Java語(yǔ)言中char和.NET中的char都是使用UTF-16。早期Windows-NT只支持UTF-16。
2.編碼轉(zhuǎn)換性能
UTF-16和UTF-8之間轉(zhuǎn)換比較復(fù)雜，通常性能較差。
如下是一個(gè)將UTF-16轉(zhuǎn)換為UTF-8編碼的實(shí)現(xiàn)，可以看出算法比較復(fù)雜，所以性能較差，這個(gè)操作也無(wú)法使用vector API做優(yōu)化。
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[]轉(zhuǎn)換為UTF-16LE編碼的byte[]時(shí)，可以使用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的實(shí)現(xiàn)不一樣，從而導(dǎo)致有不同的性能表現(xiàn)。char是UTF-16編碼，但String在JDK 9之后內(nèi)部可以有LATIN1編碼。
3.1. JDK 6之前的String實(shí)現(xiàn)
static class String {
final char[] value;
final int offset;
final int count;
}在Java 6之前，String.subString方法產(chǎn)生的String對(duì)象和原來(lái)String對(duì)象共用一個(gè)char[] value，這會(huì)導(dǎo)致subString方法返回的String的char[]被引用而無(wú)法被GC回收。于是使得很多庫(kù)都會(huì)針對(duì)JDK 6及以下版本避免使用subString方法。
3.2. JDK 7/8的String實(shí)現(xiàn)
static class String {
final char[] value;
}JDK 7之后，字符串去掉了offset和count字段，value.length就是原來(lái)的count。這避免了subString引用大char[]的問(wèn)題，優(yōu)化也更容易，從而JDK7/8中的String操作性能比Java 6有較大提升。
3.3. JDK 9/10/11的實(shí)現(xiàn)
static class String {
final byte code;
final byte[] value;
static final byte LATIN1 = 0;
static final byte UTF16 = 1;
}JDK 9之后，value類型從char[]變成byte[]，增加了一個(gè)字段code，如果字符全部是ASCII字符，使用value使用LATIN編碼；如果存在任何一個(gè)非ASCII字符，則用UTF16編碼。這種混合編碼的方式，使得英文場(chǎng)景占更少的內(nèi)存。缺點(diǎn)是導(dǎo)致Java 9的String API性能可能不如JDK 8，特別是傳入char[]構(gòu)造字符串，會(huì)被做壓縮為latin編碼的byte[]，有些場(chǎng)景會(huì)下降10%。
4.快速構(gòu)造字符串的方法
為了實(shí)現(xiàn)字符串是不可變特性，構(gòu)造字符串的時(shí)候，會(huì)有拷貝的過(guò)程，如果要提升構(gòu)造字符串的開(kāi)銷，就要避免這樣的拷貝。
比如如下是JDK8的String的一個(gè)構(gòu)造函數(shù)的實(shí)現(xiàn)
public final class String {
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
}在JDK8中，有一個(gè)構(gòu)造函數(shù)是不做拷貝的，但這個(gè)方法不是public，需要用一個(gè)技巧實(shí)現(xiàn)MethodHandles.Lookup & LambdaMetafactory綁定反射來(lái)調(diào)用，文章后面有介紹這個(gè)技巧的代碼。
public final class String {
String(char[] value, boolean share) {
// assert share : "unshared not supported";
this.value = value;
}
}快速構(gòu)造字符的方法有三種：
- 使用MethodHandles.Lookup & LambdaMetafactory綁定反射
- 使用JavaLangAccess的相關(guān)方法
- 使用Unsafe直接構(gòu)造
這三種方法，1和2性能差不多，3比1和2略慢，但都比直接new字符串要快得多。JDK8使用JMH測(cè)試的數(shù)據(jù)如下:
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之后，對(duì)全部是ASCII字符的場(chǎng)景，直接構(gòu)造能達(dá)到更好的效果。
4.1 基于MethodHandles.Lookup & LambdaMetafactory綁定反射的快速構(gòu)造字符串的方法
4.1.1 JDK8快速構(gòu)造字符串
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快速構(gòu)造字符串的方法
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快速構(gòu)造字符串的方法
在JDK 17中，MethodHandles.Lookup使用Reflection.registerFieldsToFilter對(duì)lookupClass和allowedModes做了保護(hù)，網(wǎng)上搜索到的通過(guò)修改allowedModes的辦法是不可用的。
在JDK 17中，要通過(guò)配置JVM啟動(dòng)參數(shù)才能使用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快速構(gòu)造
通過(guò)SharedSecrets提供的JavaLangAccess，也可以不拷貝構(gòu)造字符串，但是這個(gè)比較麻煩，JDK 8/11/17的API都不一樣，對(duì)一套代碼兼容不同的JDK版本不方便，不建議使用。
JavaLangAccess javaLangAccess = SharedSecrets.getJavaLangAccess(); javaLangAccess.newStringNoRepl(b, StandardCharsets.US_ASCII);
4.3 基于Unsafe實(shí)現(xiàn)快速構(gòu)造字符串
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之后，實(shí)現(xiàn)是不同，比如:
Object str = UNSAFE.allocateInstance(String.class); UNSAFE.putByte(str, coderOffset, (byte) 0); UNSAFE.putObject(str, valueOffset, (byte[]) bytes);
4.4 快速構(gòu)建字符串的技巧應(yīng)用：
如下的方法格式化日期為字符串，性能就會(huì)非常好。
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.快速遍歷字符串的辦法
無(wú)論JDK什么版本，String.charAt都是一個(gè)較大的開(kāi)銷，JIT的優(yōu)化效果并不好，無(wú)法消除參數(shù)index范圍檢測(cè)的開(kāi)銷，不如直接操作String里面的value數(shù)組。
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開(kāi)銷更大
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的比較數(shù)據(jù)如下：
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方法
當(dāng)能直接獲取到String.value時(shí)，就可以直接對(duì)其做encodeUTF8操作，會(huì)比String.getBytes(StandardCharsets.UTF_8)性能好很多。
6.1 JDK8高性能encodeUTF8的方法
public static int encodeUTF8(char[] 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 && src[offset] < '\u0080') {
dst[dp++] = (byte) src[offset++];
}
while (offset < sl) {
char c = 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 = 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操作，不會(huì)有多余的arrayCopy操作，性能會(huì)得到提升。
6.1.1 性能測(cè)試比較
測(cè)試代碼
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();
}
}測(cè)試結(jié)果
EncodeUTF8Benchmark.getBytesUTF8 thrpt 5 20690.960 ± 5431.442 ops/ms
EncodeUTF8Benchmark.unsafeEncodeUTF8 thrpt 5 34508.606 ± 55.510 ops/ms
從結(jié)果來(lái)看，通過(guò)unsafe + 直接調(diào)用encodeUTF8方法， 編碼的所需要開(kāi)銷是newStringUTF8的58%。
6.2 JDK9/11/17高性能encodeUTF8的方法
public static int encodeUTF8(byte[] src, int offset, int len, byte[] dst, int dp) {
int sl = offset + len;
while (offset < sl) {
byte b0 = src[offset++];
byte b1 = 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 = src[ip + 1];
b1 = 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操作，不會(huì)有多余的arrayCopy操作，性能會(huì)得到提升。
7.重要提醒
上面這些技巧都不是給新手使用的，使用不當(dāng)會(huì)容易導(dǎo)致BUG，如果沒(méi)徹底搞懂，請(qǐng)不要使用！
以上就是Java字符串編碼解碼性能提升的技巧分享的詳細(xì)內(nèi)容，更多關(guān)于Java字符串編碼解碼的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
Java動(dòng)態(tài)追蹤技術(shù)探究之從JSP到Arthas
這篇文章主要介紹了Java動(dòng)態(tài)追蹤技術(shù)探究之從JSP到Arthas,文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，,需要的朋友可以參考下2019-06-06
解決springmvc使用@PathVariable路徑匹配問(wèn)題
這篇文章主要介紹了解決springmvc使用@PathVariable路徑匹配問(wèn)題，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過(guò)來(lái)看看吧2021-02-02
Hibernate是一個(gè)開(kāi)放源代碼的對(duì)象關(guān)系映射框架，它對(duì)JDBC進(jìn)行了非常輕量級(jí)的對(duì)象封裝，使得Java程序員可以隨心所欲的使用對(duì)象編程思維來(lái)操縱數(shù)據(jù)庫(kù)，本文重點(diǎn)給大家介紹持久層ORM框架Hibernate框架的使用及搭建方式，感興趣的朋友一起看看吧2021-11-11
Java實(shí)現(xiàn)刪除排序數(shù)組中重復(fù)元素的方法小結(jié)【三種方法比較】
這篇文章主要介紹了Java實(shí)現(xiàn)刪除排序數(shù)組中重復(fù)元素的方法,結(jié)合實(shí)例形式對(duì)比分析了三種常見(jiàn)的數(shù)組元素刪除算法操作技巧,需要的朋友可以參考下2019-02-02
解決IDEA項(xiàng)目project包目錄消失的問(wèn)題
這篇文章主要介紹了解決IDEA項(xiàng)目project包目錄消失的問(wèn)題，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過(guò)來(lái)看看吧2021-02-02
java線程Thread.sleep()對(duì)比對(duì)象的wait示例解析
這篇文章主要為大家介紹了java線程Thread.sleep()對(duì)比對(duì)象的wait示例解析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步,早日升職加薪2023-09-09
這篇文章主要介紹了詳解Java sort()數(shù)組排序(升序和降序)，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2021-01-01
java并發(fā)包JUC誕生及詳細(xì)內(nèi)容
這篇文章主要為大家介紹了java并發(fā)包JUC的誕生及JUC增加的內(nèi)容詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步2022-02-02
這篇文章主要介紹了java常用工具類Excel操作類及依賴包下載,需要的朋友可以參考下2014-07-07
這篇文章主要介紹了java中GZIP壓縮解壓類使用實(shí)例的相關(guān)資料,需要的朋友可以參考下2017-03-03