字符串与字符数组转换

字符串与字符数组/字节数组之间的转换。

字符串转字符数组

toCharArray方法

String str = "Hello";

// 转为字符数组
char[] chars = str.toCharArray();
// ['H', 'e', 'l', 'l', 'o']

// 遍历字符数组
for (char c : chars) {
    System.out.println(c);
}

getChars提取部分字符

String str = "Hello World";

char[] dest = new char[5];

// 提取部分字符到数组
str.getChars(6, 11, dest, 0);
// 参数：源开始索引，源结束索引，目标数组，目标起始位置

// dest: ['W', 'o', 'r', 'l', 'd']

charAt逐个获取

String str = "Hello";

char[] chars = new char[str.length()];

// 逐个获取字符
for (int i = 0; i < str.length(); i++) {
    chars[i] = str.charAt(i);
}

字符数组转字符串

new String构造

char[] chars = {'H', 'e', 'l', 'l', 'o'};

// 字符数组转字符串
String str = new String(chars);
// "Hello"

部分字符数组转字符串

char[] chars = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};

// 从索引0取5个字符
String str1 = new String(chars, 0, 5);
// "Hello"

// 从索引6取5个字符
String str2 = new String(chars, 6, 5);
// "World"

// 参数：源数组，起始索引，长度

String.valueOf方法

char[] chars = {'H', 'e', 'l', 'l', 'o'};

// valueOf转换
String str = String.valueOf(chars);
// "Hello"

// 部分转换
String str2 = String.valueOf(chars, 0, 3);
// "Hel"

copyValueOf方法

char[] chars = {'A', 'B', 'C'};

// copyValueOf（等价valueOf）
String str = String.copyValueOf(chars);
// "ABC"

String str2 = String.copyValueOf(chars, 0, 2);
// "AB"

字符串转字节数组

getBytes默认编码

String str = "Hello";

// 转为字节数组（默认编码）
byte[] bytes = str.getBytes();
// [72, 101, 108, 108, 111]（ASCII）

String chinese = "中文";
byte[] bytes2 = chinese.getBytes();  // 系统默认编码（UTF-8）

getBytes指定编码

String str = "中文";

// 指定编码
byte[] bytes1 = str.getBytes("UTF-8");   // UTF-8编码
byte[] bytes2 = str.getBytes("GBK");     // GBK编码

// 使用StandardCharsets（推荐）
byte[] bytes3 = str.getBytes(StandardCharsets.UTF_8);

// 编码不同，字节不同
// UTF-8：[-28, -72, -83, -26, -105, -91]（6字节）
// GBK：[-42, -48, -50, -60]（4字节）

编码异常处理

String str = "中文";

try {
    byte[] bytes = str.getBytes("GBK");
} catch (UnsupportedEncodingException e) {
    // 不支持的编码
    e.printStackTrace();
}

// StandardCharsets不会抛异常（推荐）
byte[] bytes = str.getBytes(StandardCharsets.UTF_8);

字节数组转字符串

new String构造

byte[] bytes = {72, 101, 108, 108, 111};

// 字节数组转字符串
String str = new String(bytes);
// "Hello"

指定编码转换

byte[] bytes = {-28, -72, -83, -26, -105, -91};  // UTF-8编码的"中文"

// 指定编码解码
String str1 = new String(bytes, "UTF-8");
// "中文"

String str2 = new String(bytes, StandardCharsets.UTF_8);
// "中文"

// 编码必须匹配，否则乱码
String str3 = new String(bytes, "GBK");
// 乱码

部分字节转换

byte[] bytes = {72, 101, 108, 108, 111};

// 部分字节转字符串
String str = new String(bytes, 0, 3);
// "Hel"

// 参数：源数组，起始索引，长度

编码转换示例

UTF-8编码解码

String str = "Hello中文";

// 编码
byte[] utf8Bytes = str.getBytes(StandardCharsets.UTF_8);

// 解码
String decoded = new String(utf8Bytes, StandardCharsets.UTF_8);
// "Hello中文"（正确）

// 错误编码解码
String wrong = new String(utf8Bytes, StandardCharsets.ISO_8859_1);
// 乱码

GBK编码解码

String str = "中文";

// GBK编码
byte[] gbkBytes = str.getBytes("GBK");

// GBK解码
String decoded = new String(gbkBytes, "GBK");
// "中文"（正确）

编码转换流程

// UTF-8 → GBK转换
String utf8Str = "中文";

// 1. UTF-8解码为字符
// 2. GBK编码为字节
byte[] gbkBytes = utf8Str.getBytes("GBK");

// 3. GBK解码为字符串
String gbkStr = new String(gbkBytes, "GBK");
// 结果相同（UTF-8和GBK都能表示中文）

常用字符编码

编码类型

编码选择

// 推荐：UTF-8（国际通用）
byte[] bytes = str.getBytes(StandardCharsets.UTF_8);

// 中文系统：GBK（旧系统兼容）
byte[] bytes2 = str.getBytes("GBK");

转换方法对比

字符数组与字节数组对比

使用场景

// 字符数组：字符级别操作
char[] chars = str.toCharArray();
for (char c : chars) {
    if (Character.isDigit(c)) {  // 判断数字
        // 处理数字字符
    }
}

// 字节数组：网络传输、文件存储
byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
socket.getOutputStream().write(bytes);  // 网络传输
fileOutputStream.write(bytes);          // 文件写入

应用示例

字符统计

String str = "Hello123";

char[] chars = str.toCharArray();

int letterCount = 0;
int digitCount = 0;

for (char c : chars) {
    if (Character.isLetter(c)) {
        letterCount++;
    }
    if (Character.isDigit(c)) {
        digitCount++;
    }
}
// letterCount=5, digitCount=3

字符替换

String str = "Hello World";

char[] chars = str.toCharArray();

// 替换所有空格
for (int i = 0; i < chars.length; i++) {
    if (chars[i] == ' ') {
        chars[i] = '_';
    }
}

String result = new String(chars);
// "Hello_World"

字符反转

String str = "Hello";

char[] chars = str.toCharArray();

// 反转字符数组
for (int i = 0, j = chars.length - 1; i < j; i++, j--) {
    char temp = chars[i];
    chars[i] = chars[j];
    chars[j] = temp;
}

String reversed = new String(chars);
// "olleH"

字符串加密

String str = "Hello";

byte[] bytes = str.getBytes(StandardCharsets.UTF_8);

// 简单加密：每个字节+1
for (int i = 0; i < bytes.length; i++) {
    bytes[i] = bytes[i] + 1;
}

String encrypted = new String(bytes, StandardCharsets.UTF_8);
// 加密后的字符串

要点总结

• toCharArray()：字符串转字符数组
• new String(chars)：字符数组转字符串
• getChars()：提取部分字符到数组
• String.valueOf(chars)：字符数组转字符串
• getBytes()：字符串转字节数组
• getBytes(encoding)：指定编码转字节
• new String(bytes)：字节数组转字符串
• new String(bytes, encoding)：指定编码解码
• 编码和解码必须匹配，否则乱码
• 推荐UTF-8编码（国际通用）
• StandardCharsets不会抛异常
• 字符数组用于字符操作
• 字节数组用于网络/文件传输