Java数组元素求和：多维度解析与优化实践293
```html
传统for循环通过索引访问数组元素，提供对遍历过程的精确控制。
public class ArraySumTraditionalFor {
public static void main(String[] args) {
int[] numbers = {5, 12, 8, 20, 3, 15};
long sum = 0; // 使用long以防止溢出，特别是当数组元素和可能很大时
for (int i = 0; i < ; i++) {
sum += numbers[i];
}
("传统for循环求和: " + sum); // 输出: 传统for循环求和: 63
}
}
优点：
通用性强，适用于所有类型的数组和所有Java版本。
可以方便地获取当前元素的索引，适用于需要根据索引进行操作的场景。
缺点：
代码相对冗长，容易出现“差一错误”（off-by-one error）导致数组越界或漏算。
Java 5引入的增强型for循环（也称为for-each循环）专门用于遍历数组和集合，代码更加简洁、安全。
public class ArraySumForEach {
public static void main(String[] args) {
int[] numbers = {5, 12, 8, 20, 3, 15};
long sum = 0; // 使用long以防止溢出
for (int number : numbers) {
sum += number;
}
("增强for循环求和: " + sum); // 输出: 增强for循环求和: 63
}
}
优点：
代码简洁、可读性高，避免了索引管理。
减少了出错的可能性，因为不会有索引越界的问题。
缺点：
无法直接获取当前元素的索引。
不能修改数组中的元素（只能修改局部变量number的副本）。
对于int[], long[], double[]等基本类型数组，可以直接通过()方法转换为对应的基本类型流（如IntStream, LongStream, DoubleStream），然后调用sum()方法。
import ;
import ;
public class ArraySumStreamPrimitives {
public static void main(String[] args) {
int[] numbers = {5, 12, 8, 20, 3, 15};
// 方法一：使用()
long sum1 = (numbers).sum();
("Stream API (int[])求和: " + sum1); // 输出: Stream API (int[])求和: 63
double[] doubles = {1.1, 2.2, 3.3};
double sumDoubles = (doubles).sum();
("Stream API (double[])求和: " + sumDoubles); // 输出: Stream API (double[])求和: 6.6000000000000005
// 注意：如果是空数组，sum()方法返回0。
int[] emptyNumbers = {};
long emptySum = (emptyNumbers).sum();
("空数组Stream求和: " + emptySum); // 输出: 空数组Stream求和: 0
}
}
对于Integer[], Double[]或自定义对象数组，需要先将Stream转换为基本类型流，才能使用sum()方法。这通常通过mapToInt(), mapToLong(), mapToDouble()等中间操作实现。
import ;
import ;
import ;
class Product {
String name;
double price;
public Product(String name, double price) {
= name;
= price;
}
public double getPrice() {
return price;
}
}
public class ArraySumStreamObjects {
public static void main(String[] args) {
Integer[] integerNumbers = {5, 12, 8, 20, 3, 15};
// 对于Integer数组，需要先mapToInt
long sumIntegers = (integerNumbers)
.filter(n -> n != null) // 过滤null值，防止NullPointerException
.mapToLong(Integer::longValue) // 或者 mapToInt(Integer::intValue)
.sum();
("Stream API (Integer[])求和: " + sumIntegers); // 输出: Stream API (Integer[])求和: 63
Product[] products = {
new Product("Laptop", 1200.00),
new Product("Mouse", 25.50),
new Product("Keyboard", 75.00),
null // 包含null值的场景
};
// 求所有产品价格的总和
double totalPrice = (products)
.filter(p -> p != null) // 过滤null值
.mapToDouble(Product::getPrice)
.sum();
("Stream API (Object[])产品价格求和: " + totalPrice); // 输出: Stream API (Object[])产品价格求和: 1300.5
// 如果数组中可能存在null，且不希望过滤，可以提供默认值
double totalPriceWithNullDefault = (products)
.mapToDouble(p -> p != null ? () : 0.0)
.sum();
("Stream API (Object[])产品价格求和 (null默认0): " + totalPriceWithNullDefault); // 输出: Stream API (Object[])产品价格求和 (null默认0): 1300.5
}
}
优点：
代码简洁、声明式，提升可读性。
支持链式操作，方便进行其他数据转换。
易于并行化处理（通过parallelStream()），在处理大量数据时可能提升性能。
缺点：
对于非常小的数组，Stream API的启动开销可能导致其性能不如传统循环。
调试相对复杂一些。
多维数组（例如二维数组表示矩阵）的求和需要多层循环或Stream API的组合操作。
import ;
public class MultiDimArraySum {
public static void main(String[] args) {
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// 传统循环求和
long sumLoop = 0;
for (int i = 0; i < ; i++) {
for (int j = 0; j < matrix[i].length; j++) {
sumLoop += matrix[i][j];
}
}
("多维数组传统循环求和: " + sumLoop); // 输出: 多维数组传统循环求和: 45
// Stream API求和
long sumStream = (matrix) // Stream
.flatMapToInt(Arrays::stream) // int[] -> IntStream, 然后合并成一个IntStream
.sum(); // 求和
("多维数组Stream API求和: " + sumStream); // 输出: 多维数组Stream API求和: 45
}
}
当数组中元素的总和可能超出long类型的最大值（约9 x 1018）时，需要使用来处理任意精度的大整数。
import ;
public class BigNumberArraySum {
public static void main(String[] args) {
// 创建一个包含大整数的字符串数组
String[] bigNumbers = {
"9876543210987654321",
"1234567890123456789",
"5000000000000000000"
};
BigInteger sumBigInt = ; // 初始化为0
for (String numStr : bigNumbers) {
sumBigInt = (new BigInteger(numStr));
}
("大数数组求和 (for循环): " + sumBigInt); // 输出: 大数数组求和 (for循环): 16111111102111111110
// Stream API 方式
BigInteger sumBigIntStream = (bigNumbers)
.map(BigInteger::new) // 将字符串映射为BigInteger对象
.reduce(, BigInteger::add); // 使用reduce进行累加
("大数数组求和 (Stream API): " + sumBigIntStream); // 输出: 大数数组求和 (Stream API): 16111111102111111110
}
}
使用float或double类型进行求和时，由于浮点数的二进制表示特性，可能会遇到精度问题。对于需要精确计算的场景（如金融计算），应使用。
import ;
import ;
public class FloatPrecisionSum {
public static void main(String[] args) {
double[] prices = {0.1, 0.2, 0.3, 0.4, 0.5};
double sumDouble = 0.0;
for (double price : prices) {
sumDouble += price;
}
("double类型求和: " + sumDouble); // 预期1.5，实际可能为1.4999999999999998
// 使用BigDecimal进行精确求和
BigDecimal sumBigDecimal = ;
for (double price : prices) {
sumBigDecimal = ((price)); // 将double转换为BigDecimal
}
("BigDecimal类型求和: " + sumBigDecimal); // 输出: BigDecimal类型求和: 1.5
// Stream API + BigDecimal
BigDecimal sumBigDecimalStream = (prices)
.mapToObj(BigDecimal::valueOf)
.reduce(, BigDecimal::add);
("BigDecimal类型求和 (Stream API): " + sumBigDecimalStream); // 输出: BigDecimal类型求和 (Stream API): 1.5
}
}
对于非常大的数组，利用多核处理器的优势进行并行求和可以显著提高性能。Java Stream API提供了parallelStream()方法来实现这一点。
import ;
import ;
public class ParallelArraySum {
public static void main(String[] args) {
int arraySize = 10_000_000; // 1000万个元素
int[] largeNumbers = new int[arraySize];
// 填充随机数据
for (int i = 0; i < arraySize; i++) {
largeNumbers[i] = ().nextInt(100); // 0-99的随机数
}
long startTime = ();
long sequentialSum = (largeNumbers).sum();
long endTime = ();
("顺序流求和: " + sequentialSum + ", 耗时: " + (endTime - startTime) / 1_000_000 + " ms");
startTime = ();
long parallelSum = (largeNumbers).parallel().sum();
endTime = ();
("并行流求和: " + parallelSum + ", 耗时: " + (endTime - startTime) / 1_000_000 + " ms");
}
}
传统for循环和增强for循环：对于基本类型数组，它们通常是最快的，因为它们直接操作内存，没有额外的对象创建和方法调用开销。
Stream API (顺序流)：引入了一定的开销（管道创建、boxed类型转换等），在数据量较小时可能比循环慢。但对于IntStream等基本类型流，性能表现相当出色，且代码更具表现力。
Stream API (并行流)：在处理大规模数据（通常是百万级别以上）且计算任务是CPU密集型时，并行流能显著提升性能。但其启动和协调开销意味着不适合小数据量场景。
BigInteger / BigDecimal：这些类处理的是对象而不是基本类型，涉及更多的内存分配和方法调用，因此性能远低于基本类型操作。它们的应用场景是精确计算，而不是追求极致性能。
最佳实践：
对于基本类型的小到中等规模数组求和，优先考虑增强for循环，它兼顾了性能和可读性。
对于基本类型的大规模数组求和，如果不需要并行化，顺序Stream API（如(array).sum()）是一个不错的选择，它提供了简洁的代码。如果需要并行化，考虑parallelStream()。
对于对象数组，Stream API结合mapToInt/Long/Double是简洁且现代的选择。
涉及大数或高精度浮点数运算时，务必使用BigInteger或BigDecimal，牺牲一部分性能换取正确性。
基本类型数组：内存效率最高，直接存储值。
对象数组：存储的是对象的引用，实际对象存储在堆中，会产生额外的内存开销。使用Stream API时，如果将基本类型装箱为对象（如int装箱为Integer），也会增加内存开销。
BigInteger / BigDecimal：每次操作都可能创建新的对象，内存开销更大。
增强for循环和Stream API通常提供更好的可读性，特别是Stream API的链式操作能清晰表达数据处理流程。
选择最适合当前场景且最容易理解的方法，避免过度优化。
空数组：无论是循环还是Stream API，处理空数组时通常会得到0作为结果，这通常是符合预期的。但应确保代码能够稳健处理。
NullPointerException：对于对象数组，务必检查或过滤掉null元素，防止在访问其方法时出现NullPointerException。例如，filter(obj -> obj != null)。
溢出：当求和结果可能超出int或long的最大值时，使用更大的类型（如long或BigInteger）来存储总和。
在Java编程中，数组（Arrays）是一种非常基础且重要的数据结构，用于存储固定大小的同类型元素序列。对数组元素进行求和操作，是日常开发中一个极其常见的任务，无论是进行数据统计、计算平均值，还是作为更复杂算法的中间步骤，都离不开它。本文将作为一名专业的程序员，深入探讨Java中数组元素求和的各种方法，从传统的循环到现代的Stream API，再到特殊情况（如多维数组、大数求和、浮点数精度）和性能优化，力求为读者提供一个全面、深入且实用的指南。
一、Java数组基础回顾在深入求和方法之前，我们先快速回顾一下Java数组的基础知识。
一个数组在Java中具有以下特性：
固定长度：一旦创建，数组的大小就不能改变。
同类型元素：所有元素必须是相同的数据类型（或其子类型）。
内存连续：数组元素在内存中是连续存储的，这使得通过索引访问元素非常高效。
声明和初始化一个整型数组的示例如下：
// 声明一个整型数组变量
int[] numbers;
// 初始化一个包含5个元素的数组，并赋值
numbers = new int[]{10, 20, 30, 40, 50};
// 或者更简洁地声明并初始化
int[] scores = {100, 95, 80, 75, 90};
// 创建一个指定大小的空数组，元素会被初始化为默认值（int为0）
int[] emptyArray = new int[3]; // emptyArray = {0, 0, 0}
二、基础求和方法：循环遍历这是最直观、最常用的求和方式，通过遍历数组的每一个元素并累加到总和变量中。
1. 传统for循环 (Traditional for loop)
传统for循环通过索引访问数组元素，提供对遍历过程的精确控制。
public class ArraySumTraditionalFor {
public static void main(String[] args) {
int[] numbers = {5, 12, 8, 20, 3, 15};
long sum = 0; // 使用long以防止溢出，特别是当数组元素和可能很大时
for (int i = 0; i < ; i++) {
sum += numbers[i];
}
("传统for循环求和: " + sum); // 输出: 传统for循环求和: 63
}
}
优点：
通用性强，适用于所有类型的数组和所有Java版本。
可以方便地获取当前元素的索引，适用于需要根据索引进行操作的场景。
缺点：
代码相对冗长，容易出现“差一错误”（off-by-one error）导致数组越界或漏算。
2. 增强型for循环 (Enhanced for loop / for-each loop)
Java 5引入的增强型for循环（也称为for-each循环）专门用于遍历数组和集合，代码更加简洁、安全。
public class ArraySumForEach {
public static void main(String[] args) {
int[] numbers = {5, 12, 8, 20, 3, 15};
long sum = 0; // 使用long以防止溢出
for (int number : numbers) {
sum += number;
}
("增强for循环求和: " + sum); // 输出: 增强for循环求和: 63
}
}
优点：
代码简洁、可读性高，避免了索引管理。
减少了出错的可能性，因为不会有索引越界的问题。
缺点：
无法直接获取当前元素的索引。
不能修改数组中的元素（只能修改局部变量number的副本）。
三、Java 8 Stream API求和Java 8引入的Stream API提供了一种更函数式、更声明式的数据处理方式，尤其适合处理集合数据。它使得代码更加简洁、富有表现力，并且支持并行操作。
1. 基本类型数组求和 (Primitive Array Summation)
对于int[], long[], double[]等基本类型数组，可以直接通过()方法转换为对应的基本类型流（如IntStream, LongStream, DoubleStream），然后调用sum()方法。
import ;
import ;
public class ArraySumStreamPrimitives {
public static void main(String[] args) {
int[] numbers = {5, 12, 8, 20, 3, 15};
// 方法一：使用()
long sum1 = (numbers).sum();
("Stream API (int[])求和: " + sum1); // 输出: Stream API (int[])求和: 63
double[] doubles = {1.1, 2.2, 3.3};
double sumDoubles = (doubles).sum();
("Stream API (double[])求和: " + sumDoubles); // 输出: Stream API (double[])求和: 6.6000000000000005
// 注意：如果是空数组，sum()方法返回0。
int[] emptyNumbers = {};
long emptySum = (emptyNumbers).sum();
("空数组Stream求和: " + emptySum); // 输出: 空数组Stream求和: 0
}
}
2. 对象类型数组求和 (Object Array Summation)
对于Integer[], Double[]或自定义对象数组，需要先将Stream转换为基本类型流，才能使用sum()方法。这通常通过mapToInt(), mapToLong(), mapToDouble()等中间操作实现。
import ;
import ;
import ;
class Product {
String name;
double price;
public Product(String name, double price) {
= name;
= price;
}
public double getPrice() {
return price;
}
}
public class ArraySumStreamObjects {
public static void main(String[] args) {
Integer[] integerNumbers = {5, 12, 8, 20, 3, 15};
// 对于Integer数组，需要先mapToInt
long sumIntegers = (integerNumbers)
.filter(n -> n != null) // 过滤null值，防止NullPointerException
.mapToLong(Integer::longValue) // 或者 mapToInt(Integer::intValue)
.sum();
("Stream API (Integer[])求和: " + sumIntegers); // 输出: Stream API (Integer[])求和: 63
Product[] products = {
new Product("Laptop", 1200.00),
new Product("Mouse", 25.50),
new Product("Keyboard", 75.00),
null // 包含null值的场景
};
// 求所有产品价格的总和
double totalPrice = (products)
.filter(p -> p != null) // 过滤null值
.mapToDouble(Product::getPrice)
.sum();
("Stream API (Object[])产品价格求和: " + totalPrice); // 输出: Stream API (Object[])产品价格求和: 1300.5
// 如果数组中可能存在null，且不希望过滤，可以提供默认值
double totalPriceWithNullDefault = (products)
.mapToDouble(p -> p != null ? () : 0.0)
.sum();
("Stream API (Object[])产品价格求和 (null默认0): " + totalPriceWithNullDefault); // 输出: Stream API (Object[])产品价格求和 (null默认0): 1300.5
}
}
优点：
代码简洁、声明式，提升可读性。
支持链式操作，方便进行其他数据转换。
易于并行化处理（通过parallelStream()），在处理大量数据时可能提升性能。
缺点：
对于非常小的数组，Stream API的启动开销可能导致其性能不如传统循环。
调试相对复杂一些。
四、特殊情况与高级主题在实际开发中，我们可能遇到各种复杂的求和场景。
1. 多维数组求和 (Multi-dimensional Array Summation)
多维数组（例如二维数组表示矩阵）的求和需要多层循环或Stream API的组合操作。
import ;
public class MultiDimArraySum {
public static void main(String[] args) {
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// 传统循环求和
long sumLoop = 0;
for (int i = 0; i < ; i++) {
for (int j = 0; j < matrix[i].length; j++) {
sumLoop += matrix[i][j];
}
}
("多维数组传统循环求和: " + sumLoop); // 输出: 多维数组传统循环求和: 45
// Stream API求和
long sumStream = (matrix) // Stream
.flatMapToInt(Arrays::stream) // int[] -> IntStream, 然后合并成一个IntStream
.sum(); // 求和
("多维数组Stream API求和: " + sumStream); // 输出: 多维数组Stream API求和: 45
}
}
2. 大数求和 (Big Number Summation)
当数组中元素的总和可能超出long类型的最大值（约9 x 1018）时，需要使用来处理任意精度的大整数。
import ;
public class BigNumberArraySum {
public static void main(String[] args) {
// 创建一个包含大整数的字符串数组
String[] bigNumbers = {
"9876543210987654321",
"1234567890123456789",
"5000000000000000000"
};
BigInteger sumBigInt = ; // 初始化为0
for (String numStr : bigNumbers) {
sumBigInt = (new BigInteger(numStr));
}
("大数数组求和 (for循环): " + sumBigInt); // 输出: 大数数组求和 (for循环): 16111111102111111110
// Stream API 方式
BigInteger sumBigIntStream = (bigNumbers)
.map(BigInteger::new) // 将字符串映射为BigInteger对象
.reduce(, BigInteger::add); // 使用reduce进行累加
("大数数组求和 (Stream API): " + sumBigIntStream); // 输出: 大数数组求和 (Stream API): 16111111102111111110
}
}
3. 浮点数求和的精度问题 (Floating-point Summation Precision Issues)
使用float或double类型进行求和时，由于浮点数的二进制表示特性，可能会遇到精度问题。对于需要精确计算的场景（如金融计算），应使用。
import ;
import ;
public class FloatPrecisionSum {
public static void main(String[] args) {
double[] prices = {0.1, 0.2, 0.3, 0.4, 0.5};
double sumDouble = 0.0;
for (double price : prices) {
sumDouble += price;
}
("double类型求和: " + sumDouble); // 预期1.5，实际可能为1.4999999999999998
// 使用BigDecimal进行精确求和
BigDecimal sumBigDecimal = ;
for (double price : prices) {
sumBigDecimal = ((price)); // 将double转换为BigDecimal
}
("BigDecimal类型求和: " + sumBigDecimal); // 输出: BigDecimal类型求和: 1.5
// Stream API + BigDecimal
BigDecimal sumBigDecimalStream = (prices)
.mapToObj(BigDecimal::valueOf)
.reduce(, BigDecimal::add);
("BigDecimal类型求和 (Stream API): " + sumBigDecimalStream); // 输出: BigDecimal类型求和 (Stream API): 1.5
}
}
在某些需要极高精度且不使用BigDecimal的浮点数求和场景中，Kahan求和算法（Kahan summation algorithm）是一个可选的优化方案，它通过跟踪误差来减少累积的浮点误差，但实现起来更为复杂。
4. 并行求和 (Parallel Summation)
对于非常大的数组，利用多核处理器的优势进行并行求和可以显著提高性能。Java Stream API提供了parallelStream()方法来实现这一点。
import ;
import ;
public class ParallelArraySum {
public static void main(String[] args) {
int arraySize = 10_000_000; // 1000万个元素
int[] largeNumbers = new int[arraySize];
// 填充随机数据
for (int i = 0; i < arraySize; i++) {
largeNumbers[i] = ().nextInt(100); // 0-99的随机数
}
long startTime = ();
long sequentialSum = (largeNumbers).sum();
long endTime = ();
("顺序流求和: " + sequentialSum + ", 耗时: " + (endTime - startTime) / 1_000_000 + " ms");
startTime = ();
long parallelSum = (largeNumbers).parallel().sum();
endTime = ();
("并行流求和: " + parallelSum + ", 耗时: " + (endTime - startTime) / 1_000_000 + " ms");
}
}
注意事项：
并行流的开销（如线程管理、数据分块合并）在数据量较小时可能导致性能不如顺序流。
只有当数据量足够大，且计算任务是CPU密集型时，并行流的优势才能体现出来。
对于求和这类简单操作，如果元素数量不是特别庞大，传统循环或顺序流通常是首选。
五、性能考量与最佳实践选择合适的求和方法不仅关乎代码的简洁性，也影响到程序的性能和资源消耗。
1. 不同方法的性能对比
传统for循环和增强for循环：对于基本类型数组，它们通常是最快的，因为它们直接操作内存，没有额外的对象创建和方法调用开销。
Stream API (顺序流)：引入了一定的开销（管道创建、boxed类型转换等），在数据量较小时可能比循环慢。但对于IntStream等基本类型流，性能表现相当出色，且代码更具表现力。
Stream API (并行流)：在处理大规模数据（通常是百万级别以上）且计算任务是CPU密集型时，并行流能显著提升性能。但其启动和协调开销意味着不适合小数据量场景。
BigInteger / BigDecimal：这些类处理的是对象而不是基本类型，涉及更多的内存分配和方法调用，因此性能远低于基本类型操作。它们的应用场景是精确计算，而不是追求极致性能。
最佳实践：
对于基本类型的小到中等规模数组求和，优先考虑增强for循环，它兼顾了性能和可读性。
对于基本类型的大规模数组求和，如果不需要并行化，顺序Stream API（如(array).sum()）是一个不错的选择，它提供了简洁的代码。如果需要并行化，考虑parallelStream()。
对于对象数组，Stream API结合mapToInt/Long/Double是简洁且现代的选择。
涉及大数或高精度浮点数运算时，务必使用BigInteger或BigDecimal，牺牲一部分性能换取正确性。
2. 内存开销
基本类型数组：内存效率最高，直接存储值。
对象数组：存储的是对象的引用，实际对象存储在堆中，会产生额外的内存开销。使用Stream API时，如果将基本类型装箱为对象（如int装箱为Integer），也会增加内存开销。
BigInteger / BigDecimal：每次操作都可能创建新的对象，内存开销更大。
3. 可读性与维护性
增强for循环和Stream API通常提供更好的可读性，特别是Stream API的链式操作能清晰表达数据处理流程。
选择最适合当前场景且最容易理解的方法，避免过度优化。
4. 错误处理
空数组：无论是循环还是Stream API，处理空数组时通常会得到0作为结果，这通常是符合预期的。但应确保代码能够稳健处理。
NullPointerException：对于对象数组，务必检查或过滤掉null元素，防止在访问其方法时出现NullPointerException。例如，filter(obj -> obj != null)。
溢出：当求和结果可能超出int或long的最大值时，使用更大的类型（如long或BigInteger）来存储总和。
六、总结Java中数组元素的求和操作看似简单，实则蕴含着多种实现方式和深层次的考量。从传统的for循环、增强for循环，到现代的Java 8 Stream API，每种方法都有其独特的优点和适用场景。在面对多维数组、大数运算、浮点数精度以及大规模数据并行处理等复杂情况时，理解并选择最合适的工具至关重要。
作为一名专业的程序员，我们应该在追求代码简洁、可读性的同时，不忘关注性能和内存效率，并根据具体业务需求做出明智的技术选型。通过本文的深入探讨，相信您对Java数组求和的各种方法有了更全面的理解，能够在未来的开发工作中游刃有余。
```
2025-10-25
最新文章 
2小时前 2小时前 3小时前 3小时前 3小时前
热门文章 10-11 21:29 10-21 17:35 10-17 02:25 10-20 22:45 10-13 03:36
深入理解Java方法注解：运行时获取与动态解析实践
https://www.shuihudhg.cn/131109.html
PHP单文件Web文件管理器：轻量级部署与安全实践指南
https://www.shuihudhg.cn/131108.html
Java字符串截取终极指南：从基础到高级，掌握文本处理的艺术
https://www.shuihudhg.cn/131107.html
Python函数可视化：使用Matplotlib绘制数学图像详解
https://www.shuihudhg.cn/131106.html
使用PHP实现域名信息获取：查询、检测与管理
https://www.shuihudhg.cn/131105.html
热门文章
Java中数组赋值的全面指南
https://www.shuihudhg.cn/207.html
JavaScript 与 Java：二者有何异同？
https://www.shuihudhg.cn/6764.html
判断 Java 字符串中是否包含特定子字符串
https://www.shuihudhg.cn/3551.html
Java 字符串的切割：分而治之
https://www.shuihudhg.cn/6220.html
Java 输入代码：全面指南
https://www.shuihudhg.cn/1064.html