Java中String使用方法及分析(UTF-8簡單編碼/解碼器實現(xiàn))
更新時間：2025年12月01日 09:48:27 作者：森林公園
在Java中String類是用來表示和操作字符串的,它是Java中最常用的類之一,提供了豐富的方法來創(chuàng)建、操作和查詢字符串,這篇文章主要介紹了Java中String使用方法及分析(UTF-8簡單編碼/解碼器實現(xiàn))的相關(guān)資料,需要的朋友可以參考下
0. Java中的字符串（String）
在 Java 語言中，字符串即 字符序列（這里的字符可以是一個英文字母例如 ‘A’，也可以是一個漢字例如 ‘楠’，也可以是一個韓語文字例如 ‘?’，也可以是一個 emoji 表情符號例如 ‘?’ 或 ‘?’）。原生類型 char 用來定義一個字符變量，char 類型字符變量用于保存一個字符。String 類型用來表示一個字符串，Java 中所有字符串字面量都是 String 類型的對象實例，而 String 類內(nèi)部使用 char 類型的數(shù)組保存組成該字符串的字符序列，String 并沒有提供修改字符串即 字符序列的方法，但這并不因為不能做到。下面是一個 String 類的構(gòu)造器方法，如下：
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
可見該方法使用一個 String 類型的實例對象初始化/創(chuàng)建另一個 String 對象，它們內(nèi)部都指向同一個字符序列，這是通常我們創(chuàng)建一個 String 類型對象實例的方式之一：
String str = new String("this is string");
可見，下面的直接賦值的方法更簡潔/高效一點：
String str = "this is string";
Java中的字符串并非不能修改，下面的例子使用反射來修改字符串對象的值：
import java.lang.reflect.Field;
public class Test3 {
public static void main(String[] args) throws NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException {
String str1 = "真楠人";
String str2 = "真楠人";
// 打印字符串 str1 和 str2
System.out.println("str1: " + str1 + ", str2: " + str2);
// 通過反射更改字符串 str1 的值
Field valueField = String.class.getDeclaredField("value");
assert valueField != null;
valueField.setAccessible(true);
char[] value = (char[]) valueField.get(str1);
value[0] = '假';
// 再次打印字符串 str1
System.out.println("str1: " + str1 + ", str2: " + str2);
}
}
代碼執(zhí)行結(jié)果如下：
str1: 真楠人, str2: 真楠人 str1: 假楠人, str2: 假楠人
上述程序中，我們通過反射方法僅僅修改了字符串 str1 的內(nèi)容，但是最后字符串 str2 的內(nèi)容也一起改變了，原因在于 str1 和 str2 都是引用同一個字符串對象（字符串字面量 “真楠人” 為一個 String 類型的對象實例，雖然這個字面量在代碼中出現(xiàn)多次，但是都是引用了同一個 String 實例，可見相同字符序列的字符串共享同一個 String 實例，即 共享字符串，這也解釋了為什么 String 類沒有提供修改字符串的公共方法以及String 類被設(shè)計為 final 類，都是為了共享字符串），這并不難理解。
1. Java中的字符（char）
下面的程序打印一個字符 ‘楠’ 字：
public class Temp_3 {
public static void main(String[] args) {
System.out.println('楠');
System.out.println((char)26976);
System.out.println('\u6960');
}
}
運行結(jié)果為：
楠
楠
楠
可見，三次打印輸出的結(jié)果都一樣。Java 語言使用 Unicode 字符集，Unicode 為每一個字符都分配的一個唯一的數(shù)字，即 這個數(shù)字便代表與之對應(yīng)的字符，其中 ‘\u6960’ 即為字符 ‘楠’ 的 Unicode 十六進制編碼，而十進制數(shù) 26976 則為這個十六進制數(shù)的十進制數(shù)值，它倆是同一個數(shù)值的不同表示方式而已。
我們知道 ASCII 字符集中，字符 ‘A’ 的編號為 65，即 可以對 65 進行強制類型轉(zhuǎn)換即可得到其對應(yīng)的字符 ‘A’。數(shù)值 65 使用一個字節(jié)便可存儲，顯然對于字符 ‘楠’（對應(yīng)數(shù)值為 26976） 一個字節(jié)無法存儲，那么它需要多少個字節(jié)才合適呢？
我們可以看看其它編程語言中的情況，在 C 語言中也有一個 char 數(shù)據(jù)類型，但是它僅僅表示一個字節(jié)的空間，看下面的 C 語言中的例子：
#include <stdio.h>
void main(){
char c = '楠'; // 一個字節(jié)
printf("%c, %d, size=%ld\n", c, c, sizeof c);
char c2 = 'A'; // 一個字節(jié)
printf("%c, size=%ld\n", c2, sizeof c2);
char c3[] = "楠"; // 字符串
printf("%s, size=%ld\n", c3, sizeof c3);
char c4[] = "真楠人"; // 字符串
printf("%s, size=%ld\n", c4, sizeof c4);
}
執(zhí)行結(jié)果如下：
ubuntu@cuname:~/dev/beginning-linux-programming/temp$ gcc -o use-char-string-test use-char-string-test.c
use-char-string-test.c: In function ‘main':
use-char-string-test.c:4:14: warning: multi-character character constant [-Wmultichar]
char c = '楠';
^
use-char-string-test.c:4:14: warning: overflow in implicit constant conversion [-Woverflow]
ubuntu@cuname:~/dev/beginning-linux-programming/temp$ ./use-char-string-test
?, -96, size=1 // c
A, size=1 // c2
楠, size=4 // c3
真楠人, size=10 // c4
可以看到，將字符 ‘楠’ 賦值給 char 類型的變量時，gcc 編譯器警告提示字符 ’楠‘ 為多字節(jié)字符常量，而變量 c 僅僅存儲了字符 ’楠‘ 的一個字節(jié)的數(shù)據(jù)（且其數(shù)值為 -96，-96 是字符 ‘楠’ 字編碼后的字節(jié)序列中的一個字節(jié)，變量 c 顯示亂碼），繼續(xù)查看后續(xù)的輸出結(jié)果，發(fā)現(xiàn)字符 ’A‘ 的長度為 1 個字節(jié)，而每個漢字占 3 個字節(jié)的存儲空間（C 語言中的字符串字面量的內(nèi)部實現(xiàn)為 char 類型的數(shù)組，且以一個空字符 ’\0‘表示字符串結(jié)尾，所以 sizeof 計算的字符串長度（即 字節(jié)數(shù)）比實際長度多一個字節(jié)）。3 個字節(jié)能表示的最大數(shù)值為 ’2的24次方‘ - 1 = 16777215，遠遠大于 26976（即字符 ’楠‘ 對應(yīng)的數(shù)字），其實 2 個字節(jié)就足以存儲數(shù)值 26976（即字符 ’楠‘），而實際上字符 ’楠‘ 卻占用了 3 個字節(jié)空間，這是為啥？這與字符（即 數(shù)值）的編碼（即 存儲）方式有關(guān)，我們知道 Unicode 給每個字符分配一個唯一的數(shù)值來代表該字符，例如任一一篇文章很可能會有多個字符，但是在存儲或傳輸該文章時，并不能就直接依次存儲或傳輸與每個字符對應(yīng)的十進制數(shù)字序列，這里需要考慮 2 個問題，第一如何從數(shù)字序列中識別一個字符，即每個字符的 ‘數(shù)字表示’ 其自身應(yīng)當是一個整體，必須與其它的數(shù)字即與其相鄰的數(shù)字區(qū)分開，第二個問題：成本，字符 ‘A’ 使用 1 個字節(jié)即可存儲，但是字符 ‘楠’ 卻要使用至少 2 個字節(jié)才能滿足，這時，如果要求每個字符都是使用例如 2 個字節(jié)存儲，那么對于英語國家的用戶來說，相當于增加并浪費了 1 倍的成本，這是不能被接受！UTF-8 便是一種可變長度的 Unicode 字符編碼解決方案，且被應(yīng)用于 Java 語言，于是求助于 UTF-8（即 Unicode Transformation Format 8-bit，）。
2. UTF-8編碼
- 參考鏈接UTF-8 and Unicode
- 下面是對UTF-8編碼-規(guī)范文檔的解讀（需要注意區(qū)分，Unicode 只是一個字符集，它為每個字符分配一個唯一的數(shù)字，從而可以用數(shù)字來表達字符，而 UTF-8 是一種編碼方式，描述怎樣實際存儲Unicode 字符對應(yīng)的數(shù)值）
- UTF-8 兼容 ASCII 字符集，即 將編號 0 - 127 留給 ASCII 字符集，這里（ASCII 字符集）總共 128 個數(shù)字（即 字符），使用 7 個 bit 的空間即可表示，每個 ASCII 字符占用一個字節(jié)，且該字節(jié)的最高位始終為 0，反過來，在 UTF-8 編碼中，最高位為 0 的字節(jié)始終表示一個 ASCII 字符。
- UTF-8 使用 1 - 4 個字節(jié)來編碼 Unicode 字符對應(yīng)的數(shù)字編號，規(guī)則如下圖
上圖與 UTF-8 規(guī)范文檔中的圖有點不同：即 可編碼的最大值不同，文檔圖如下：
再回到前面說的字符 ‘楠’ 字，該字符的 Unicode 編號為 26976，而 26976 位于 2048 和 65535 之間，所以它使用 3 個字節(jié)進行編碼并存儲。在進行編碼時，只需將 26976 的二進制碼從低位到高位依次填入‘可用編碼位’ 即可得到字符 ‘楠’ 對應(yīng)的 UTF-8 編碼，操作如下圖：
驗證，使用 notepad++ 新建一個文本文件，并寫入字符 ‘楠’ 字（注意，使用 utf-8編碼），保存文件，然后使用 WinHex 打開該文本文件，結(jié)果如下：
可見，結(jié)果正確。
- 上面是編碼一個字符，下面從 以UTF-8 編碼的字節(jié)數(shù)據(jù)中進行解碼（解碼是編碼的反向操作，編碼是將數(shù)值位依次插入到對應(yīng)的可編碼位，解碼時則從可編碼位提取對應(yīng)的數(shù)值位并將它們拼接在一起，從而還原出原來的數(shù)值）。綜上可以發(fā)現(xiàn)，以 UTF-8 編碼的數(shù)據(jù)，其字節(jié)類型總共有 5 種，其中只有 4 中類型的字節(jié)是可作為一個 UTF-8 編碼的起始字節(jié)（即標識一個字符編碼的開始），如下圖：
思路：將數(shù)值 240（即 ‘1111 0000’）與任意字節(jié)作 ‘&’ （即 ‘與’）位操作，其結(jié)果必定落在上圖中的某個取值范圍中，從而可以決定當前字節(jié)的類型（是否為一個字符編碼的起始字節(jié)）。
簡單 UTF-8 解碼器 Java 實現(xiàn)，代碼如下：
/** 簡單 UTF-8 解碼器（實際應(yīng)用中，可能必須要注意/處理無效字符 即無效 unicode code-point 的情況） */
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Random;
public class UTF_8_decoder {
/** 1M，用于緩存數(shù)據(jù) */
private static final int BUFFER_SIZE = 1024 * 1024;
/** 文本文件 */
private static final String filePath = "C:/Users/jokee/Desktop/data-for-test.txt";
public static void main(String[] args) throws IOException {
File file = new File(filePath);
FileInputStream fileReader = new FileInputStream(file);
/** 用于緩存文件字節(jié)數(shù)據(jù) 即 緩存待解碼的數(shù)據(jù) */
byte[] buffer = new byte[BUFFER_SIZE];
/** 緩存所有數(shù)據(jù) */
final int bytesLength = fileReader.read(buffer, 0, buffer.length);
String result = doDecoding(buffer, bytesLength);
// 打印結(jié)果
System.out.println("解碼字符如下：\n" + "---------------------------------------------\n"
+ result);
fileReader.close();
}
/**
* 執(zhí)行解碼操作，默認大端字節(jié)序
*
bytes ： 待解碼字節(jié)緩沖區(qū)
*
bytesLength ：緩沖區(qū) bytes 中，待解碼的字節(jié)總數(shù)
*/
public static String doDecoding(byte[] bytes, int bytesLength) {
/** 保存解碼后的數(shù)據(jù) */
char[] charData = null;
int charData_index = 0;
String result = null;
if (bytes != null
&& (bytesLength = Math.min(bytesLength, bytes.length)) > 0) {
// 1 從一個隨機位置開始解碼
// int startIndex = new Random().nextInt(bytesLength);
// 2 解碼所有字節(jié)數(shù)據(jù)
int startIndex = 0;
/** 字符類型（參考 getType 方法） */
int type = 0;
/** 保存一個字符的 UTF-8 編碼 */
byte[] encodedCharData = new byte[4];
int encodedCharData_index = 0;
// 初始化
charData = new char[BUFFER_SIZE];
for (; startIndex < bytesLength; ++startIndex) {
if (encodedCharData_index == 0 && (type = getType(bytes[startIndex])) < 0) {
// 直到找到一個 UTF-8 編碼的起始字節(jié)為止
continue;
}
// 讀取一個字符的編碼
encodedCharData[encodedCharData_index++] = bytes[startIndex];
if (encodedCharData_index < type) {
// 繼續(xù)讀取該字符剩余的其它字節(jié)
continue;
}
// 解碼一個字符
if (type == 1) {
// 1
// ascii 字符
charData[charData_index++] = (char) Byte.toUnsignedInt(encodedCharData[0]);
} else if (type == 2) {
// 2
// 提取第一個字節(jié)，屏蔽前 3 個 bit
int b1 = 0b00011111 & Byte.toUnsignedInt(encodedCharData[0]);
// 提取第二個字節(jié)，屏蔽前 2 個 bit
int b2 = 0b00111111 & Byte.toUnsignedInt(encodedCharData[1]);
int aChar = (b1 << 6) | b2;
charData[charData_index++] = (char)aChar;
} else if (type == 3) {
// 3
// 提取第一個字節(jié)，屏蔽前 4 個 bit
int b1 = 0b00001111 & Byte.toUnsignedInt(encodedCharData[0]);
// 提取第二個字節(jié)，屏蔽前 2 個 bit
int b2 = 0b00111111 & Byte.toUnsignedInt(encodedCharData[1]);
// 提取第三個字節(jié)，屏蔽前 2 個 bit
int b3 = 0b00111111 & Byte.toUnsignedInt(encodedCharData[2]);
int aChar = (b1 << 12) | (b2 << 6) | b3;
charData[charData_index++] = (char)aChar;
} else if (type == 4) {
// 4
// 提取第一個字節(jié)，屏蔽前 3 個 bit
int b1 = 0b00000111 & Byte.toUnsignedInt(encodedCharData[0]);
// 提取第二個字節(jié)，屏蔽前 2 個 bit
int b2 = 0b00111111 & Byte.toUnsignedInt(encodedCharData[1]);
// 提取第三個字節(jié)，屏蔽前 2 個 bit
int b3 = 0b00111111 & Byte.toUnsignedInt(encodedCharData[2]);
// 提取第四個字節(jié)，屏蔽前 2 個 bit
int b4 = 0b00111111 & Byte.toUnsignedInt(encodedCharData[3]);
int aChar = (b1 << 18) | (b2 << 12) | (b3 << 6) | b4;
charData[charData_index++] = (char)aChar;
}
// 清理工作
// 清除已緩存且已完成解碼的字符編碼，繼續(xù)處理下一個字符編碼
encodedCharData_index = 0;
}
result = new String(charData, 0, charData_index);
}
return result;
}
/**
* 該方法用于確認參數(shù)字節(jié) aByte 是否為一個 UTF-8 編碼的起始字節(jié)， 返回值說明，
* -1：字節(jié) aByte 非起始字節(jié)，
* 1：起始字節(jié)，類型為 1，對應(yīng)字符占 1 個字節(jié)空間（實為 ASCII 字符）
* 2：起始字節(jié)，類型為 2，對應(yīng)字符占 2 個字節(jié)空間
* 3：起始字節(jié)，類型為 3，對應(yīng)字符占 3 個字節(jié)空間
* 4：起始字節(jié)，類型為 4，對應(yīng)字符占 4 個字節(jié)空間
*/
public static int getType(byte aByte) {
int type = 0b11110000 & aByte; // ‘0b11110000' 為十進制數(shù) 240 的二進制表示
if (0 <= type && type < 128) {
return 1;
} else if (128 <= type && type < 192) {
return -1;
} else if (192 <= type && type < 224) {
return 2;
} else if (224 <= type && type < 240) {
return 3;
} else if (240 <= type && type < 248) {
return 4;
}
return -1;
}
}
- 既然上面有了一個簡單的解碼器，再加一個編碼器也不會多余，下面是一個簡單的 UTF-8 編碼器實現(xiàn)（其中的位運算必須要細心，容易出錯）：
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/** 簡單的 UTF-8 編碼器（實際應(yīng)用中，可能必須要注意/處理無效字符 即無效 unicode code-point 的情況） */
public class UTF_8_encoder {
/** 輸出文件 */
private static final String filePath = "C:/Users/jokee/Desktop/data-for-test.txt";
public static void main(String[] args) throws IOException {
String text = "\u13A0,\u1B93,\u1D83,\u1F00,\u1F10,\u1910\nwo我愛wo家ya，wo愛北京天安門a，\nhei，今天又下雨了ne";
int[] cs = new int[text.length()];
for(int i = 0;i < text.length();i++) {
cs[i] = text.charAt(i);
}
// do encoding
Bytes bytes = doEncoding(cs, cs.length);
// write to file
FileOutputStream writer = new FileOutputStream(new File(filePath));
writer.write(bytes.bytes, 0, bytes.length);
writer.close();
System.out.println("done.");
}
/** 將字符數(shù)組 chars 中的數(shù)量為 charsLength 的字符進行編碼 */
public static Bytes doEncoding(int[] chars, int charsLength) {
Bytes bytes = null;
if (chars != null && (charsLength = Math.min(chars.length, charsLength)) > 0) {
int aChar = 0;
int type = 0;
/** 定義一個足夠容量的字節(jié)緩存區(qū)：假設(shè)每個字符都是占用 4 個字節(jié) */
bytes = new Bytes(4 * charsLength);
for(int i = 0;i < charsLength;i++) {
aChar = chars[i];
type = getType(aChar);
switch(type) {
case 1:
bytes.add((byte)aChar);
break;
case 2:
{
int code = 0b1100000010000000;
code |= (aChar & 0b111111);
code |= ((aChar & 0b11111000000) << 2);
bytes.add((byte)(code >> 8));
bytes.add((byte)code);
}
break;
case 3:
{
int code = 0b111000001000000010000000;
code |= (aChar & 0b111111);
code |= ((aChar & 0b111111000000) << 2);
code |= ((aChar & 0b1111000000000000) << 4);
bytes.add((byte) (code >> 16));
bytes.add((byte) (code >> 8));
bytes.add((byte) code);
}
break;
case 4:
{
int code = 0b11100000100000001000000010000000;
code |= (aChar & 0b111111);
code |= ((aChar & 0b111111000000) << 2);
code |= ((aChar & 0b111111000000000000) << 4);
code |= ((aChar & 0b111000000000000000000) << 6);
bytes.add((byte) (code >> 24));
bytes.add((byte) (code >> 16));
bytes.add((byte) (code >> 8));
bytes.add((byte) code);
}
break;
default:
// nothing to do.
}
}
}else {
// 返回一個空的字節(jié)緩存區(qū)
bytes = new Bytes(0);
}
return bytes;
}
/**
* 返回值表示一個字符 aChar 的編碼空間（即 需占用的字節(jié)數(shù)），返回值如下 4 種：
*
1，表示使用 1 個字節(jié)編碼字符 aChar 對應(yīng)的數(shù)值
*
2，表示使用 2 個字節(jié)編碼字符 aChar 對應(yīng)的數(shù)值
*
3，表示使用 3 個字節(jié)編碼字符 aChar 對應(yīng)的數(shù)值
*
4，表示使用 4 個字節(jié)編碼字符 aChar 對應(yīng)的數(shù)值
* <b4> 如果 aChar 是無效的 UTF-8 字符，可選擇拋出異常：IllegalArgumentException，或忽略
*/
public static int getType(int aChar) {
if (!Character.isValidCodePoint(aChar)) {
// throw new IllegalArgumentException(aChar + " is invalid code point");
return 0;
}
if(0 <= aChar && aChar <= 127) {
// a char of ascii
return 1;
}else if(128 <= aChar && aChar <= 2047) {
return 2;
}else if(2048 <= aChar && aChar <= 65535) {
return 3;
}else if(65536 <= aChar && aChar <= 2097151) {
return 4;
}else {
// throw new IllegalArgumentException(aChar + " is invalid code point");
return 0;
}
}
/** 組合一個字節(jié)緩存區(qū) bytes 及其 長度值 length */
public static class Bytes {
private int length;
private final int capacity;
private byte[] bytes;
public Bytes(int capacity) {
this.length = 0;
this.capacity = capacity;
this.bytes = new byte[capacity];
}
/** 向該緩存區(qū)中添加一個字節(jié) */
public void add(byte aByte) {
if (length < capacity) {
bytes[length++] = aByte;
}else {
throw new ArrayIndexOutOfBoundsException("當前緩存區(qū)已滿，capacity = length is " + capacity);
}
}
public int getLength() {
return length;
}
public byte[] getBytes() {
return bytes;
}
public int getCapacity() {
return capacity;
}
}
}
總結(jié)
到此這篇關(guān)于Java中String使用方法及分析的文章就介紹到這了,更多相關(guān)Java中String使用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
本篇文章為大家詳細介紹了怎么用Java數(shù)組和鏈表實現(xiàn)棧,文中有非常詳細的代碼示例及注釋,對正在學習java的小伙伴們很有幫助,需要的朋友可以參考下2021-05-05
SpringBoot中application.properties與application.yml區(qū)別小結(jié)
本文主要介紹了SpringBoot中application.properties與application.yml區(qū)別小結(jié),文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2023-10-10
springboot整合vue2-uploader實現(xiàn)文件分片上傳、秒傳、斷點續(xù)傳功能
對于大文件的處理,無論是用戶端還是服務(wù)端,如果一次性進行讀取發(fā)送、接收都是不可取,很容易導致內(nèi)存問題,下面這篇文章主要給大家介紹了關(guān)于springboot整合vue2-uploader實現(xiàn)文件分片上傳、秒傳、斷點續(xù)傳功能的相關(guān)資料,需要的朋友可以參考下2023-06-06
Java?ConcurrentHashMap實現(xiàn)線程安全的代碼示例
眾所周知ConcurrentHashMap是HashMap的多線程版本，HashMap?在并發(fā)操作時會有各種問題，而這些問題，只要使用ConcurrentHashMap就可以完美解決了，本文將給詳細介紹ConcurrentHashMap是如何保證線程安全的2023-05-05
Java 實用注解篇之@Qualifier 深度解析及實戰(zhàn)案例
在Spring框架中,@Qualifier是一個常見的注解,主要用于解決依賴注入（DI）時的歧義性,本文給大家介紹Java 實用注解篇之@Qualifier 深度解析及實戰(zhàn)案例,感興趣的朋友一起看看吧2025-06-06
這篇文章主要介紹了Java Arrays.AsList原理及用法實例,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-11-11
這篇文章主要為大家介紹了RocketMQ消息發(fā)送流程源碼剖析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-08-08
這篇文章主要介紹了Springmvc異常映射2種實現(xiàn)方法以上就是本文的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。,需要的朋友可以參考下2020-05-05
下面小編就為大家?guī)硪黄猯og4j2日志異步打印(實例講解)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-10-10
這篇文章主要介紹了Java類鎖、對象鎖、私有鎖沖突測試,得出結(jié)論是加鎖方法夠成了競爭關(guān)系,同一時刻只能有一個方法能執(zhí)行,需要的朋友可以參考下2014-10-10