目前的文字编码标准主要有 ASCII、GB2312、GBK、Unicode等。ASCII 编码是最简单的西文编码方案。GB2312、GBK、GB18030 是汉字字符编码方案的国家标准。ISO/IEC 10646 和 Unicode 都是全球字符编码的国际标准。

java中字符串与hex数据转换

package org.example;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;


public class DemoMain {

    public static void main(String[] args) throws UnsupportedEncodingException {
        String text = "hello中国1234";
        byte[] defaultBytes = text.getBytes();
        byte[] utf8Bytes = text.getBytes(StandardCharsets.UTF_8);
        byte[] iso8895Bytes = text.getBytes(StandardCharsets.ISO_8859_1);
        byte[] asciiBytes = text.getBytes(StandardCharsets.US_ASCII);
        byte[] gbkBytes = text.getBytes("GBK");
        byte[] gb2312Bytes = text.getBytes("GB2312");
        print("default", defaultBytes);
        print("UTF_8", utf8Bytes);
        print("ISO_8859_1", iso8895Bytes);
        print("US_ASCII", asciiBytes);
        print("GBK", gbkBytes);
        print("GB2312", gb2312Bytes);
        System.out.println("Hex =" + utf8String2Hex(text));
        System.out.println("unicode2Hex =" + unicode2Hex(text));
        System.out.println("hex2String = " + hex2String(utf8String2Hex(text)));

        for (int i = 0; i < text.length(); i++) {
            String e = String.valueOf(text.charAt(i));
            byte[] bytes = e.getBytes(StandardCharsets.UTF_8);
            String hex = bytesToHex(bytes);
            System.out.println("字符=" + e + "  byte =" + bytes2String(bytes) + "  ASCII=" + bytes2ASCII(bytes) + "  " + "HEX=" + hex);
        }
    }

    private static void print(String charsetName, byte[] bytes) {
        System.out.print(charsetName + " : ");
        for (byte b : bytes) {
            System.out.print(b + " ");
        }
        System.out.println();
    }

    private static String bytes2String(byte[] bytes) {
        String val = "";
        for (byte b : bytes) {
            val += b + " , ";
        }
        return val;
    }

    private static String bytes2ASCII(byte[] bytes) {
        String val = "";
        for (byte b : bytes) {
            val += (b & 0xff) + " , ";
        }
        return val;
    }

    private static String bytesToHex(byte[] bytes) {
        if (bytes == null) {
            return null;
        }
        StringBuilder buff = new StringBuilder();
        int len = bytes.length;
        for (int j = 0; j < len; j++) {
            buff.append(String.format("%02X", bytes[j] & 0xff));
        }
        return buff.toString().toUpperCase();
    }

    private static String utf8String2Hex(String txt) {
        // 方法1：转换为UTF-8字节后转Hex（推荐用于中文）
        StringBuilder hexBuilder = new StringBuilder();
        byte[] bytes = txt.getBytes(java.nio.charset.StandardCharsets.UTF_8);
        for (byte b : bytes) {
            hexBuilder.append(String.format("%02X", b));
        }
        return hexBuilder.toString();
    }

    private static String unicode2Hex(String txt) {
        // 方法2：直接按字符Unicode码点转Hex（适用于基本字符）
        StringBuilder unicodeHexBuilder = new StringBuilder();
        for (char c : txt.toCharArray()) {
            unicodeHexBuilder.append(String.format("%04X", (int) c));
        }
        return unicodeHexBuilder.toString();
    }

    public static String hex2String(String hex) {
        int len = hex.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            // 每两个十六进制字符转换为一个字节
            data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4) + Character.digit(hex.charAt(i + 1), 16));
        }
        String result = new String(data, StandardCharsets.UTF_8);
        return result;
    }
}

运行结果如下:

default : 		104 101 108 108 111 -28 -72 -83 -27 -101 -67 49 50 51 52 
UTF_8 :   		104 101 108 108 111 -28 -72 -83 -27 -101 -67 49 50 51 52 
ISO_8859_1 : 	104 101 108 108 111 63 63 49 50 51 52 
US_ASCII : 		104 101 108 108 111 63 63 49 50 51 52 
GBK : 			104 101 108 108 111 -42 -48 -71 -6 49 50 51 52 
GB2312 : 		104 101 108 108 111 -42 -48 -71 -6 49 50 51 52 
Hex =			68656C6C6FE4B8ADE59BBD31323334
unicode2Hex =	00680065006C006C006F4E2D56FD0031003200330034
hex2String = 	hello中国1234
字符=h  byte =104 ,   ASCII=104 ,   HEX=68
字符=e  byte =101 ,   ASCII=101 ,   HEX=65
字符=l  byte =108 ,   ASCII=108 ,   HEX=6C
字符=l  byte =108 ,   ASCII=108 ,   HEX=6C
字符=o  byte =111 ,   ASCII=111 ,   HEX=6F
字符=中  byte =-28 , -72 , -83 ,   ASCII=228 , 184 , 173 ,   HEX=E4B8AD
字符=国  byte =-27 , -101 , -67 ,   ASCII=229 , 155 , 189 ,   HEX=E59BBD
字符=1  byte =49 ,   ASCII=49 ,   HEX=31
字符=2  byte =50 ,   ASCII=50 ,   HEX=32
字符=3  byte =51 ,   ASCII=51 ,   HEX=33
字符=4  byte =52 ,   ASCII=52 ,   HEX=34

字符串与Unicode互转

字符串转unicode

以下是使用 Java 将字符串 “hello中国1234” 转换为 Unicode 编码的完整代码：

public class StringToUnicode {
    public static void main(String[] args) {
        String input = "hello中国1234";
        
        // 方法1：转换为Unicode转义序列格式（\uXXXX）
        StringBuilder unicodeBuilder = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            unicodeBuilder.append(String.format("\\u%04X", (int) c));
        }
        System.out.println("Unicode转义序列: " + unicodeBuilder.toString());
        
        // 方法2：转换为Unicode码点格式（U+XXXX）
        StringBuilder codePointBuilder = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            int codePoint = input.codePointAt(i);
            // 处理代理对（surrogate pairs），用于表示BMP之外的字符
            if (Character.isHighSurrogate(input.charAt(i))) {
                i++; // 跳过低位代理
            }
            codePointBuilder.append(String.format("U+%04X ", codePoint));
        }
        System.out.println("Unicode码点: " + codePointBuilder.toString());
        
        // 方法3：获取每个字符的Unicode数值
        StringBuilder numericBuilder = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            int codePoint = input.codePointAt(i);
            if (Character.isHighSurrogate(input.charAt(i))) {
                i++; // 跳过低位代理
            }
            numericBuilder.append(codePoint).append(" ");
        }
        System.out.println("Unicode数值: " + numericBuilder.toString());
    }
}

输出结果：

Unicode转义序列: \u0068\u0065\u006C\u006C\u006F\u4E2D\u56FD\u0031\u0032\u0033\u0034
Unicode码点: U+0068 U+0065 U+006C U+006C U+006F U+4E2D U+56FD U+0031 U+0032 U+0033 U+0034 
Unicode数值: 104 101 108 108 111 20013 22269 49 50 51 52

Unicode转义序列格式（\uXXXX）：

这是Java中表示Unicode字符的标准方式
每个字符用6个字符表示：\u + 4位十六进制数字
适用于在Java源代码中直接使用

Unicode码点格式（U+XXXX）：

这是Unicode标准表示法
每个字符用U+ + 4位十六进制数字表示
更通用，常用于文档和标准中

Unicode数值：

直接显示每个字符的十进制Unicode码点值
对于中文字符，显示的是较大的数值（如”中”=20013，”国”=22269）

注意事项：

对于基本多文种平面（BMP）内的字符（U+0000到U+FFFF），使用4位十六进制表示足够
对于辅助平面字符（如一些表情符号），需要使用5-6位十六进制表示
示例中的”hello中国1234”所有字符都在BMP内，所以4位十六进制足够表示

Unicode 转换为字符串

有多种方式可以将 Unicode 表示（如 \uXXXX 格式或 Unicode 码点）转换回原始字符串。以下是几种常见的方法：

方法1：处理 Unicode 转义序列（\uXXXX）

public class UnicodeToString {
    public static void main(String[] args) {
        // Unicode 转义序列
        String unicodeEscape = "\\u0068\\u0065\\u006C\\u006C\\u006F\\u4E2D\\u56FD\\u0031\\u0032\\u0033\\u0034";
        
        // 将Unicode转义序列转换为字符串
        String result = convertUnicodeEscape(unicodeEscape);
        System.out.println("转换结果: " + result);
    }
    
    public static String convertUnicodeEscape(String unicodeEscape) {
        StringBuilder sb = new StringBuilder();
        String[] hexValues = unicodeEscape.split("\\\\u");
        
        // 跳过第一个空字符串（因为分割后第一个元素是空）
        for (int i = 1; i < hexValues.length; i++) {
            int hexVal = Integer.parseInt(hexValues[i], 16);
            sb.append((char) hexVal);
        }
        
        return sb.toString();
    }
}

方法2：使用 Java 内置的 Unicode 处理

public class UnicodeToString {
    public static void main(String[] args) {
        // 方法2：直接使用Java字符串（编译器会自动处理Unicode转义）
        String unicodeString = "\u0068\u0065\u006C\u006C\u006F\u4E2D\u56FD\u0031\u0032\u0033\u0034";
        System.out.println("直接Unicode字符串: " + unicodeString);
        
        // 方法3：从码点数组创建字符串
        int[] codePoints = {0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x4E2D, 0x56FD, 0x31, 0x32, 0x33, 0x34};
        String fromCodePoints = new String(codePoints, 0, codePoints.length);
        System.out.println("从码点创建: " + fromCodePoints);
    }
}

方法3：处理不同格式的 Unicode 输入

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class UnicodeToString {
    public static void main(String[] args) {
        // 处理不同格式的Unicode表示
        String mixedUnicode = "U+0068 U+0065 U+006C U+006C U+006F U+4E2D U+56FD U+0031 U+0032 U+0033 U+0034";
        String result = convertMixedUnicode(mixedUnicode);
        System.out.println("混合格式转换: " + result);
    }
    
    public static String convertMixedUnicode(String input) {
        StringBuilder sb = new StringBuilder();
        
        // 使用正则表达式匹配不同格式的Unicode表示
        Pattern pattern = Pattern.compile("(\\\\u[0-9A-Fa-f]{4})|(U\\+[0-9A-Fa-f]{4})");
        Matcher matcher = pattern.matcher(input);
        
        while (matcher.find()) {
            String match = matcher.group();
            String hexValue;
            
            if (match.startsWith("\\u")) {
                hexValue = match.substring(2);
            } else {
                hexValue = match.substring(2); // 去掉"U+"
            }
            
            int codePoint = Integer.parseInt(hexValue, 16);
            sb.append((char) codePoint);
        }
        
        return sb.toString();
    }
}

方法4：处理包含文字和 Unicode 的混合字符串

public class UnicodeToString {
    public static void main(String[] args) {
        // 处理混合了普通文本和Unicode转义的字符串
        String mixedString = "hello\\u4E2D\\u56FD1234";
        String result = parseMixedContent(mixedString);
        System.out.println("混合内容转换: " + result);
    }
    
    public static String parseMixedContent(String input) {
        StringBuilder sb = new StringBuilder();
        int i = 0;
        while (i < input.length()) {
            if (i < input.length() - 5 && 
                input.charAt(i) == '\\' && 
                input.charAt(i + 1) == 'u') {
                // 找到Unicode转义序列
                String hex = input.substring(i + 2, i + 6);
                int codePoint = Integer.parseInt(hex, 16);
                sb.append((char) codePoint);
                i += 6;
            } else {
                // 普通字符
                sb.append(input.charAt(i));
                i++;
            }
        }
        return sb.toString();
    }
}

所有上述方法都会输出：

转换结果: hello中国1234

注意事项

Unicode 转义格式：Java 中的 Unicode 转义序列格式是 \uXXXX，其中 XXXX 是 4 位十六进制数字。
字符编码：确保正确处理字符编码，特别是处理非 BMP 字符（需要代理对）时。
错误处理：在实际应用中，应该添加适当的错误处理，例如处理无效的十六进制值。
性能考虑：对于大量数据处理，可以考虑使用更高效的方法，如预编译正则表达式。

字符转为二进制

如果明确使用UTF-8编码，字符串”中”中的字符数仍然是1，但是占用的字节数会根据编码方式不同而有所变化。

在UTF-8编码中，一个中文字符占用3个字节。因此，字符串”中”在UTF-8编码下占用的字节数是3。

下面是具体的处理代码示例：

package org.example;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String text = "中";
        int charCount = text.length();
        //字符数：1
        System.out.println("字符数：" + charCount);
        System.out.println("\r\n");

        //UTF-8编码下字节数：3
        //UTF-8编码下字节数的二进制表示：11100100 10111000 10101101
        printArray(text, StandardCharsets.UTF_8.name());
        System.out.println("\r\n");

        //US-ASCII编码下字节数：1
        //US-ASCII编码下字节数的二进制表示：111111
        printArray(text, StandardCharsets.US_ASCII.name());
        System.out.println("\r\n");

        //unicode编码下字节数：4
        //unicode编码下字节数的二进制表示：11111110 11111111 1001110 101101
        printArray(text, "unicode");
        System.out.println("\r\n");


        //GB2312 兼容 ASICII 编码, GBK 兼容 GB2312 编码，GB18030 兼容 GB2312 编码 和 GBK 编码

        //GB18030编码下字节数：2
        //GB18030编码下字节数的二进制表示：11010110 11010000
        printArray(text, "GB18030");
        System.out.println("\r\n");

        //GB2312编码下字节数：2
        //GB2312编码下字节数的二进制表示：11010110 11010000
        printArray(text, "GB2312");
        System.out.println("\r\n");

        //GBK编码下字节数：2
        //GBK编码下字节数的二进制表示：11010110 11010000 
        printArray(text, "GBK");
        System.out.println("\r\n");
    }

    private static void printArray(String text, String charsetName) throws UnsupportedEncodingException {
        byte[] bytes = text.getBytes(charsetName);
        System.out.println(charsetName + "编码下字节数：" + bytes.length);
        System.out.print(charsetName + "编码下字节数的二进制表示：");
        for (byte b : bytes) {
            System.out.print(Integer.toBinaryString(b & 0xFF) + " ");
        }
    }
}

运行以上代码，输出如下：

字符数：1

UTF-8编码下字节数：3
UTF-8编码下字节数的二进制表示：11100100 10111000 10101101 

US-ASCII编码下字节数：1
US-ASCII编码下字节数的二进制表示：111111 

unicode编码下字节数：4
unicode编码下字节数的二进制表示：11111110 11111111 1001110 101101 

GB18030编码下字节数：2
GB18030编码下字节数的二进制表示：11010110 11010000 

GB2312编码下字节数：2
GB2312编码下字节数的二进制表示：11010110 11010000 

GBK编码下字节数：2
GBK编码下字节数的二进制表示：11010110 11010000

以上代码使用getBytes(StandardCharsets.UTF_8)方法将字符串转换为UTF-8编码的字节数组，并通过循环输出每个字节的二进制表示。

二进制转为字符

要将二进制数据 11100100 10111000 10101101 转换为UTF-8编码格式的字符，可以使用Java的String和StandardCharsets类。

以下是一个示例代码，演示了如何将二进制数据转换为UTF-8编码格式的字符：

import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) {
        byte[] bytes = { (byte) 0b11100100, (byte) 0b10111000, (byte) 0b10101101 };
        
        try {
            String str = new String(bytes, StandardCharsets.UTF_8);
            System.out.println("转换后的字符串：" + str);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行以上代码，输出如下：

转换后的字符串：中

以上代码使用String类的构造方法，将字节数组以UTF-8编码格式转换为字符串。StandardCharsets.UTF_8表示使用UTF-8编码。最后输出转换后的字符串”中”。

怎么将字符串 11100100 转为二进制数据byte

String text = "11100100";
    
    try {
        byte data = (byte) Integer.parseInt(text, 2);
        System.out.println("转换后的byte数据：" + data);
    } catch (NumberFormatException e) {
        e.printStackTrace();
    }

另外一种方法

@Test
public void test03() {

    String text = "11100100 10111000 10101101";

    final String[] tokens = text.split(" ");
    List<Byte> byteList = new ArrayList<>();

    for (String token : tokens) {
        byte data = (byte)Integer.parseInt(token, 2);
        byteList.add(data);
    }

    byte[] bytes = new byte[byteList.size()];

    for (int i = 0; i < byteList.size(); i++) {
        bytes[i] = byteList.get(i);
    }

    try {
        String str = new String(bytes, StandardCharsets.UTF_8);
        System.out.println("转换后的字符串：" + str);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出的结果为

转换后的字符串：中

java中数字转为16进制时为什么要先执行 & 0xFF 操作

在Java中，数字转换为16进制时，执行 & 0xFF 操作是为了确保结果是一个有效的8位无符号整数。

在Java中，整数类型是有符号的，即它们可以表示正数和负数。当将一个有符号整数转换为16进制时，如果不执行 & 0xFF 操作，那么结果可能会包含负号，或者超过16进制的有效范围。

执行 & 0xFF 操作可以将一个有符号整数的高24位清零，只保留低8位。由于无符号整数的范围是0到255（即16进制的00到FF），所以执行 & 0xFF 操作可以确保结果在有效的16进制范围内。

以下是一个示例，说明为什么要执行 & 0xFF 操作：

int number = -1; // 有符号整数，表示为二进制的 11111111 11111111 11111111 11111111

String hex = Integer.toHexString(number);
System.out.println(hex); // 输出 ffffffff

hex = Integer.toHexString(number & 0xFF);
System.out.println(hex); // 输出 ff

在第一个示例中，由于没有执行 & 0xFF 操作，转换结果包含了负号和32个字符，这是因为在转换为16进制时，Java将有符号整数视为32位整数。

在第二个示例中，执行了 & 0xFF 操作，结果只保留了低8位，所以转换结果是一个有效的16进制数字。

golang中字符串与hex数据转换

使用Go语言将字符串转换为十六进制（hex）表示，然后再转换回字符串的过程可以通过标准库中的encoding/hex包实现。以下是完整的代码示例：

originalStr := "hello中国1234"

	// 将字符串转换为字节切片
	byteData := []byte(originalStr)
	fmt.Print("byte:")
	for i := 0; i < len(byteData); i++ {
		fmt.Print(byteData[i])
		fmt.Print(" ")
	}
	fmt.Println("")
	fmt.Print("hex:")
	for i := 0; i < len(byteData); i++ {
		fmt.Printf("%X", byteData[i])
		fmt.Print(" ")
	}
	fmt.Println("")

	// 将字节切片转换为hex字符串
	hexStr := hex.EncodeToString(byteData)
	fmt.Printf("Hex: %s\n", hexStr)
	fmt.Printf("Hex: %s\n", strings.ToUpper(hexStr))

	// 将hex字符串转换回字节切片
	decodedBytes, err := hex.DecodeString(hexStr)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print("decodedBytes:")
	for i := 0; i < len(decodedBytes); i++ {
		fmt.Print(decodedBytes[i])
		fmt.Print(" ")
	}
	fmt.Println("")
	// 将字节切片转换为原始字符串
	decodedStr := string(decodedBytes)
	fmt.Printf("String: %s\n", decodedStr)

	runes := []rune(originalStr)
	fmt.Print("runes:")
	for i := 0; i < len(runes); i++ {
		fmt.Print(runes[i])
		fmt.Print(" ")
	}
	fmt.Println("")

输出结果：

byte:			104 101 108 108 111 228 184 173 229 155 189 49 50 51 52 
hex:			68 65 6C 6C 6F E4 B8 AD E5 9B BD 31 32 33 34 
Hex: 			68656c6c6fe4b8ade59bbd31323334
Hex: 			68656C6C6FE4B8ADE59BBD31323334
decodedBytes:	        104 101 108 108 111 228 184 173 229 155 189 49 50 51 52 
String: 		        hello中国1234
runes:			104 101 108 108 111 20013 22269 49 50 51 52

步骤解析：

字符串转Hex：通过hex.EncodeToString将字符串的字节切片（UTF-8编码）转换为十六进制字符串。
Hex转字符串：通过hex.DecodeString将十六进制字符串解码为原始字节切片，再通过string()转换为字符串。

注意：

中文字符“中国”在UTF-8编码下占6个字节（每个汉字3字节），因此转换后的Hex长度会相应增加。
确保Hex字符串的格式正确（偶数长度、有效的十六进制字符），否则解码会失败。

golang遍历字符串

func Test_0003(t *testing.T) {
	originalStr := "hello中国1234"

	fmt.Printf("原始字符串: %s\n", originalStr)
	fmt.Printf("字符串长度(字节数): %d\n", len(originalStr))
	fmt.Println("使用range遍历:")

	// 使用range遍历字符串
	for i, char := range originalStr {
		fmt.Print(" i = " + strconv.Itoa(i) + " char " + string(char))
		fmt.Printf("  索引位置: %d, Unicode码点: %U, 字符: %c\n", i, char, char)
	}

	fmt.Println("\n转换为rune切片后遍历:")
	// 另一种方式：将字符串转换为rune切片后再遍历
	runes := []rune(originalStr)
	for i, char := range runes {
		fmt.Print(" i = " + strconv.Itoa(i) + " char " + string(char))
		fmt.Printf("  索引位置: %d, Unicode码点: %U, 字符: %c\n", i, char, char)
	}
}

运行结果为：

原始字符串: hello中国1234
字符串长度(字节数): 15
使用range遍历:
 i = 0 char h  索引位置: 0, Unicode码点: U+0068, 字符: h
 i = 1 char e  索引位置: 1, Unicode码点: U+0065, 字符: e
 i = 2 char l  索引位置: 2, Unicode码点: U+006C, 字符: l
 i = 3 char l  索引位置: 3, Unicode码点: U+006C, 字符: l
 i = 4 char o  索引位置: 4, Unicode码点: U+006F, 字符: o
 i = 5 char 中  索引位置: 5, Unicode码点: U+4E2D, 字符: 中
 i = 8 char 国  索引位置: 8, Unicode码点: U+56FD, 字符: 国
 i = 11 char 1  索引位置: 11, Unicode码点: U+0031, 字符: 1
 i = 12 char 2  索引位置: 12, Unicode码点: U+0032, 字符: 2
 i = 13 char 3  索引位置: 13, Unicode码点: U+0033, 字符: 3
 i = 14 char 4  索引位置: 14, Unicode码点: U+0034, 字符: 4

转换为rune切片后遍历:
 i = 0 char h  索引位置: 0, Unicode码点: U+0068, 字符: h
 i = 1 char e  索引位置: 1, Unicode码点: U+0065, 字符: e
 i = 2 char l  索引位置: 2, Unicode码点: U+006C, 字符: l
 i = 3 char l  索引位置: 3, Unicode码点: U+006C, 字符: l
 i = 4 char o  索引位置: 4, Unicode码点: U+006F, 字符: o
 i = 5 char 中  索引位置: 5, Unicode码点: U+4E2D, 字符: 中
 i = 6 char 国  索引位置: 6, Unicode码点: U+56FD, 字符: 国
 i = 7 char 1  索引位置: 7, Unicode码点: U+0031, 字符: 1
 i = 8 char 2  索引位置: 8, Unicode码点: U+0032, 字符: 2
 i = 9 char 3  索引位置: 9, Unicode码点: U+0033, 字符: 3
 i = 10 char 4  索引位置: 10, Unicode码点: U+0034, 字符: 4

ASCII码对照表

ASCII（发音：，American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统。它主要用于显示现代英语，而其扩展版本延伸美国标准信息交换码则可以部分支持其他西欧语言，并等同于国际标准ISO/IEC 646。

ASCII 由电报码发展而来。第一版标准发布于1963年，1967年经历了一次主要修订[5][6]，最后一次更新则是在1986年，至今为止共定义了128个字符；其中33个字符无法显示（一些终端提供了扩展，使得这些字符可显示为诸如笑脸、扑克牌花式等8-bit符号），且这33个字符多数都已是陈废的控制字符。控制字符的用途主要是用来操控已经处理过的文字。在33个字符之外的是95个可显示的字符。用键盘敲下空白键所产生的空白字符也算1个可显示字符（显示为空白）。

ASCII码表（控制字符）

编码范围：0-31，ASCII控制字符不可显示。

在ASCII码表中，前32个字符是不能用于打印控制的编码，而是用于控制像打印机一样的外围设备。

十进制 DEC	八进制 OCT	十六进制 HEX	二进制 BIN	符号 Symbol	HTML 实体编码	中文解释 Description
0	000	00	00000000	NUL	``	空字符
1	001	01	00000001	SOH	``	标题开始
2	002	02	00000010	STX	``	正文开始
3	003	03	00000011	ETX	``	正文结束
4	004	04	00000100	EOT	``	传输结束
5	005	05	00000101	ENQ	``	询问
6	006	06	00000110	ACK	``	收到通知
7	007	07	00000111	BEL	``	铃
8	010	08	00001000	BS	``	退格
9	011	09	00001001	HT	` `	水平制表符
10	012	0A	00001010	LF	` `	换行键
11	013	0B	00001011	VT	``	垂直制表符
12	014	0C	00001100	FF	``	换页键
13	015	0D	00001101	CR	` `	回车键
14	016	0E	00001110	SO	``	移出
15	017	0F	00001111	SI	``	移入
16	020	10	00010000	DLE	``	数据链路转义
17	021	11	00010001	DC1	``	设备控制 1
18	022	12	00010010	DC2	``	设备控制 2
19	023	13	00010011	DC3	``	设备控制 3
20	024	14	00010100	DC4	``	设备控制 4
21	025	15	00010101	NAK	``	拒绝接收
22	026	16	00010110	SYN	``	同步空闲
23	027	17	00010111	ETB	``	传输块结束
24	030	18	00011000	CAN	``	取消
25	031	19	00011001	EM	``	介质中断
26	032	1A	00011010	SUB	``	替换
27	033	1B	00011011	ESC	``	换码符
28	034	1C	00011100	FS	``	文件分隔符
29	035	1D	00011101	GS	``	组分隔符
30	036	1E	00011110	RS	``	记录分离符
31	037	1F	00011111	US	``	单元分隔符

ASCII码表（打印字符）

编码范围：32-127，可打印字符包含字母、数字、标点符号等。

32～126(共95个)是字符：32是空格，其中48～57为0到9十个阿拉伯数字，65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等。第127个字符表示的是键盘上的删除命令。

十进制 DEC	八进制 OCT	十六进制 HEX	二进制 BIN	符号 Symbol	HTML 实体编码	中文解释 Description
32	040	20	00100000		` `	空格
33	041	21	00100001	!	`!`	感叹号
34	042	22	00100010	“	`"`	双引号
35	043	23	00100011	#	`#`	井号
36	044	24	00100100	$	`$`	美元符
37	045	25	00100101	%	`%`	百分号
38	046	26	00100110	&	`&`	与
39	047	27	00100111	‘	`'`	单引号
40	050	28	00101000	(	`(`	左括号
41	051	29	00101001	)	`)`	右括号
42	052	2A	00101010	*	`*`	星号
43	053	2B	00101011	+	`+`	加号
44	054	2C	00101100	,	`,`	逗号
45	055	2D	00101101	-	`-`	连字号或减号
46	056	2E	00101110	.	`.`	句点或小数点
47	057	2F	00101111	/	`/`	斜杠
48	060	30	00110000	0	`0`	0
49	061	31	00110001	1	`1`	1
50	062	32	00110010	2	`2`	2
51	063	33	00110011	3	`3`	3
52	064	34	00110100	4	`4`	4
53	065	35	00110101	5	`5`	5
54	066	36	00110110	6	`6`	6
55	067	37	00110111	7	`7`	7
56	070	38	00111000	8	`8`	8
57	071	39	00111001	9	`9`	9
58	072	3A	00111010	:	`:`	冒号
59	073	3B	00111011	;	`;`	分号
60	074	3C	00111100	<	`<`	小于
61	075	3D	00111101	=	`=`	等号
62	076	3E	00111110	>	`>`	大于
63	077	3F	00111111	?	`?`	问号
64	100	40	01000000	@	`@`	电子邮件符号
65	101	41	01000001	A	`A`	大写字母 A
66	102	42	01000010	B	`B`	大写字母 B
67	103	43	01000011	C	`C`	大写字母 C
68	104	44	01000100	D	`D`	大写字母 D
69	105	45	01000101	E	`E`	大写字母 E
70	106	46	01000110	F	`F`	大写字母 F
71	107	47	01000111	G	`G`	大写字母 G
72	110	48	01001000	H	`H`	大写字母 H
73	111	49	01001001	I	`I`	大写字母 I
74	112	4A	01001010	J	`J`	大写字母 J
75	113	4B	01001011	K	`K`	大写字母 K
76	114	4C	01001100	L	`L`	大写字母 L
77	115	4D	01001101	M	`M`	大写字母 M
78	116	4E	01001110	N	`N`	大写字母 N
79	117	4F	01001111	O	`O`	大写字母 O
80	120	50	01010000	P	`P`	大写字母 P
81	121	51	01010001	Q	`Q`	大写字母 Q
82	122	52	01010010	R	`R`	大写字母 R
83	123	53	01010011	S	`S`	大写字母 S
84	124	54	01010100	T	`T`	大写字母 T
85	125	55	01010101	U	`U`	大写字母 U
86	126	56	01010110	V	`V`	大写字母 V
87	127	57	01010111	W	`&#087	大写字母 W
88	130	58	01011000	X	`X`	大写字母 X
89	131	59	01011001	Y	`Y`	大写字母 Y
90	132	5A	01011010	Z	`Z`	大写字母 Z
91	133	5B	01011011	[	`[`	左中括号
92	134	5C	01011100	\	`\`	反斜杠
93	135	5D	01011101	]	`]`	右中括号
94	136	5E	01011110	^	`^`	音调符号
95	137	5F	01011111	_	`_`	下划线
96	140	60	01100000	`	```	重音符
97	141	61	01100001	a	`a`	小写字母 a
98	142	62	01100010	b	`b`	小写字母 b
99	143	63	01100011	c	`c`	小写字母 c
100	144	64	01100100	d	`d`	小写字母 d
101	145	65	01100101	e	`e`	小写字母 e
102	146	66	01100110	f	`f`	小写字母 f
103	147	67	01100111	g	`g`	小写字母 g
104	150	68	01101000	h	`h`	小写字母 h
105	151	69	01101001	i	`i`	小写字母 i
106	152	6A	01101010	j	`j`	小写字母 j
107	153	6B	01101011	k	`k`	小写字母 k
108	154	6C	01101100	l	`l`	小写字母 l
109	155	6D	01101101	m	`m`	小写字母 m
110	156	6E	01101110	n	`n`	小写字母 n
111	157	6F	01101111	o	`o`	小写字母 o
112	160	70	01110000	p	`p`	小写字母 p
113	161	71	01110001	q	`q`	小写字母 q
114	162	72	01110010	r	`r`	小写字母 r
115	163	73	01110011	s	`s`	小写字母 s
116	164	74	01110100	t	`t`	小写字母 t
117	165	75	01110101	u	`u`	小写字母 u
118	166	76	01110110	v	`v`	小写字母 v
119	167	77	01110111	w	`w`	小写字母 w
120	170	78	01111000	x	`x`	小写字母 x
121	171	79	01111001	y	`y`	小写字母 y
122	172	7A	01111010	z	`z`	小写字母 z
123	173	7B	01111011	{	`{`	左大括号
124	174	7C	01111100	\		`\|`	垂直线
125	175	7D	01111101	}	`}`	右大括号
126	176	7E	01111110	~	`~`	波浪号
127	177	7F	01111111		``	删除

ASCII码表（扩展字符）

ASCII码对照表后128个称为扩展ASCII码。许多基于x86的系统都支持使用扩展（或“高”）ASCII。扩展ASCII码允许将每个字符的第8位用于确定附加的128个特殊符号字符、外来语字母和图形符号。

十进制 DEC	八进制 OCT	十六进制 HEX	二进制 BIN	符号 Symbol	HTML 实体编码	中文解释 Description
128	200	80	10000000	€	``	欧盟符号
129	201	81	10000001
130	202	82	10000010	?	``	单低 9 引号
131	203	83	10000011	?	``	带钩的拉丁小写字母f
132	204	84	10000100	?	``	双低 9 引号
133	205	85	10000101	…	``	水平省略号
134	206	86	10000110	?	``	剑号
135	207	87	10000111	?	``	双剑号
136	210	88	10001000	?	``	修正字符抑扬音符号
137	211	89	10001001	‰	``	千分号
138	212	8A	10001010	?	``	带弯音号的拉丁大写字母 S
139	213	8B	10001011	?	``	左单书名号
140	214	8C	10001100	?	``	拉丁大写组合 OE
141	215	8D	10001101
142	216	8E	10001110	?	``	带弯音号的拉丁大写字母 z
143	217	8F	10001111
144	220	90	10010000
145	221	91	10010001	‘	``	左单引号
146	222	92	10010010	’	``	右单引号
147	223	93	10010011	“	``	左双引号
148	224	94	10010100	”	``	右双引号
149	225	95	10010101	?	``
150	226	96	10010110	–	``	半长破折号
151	227	97	10010111	—	``	全长破折号
152	230	98	10011000	?	``	小波浪线
153	231	99	10011001	?	``
154	232	9A	10011010	?	``	带弯音号的拉丁小写字母 s
155	233	9B	10011011	?	``	右单书名号
156	234	9C	10011100	?	``	拉丁小写组合 oe
157	235	9D	10011101
158	236	9E	10011110	?	``	带弯音号的拉丁小写字母 z
159	237	9F	10011111	?	``	带弯音号的拉丁大写字母 Y
160	240	A0	10100000		` `
161	241	A1	10100001	?	`¡`	反向感叹号
162	242	A2	10100010	?	`¢`	分币符号
163	243	A3	10100011	?	`£`	英磅符号
164	244	A4	10100100	¤	`¤`
165	245	A5	10100101	?	`¥`	人民币符号
166	246	A6	10100110	?	`¦`
167	247	A7	10100111	§	`§`	章节符号
168	250	A8	10101000	¨	`¨`	通用货币符号
169	251	A9	10101001	?	`©`	版权符号
170	252	AA	10101010	?	`ª`	阴性顺序指示符号
171	253	AB	10101011	?	`«`	左角引号
172	254	AC	10101100	?	`¬`
173	255	AD	10101101	?	``
174	256	AE	10101110	?	`®`
175	257	AF	10101111	?	`¯`
176	260	B0	10110000	°	`°`	温度符号
177	261	B1	10110001	±	`±`	加/减号
178	262	B2	10110010	?	`²`	上标 2
179	263	B3	10110011	?	`³`	上标 3
180	264	B4	10110100	?	`´`
181	265	B5	10110101	?	`µ`	微符号
182	266	B6	10110110	?	`¶`	段落符号， pilcrow
183	267	B7	10110111	·	`·`	中点
184	270	B8	10111000	?	`¸`
185	271	B9	10111001	?	`¹`	上标 1
186	272	BA	10111010	?	`º`	阳性顺序指示符
187	273	BB	10111011	?	`»`	右角引号
188	274	BC	10111100	?	`¼`	分数四分之一
189	275	BD	10111101	?	`½`	分数二分之一
190	276	BE	10111110	?	`¾`
191	277	BF	10111111	?	`¿`	反向问号
192	300	C0	11000000	?	`À`	带重音符的大写字母 A
193	301	C1	11000001	?	`Á`	带尖锐重音的大写字母 A
194	302	C2	11000010	?	`Â`	带音调符号的大写字母 A
195	303	C3	11000011	?	`Ã`	带代字号的大写字母 A
196	304	C4	11000100	?	`Ä`	带元音变音 (分音符号) 的大写字母 A
197	305	C5	11000101	?	`Å`	带铃声的大写字母 A
198	306	C6	11000110	?	`Æ`	大写字母 AE 双重元音
199	307	C7	11000111	?	`Ç`	带变音符号的大写字母 C
200	310	C8	11001000	?	`È`	带重音符的大写字母 E
201	311	C9	11001001	?	`É`	带尖锐重音的大写字母 E
202	312	CA	11001010	?	`Ê`	带音调符号的大写字母 E
203	313	CB	11001011	?	`Ë`	带元音变音 (分音符号) 的大写字母 E
204	314	CC	11001100	?	`Ì`	带重音符的大写字母 I
205	315	CD	11001101	?	`Í`	带尖锐重音的大写字母 I
206	316	CE	11001110	?	`Î`	带音调符号的大写字母 I
207	317	CF	11001111	?	`Ï`	带元音变音 (分音符号) 的大写字母 I
208	320	D0	11010000	?	`Ð`
209	321	D1	11010001	?	`Ñ`	带代字号的大写字母 N
210	322	D2	11010010	?	`Ò`	带重音符的大写字母 O
211	323	D3	11010011	?	`Ó`	带尖锐重音的大写字母 O
212	324	D4	11010100	?	`Ô`	带音调符号的大写字母 O
213	325	D5	11010101	?	`Õ`	带代字号的大写字母 O
214	326	D6	11010110	?	`Ö`	带元音变音 (分音符号) 的大写字母 O
215	327	D7	11010111	×	`×`	大写字母 OE 连字
216	330	D8	11011000	?	`Ø`	带斜杠的大写字母 O
217	331	D9	11011001	?	`Ù`	带重音符的大写字母 U
218	332	DA	11011010	?	`Ú`	带尖锐重音的大写字母 U
219	333	DB	11011011	?	`Û`	带音调符号的大写字母 U
220	334	DC	11011100	?	`Ü`	带元音变音 (分音符号) 的大写字母 U
221	335	DD	11011101	?	`Ý`	带元音变音 (分音符号) 的大写字母 Y
222	336	DE	11011110	?	`Þ`
223	337	DF	11011111	?	`ß`	德语高调小写字母 s
224	340	E0	11100000	à	`à`	带重音符的小写字母 a
225	341	E1	11100001	á	`á`	带尖锐重音的小写字母 a
226	342	E2	11100010	?	`â`	带音调符号的小写字母 a
227	343	E3	11100011	?	`ã`	带代字号的小写字母 a
228	344	E4	11100100	?	`ä`	带元音变音 (分音符号) 的小写字母 a
229	345	E5	11100101	?	`å`	带铃声的小写字母 a
230	346	E6	11100110	?	`æ`	小写字母 ae 双重元音
231	347	E7	11100111	?	`ç`	带变音符号的小写字母 c
232	350	E8	11101000	è	`è`	带重音符的小写字母 e
233	351	E9	11101001	é	`é`	带尖锐重音的小写字母 e
234	352	EA	11101010	ê	`ê`	带音调符号的小写字母 e
235	353	EB	11101011	?	`ë`	带元音变音 (分音符号) 的小写字母 e
236	354	EC	11101100	ì	`ì`	带重音符的小写字母 i
237	355	ED	11101101	í	`í`	带尖锐重音的小写字母 i
238	356	EE	11101110	?	`î`	带音调符号的小写字母 i
239	357	EF	11101111	?	`ï`	带元音变音 (分音符号) 的小写字母 i
240	360	F0	11110000	?	`ð`
241	361	F1	11110001	?	`ñ`	带代字号的小写字母 n
242	362	F2	11110010	ò	`ò`	带重音符的小写字母 o
243	363	F3	11110011	ó	`ó`	带尖锐重音的小写字母 o
244	364	F4	11110100	?	`ô`	带音调符号的小写字母 o
245	365	F5	11110101	?	`õ`	带代字号的小写字母 o
246	366	F6	11110110	?	`ö`	带元音变音 (分音符号) 的小写字母 o
247	367	F7	11110111	÷	`÷`	小写字母 oe 连字
248	370	F8	11111000	?	`ø`	带斜杠的小写字母 o
249	371	F9	11111001	ù	`ù`	带重音符的小写字母 u
250	372	FA	11111010	ú	`ú`	带尖锐重音的小写字母 u
251	373	FB	11111011	?	`û`	带音调符号的小写字母 u
252	374	FC	11111100	ü	`ü`	带元音变音 (分音符号) 的小写字母 u
253	375	FD	11111101	?	`ý`	带元音变音 (分音符号) 的小写字母 y
254	376	FE	11111110	?	`þ`
255	377	FF	11111111	?	`ÿ`

java与golang中字符串与hex转换

我对你的好总是被辜负，而我的坏常常被你记住