涵盖 Java 中 String、char []、Integer 等常用类型的相互转换方法，以及 Arrays 类的高频便捷方法

最新推荐文章于 2026-04-12 00:29:37 发布

原创最新推荐文章于 2026-04-12 00:29:37 发布 · 217 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #开发语言

Python3.8

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

一、核心类型相互转换（String/char []/Integer/int）

1. String ↔ char []（字符串与字符数组）

转换方向	核心方法	代码示例
String → char[]	`String.toCharArray()`	```java
String str = "hello";
char[] charArr = str.toCharArray(); // ['h','e','l','l','o']

| char[] → String  | `new String(char[])`    | ```java
char[] charArr = {'h','e','l','l','o'};
String str = new String(charArr); // "hello"
// 进阶：截取部分字符（起始索引，长度）
String str2 = new String(charArr, 0, 3); // "hel"
``` |

### 2. String ↔ Integer/int（字符串与整数）
| 转换方向         | 核心方法                          | 代码示例                                                                 | 注意事项                                                                 |
|------------------|-----------------------------------|--------------------------------------------------------------------------|--------------------------------------------------------------------------|
| String → int     | `Integer.parseInt(String)`        | ```java
String str = "123";
int num = Integer.parseInt(str); // 123
``` | 字符串必须是纯数字（可带±），否则抛 `NumberFormatException` |
| String → Integer | `Integer.valueOf(String)`        | ```java
String str = "123";
Integer num = Integer.valueOf(str); // 123（缓存-128~127）
``` | `valueOf` 优先返回缓存对象，效率高于 `new Integer()` |
| int → String     | `String.valueOf(int)` / 拼接空串 | ```java
int num = 123;
String str1 = String.valueOf(num); // "123"
String str2 = num + ""; // 简洁写法，底层调用 valueOf
``` | 推荐 `String.valueOf()`，避免拼接空串的隐式转换 |
| Integer → String | `Integer.toString()` / `String.valueOf()` | ```java
Integer num = 123;
String str1 = num.toString(); // "123"
String str2 = String.valueOf(num); // 兼容 null（返回"null"）
``` | 若 Integer 为 null，`toString()` 抛 NPE，`valueOf()` 更安全 |

### 3. char[]/char ↔ int/Integer（字符/字符数组与整数）
| 转换方向         | 核心逻辑                          | 代码示例                                                                 |
|------------------|-----------------------------------|--------------------------------------------------------------------------|
| char → int       | 减去 '0'（字符0的ASCII值）| ```java
char c = '5';
int num = c - '0'; // 5（'5'的ASCII是53，'0'是48，53-48=5）
``` |
| int → char       | 加上 '0'                          | ```java
int num = 5;
char c = (char) (num + '0'); // '5'
``` | 需强制类型转换，num 范围 0~9 |
| char[] → int     | 先转 String 再转 int              | ```java
char[] charArr = {'1','2','3'};
int num = Integer.parseInt(new String(charArr)); // 123
``` | 通用且简洁的方式 |

### 4. 扩展：包装类 ↔ 基本类型（自动拆箱/装箱）
Java 5+ 支持自动拆箱（包装类→基本类型）、自动装箱（基本类型→包装类），手动转换也可调用方法：
```java
// 手动转换
Integer numObj = Integer.valueOf(123); // 装箱（int→Integer）
int num = numObj.intValue(); // 拆箱（Integer→int）

// 自动转换（推荐）
Integer numObj2 = 123; // 自动装箱
int num2 = numObj2; // 自动拆箱

二、Arrays 类高频便捷方法（java.util.Arrays）

Arrays 提供了大量操作数组的静态方法，以下是开发中最常用、能显著简化代码的方法：

1. 数组遍历 / 打印：`Arrays.toString()`

2. Arrays 常用方法核心

这份总结覆盖了日常开发中 90% 以上的类型转换和 Arrays 用法场景，你可以直接收藏作为速查手册～

已生成代码

作用：将任意类型数组转为易读的字符串（替代手动循环打印）
示例：

int[] arr1 = {1,2,3};
System.out.println(Arrays.toString(arr1)); // [1, 2, 3]

char[] arr2 = {'a','b'};
System.out.println(Arrays.toString(arr2)); // [a, b]

// 二维数组用 deepToString()
int[][] arr3 = {{1,2},{3,4}};
System.out.println(Arrays.deepToString(arr3)); // [[1, 2], [3, 4]]

2. 数组排序：`Arrays.sort()`

作用：对数组进行升序排序（支持基本类型、对象类型）
示例：

// 基本类型数组排序
int[] arr = {3,1,2};
Arrays.sort(arr); // 直接修改原数组，arr 变为 [1,2,3]

// 自定义范围排序（起始索引，结束索引-1）
int[] arr2 = {5,3,4,1,2};
Arrays.sort(arr2, 1, 4); // 排序索引1~3，arr2 变为 [5,1,3,4,2]

// 字符串数组（按字典序）
String[] strArr = {"banana","apple","cherry"};
Arrays.sort(strArr); // ["apple","banana","cherry"]

3. 数组查找：`Arrays.binarySearch()`

作用：在已排序的数组中 二分查找指定元素，返回索引（未找到返回 -(插入点)-1）
示例：

int[] arr = {1,2,3,4,5};
// 找到：返回索引2
int index1 = Arrays.binarySearch(arr, 3); 
// 未找到：返回 -5（插入点是4，-(4)-1=-5）
int index2 = Arrays.binarySearch(arr, 6);

注意：必须先排序，否则结果不可预测！
作用：创建新数组并拷贝原数组元素（避免直接赋值导致的数组引用传递）
示例：
4. 数组拷贝：Arrays.copyOf() / Arrays.copyOfRange()

int[] arr = {1,2,3};
// 拷贝全部元素，新数组长度3
int[] copy1 = Arrays.copyOf(arr, 3); // [1,2,3]
// 拷贝并扩容，多余位置补默认值（int补0）
int[] copy2 = Arrays.copyOf(arr, 5); // [1,2,3,0,0]

// 拷贝指定范围（起始索引，结束索引-1）
int[] copy3 = Arrays.copyOfRange(arr, 0, 2); // [1,2]

5. 数组填充：`Arrays.fill()`

作用：将数组所有 / 指定范围元素设为指定值（初始化数组常用）
示例：

int[] arr = new int[5];
// 全部填充为9
Arrays.fill(arr, 9); // [9,9,9,9,9]

// 指定范围填充为8（索引1~3）
Arrays.fill(arr, 1, 4, 8); // [9,8,8,8,9]

6. 数组比较：`Arrays.equals()`

作用：判断两个数组是否「内容相等」（长度 + 对应位置元素都相等）
示例：

int[] arr1 = {1,2,3};
int[] arr2 = {1,2,3};
int[] arr3 = {1,3,2};

// true（内容相等）
System.out.println(Arrays.equals(arr1, arr2)); 
// false（顺序不同）
System.out.println(Arrays.equals(arr1, arr3)); 

// 二维数组用 deepEquals()
int[][] arr4 = {{1,2},{3,4}};
int[][] arr5 = {{1,2},{3,4}};
System.out.println(Arrays.deepEquals(arr4, arr5)); // true

注意：数组直接用 == 比较的是引用地址，Arrays.equals() 才是比较内容！
作用：将数组转为固定大小的 List（方便结合集合方法使用）
示例：
7. 数组转集合：Arrays.asList()

String[] strArr = {"a","b","c"};
// 转为 List<String>（不可增删，可修改元素）
List<String> list = Arrays.asList(strArr); 

// 若需可增删的 List，嵌套 new ArrayList()
List<String> mutableList = new ArrayList<>(Arrays.asList(strArr));