本文目录导读：
我来为您提供几个实用的Java字符串处理案例,涵盖常见的开发场景。
字符串基础操作案例
public class StringBasicOperations {
public static void main(String[] args) {
// 字符串拼接
String str1 = "Hello";
String str2 = "World";
String result = str1 + " " + str2;
System.out.println("拼接结果: " + result);
// 使用StringBuilder（性能更好）
StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("World");
System.out.println("StringBuilder结果: " + sb.toString());
// 字符串比较
String a = "Java";
String b = new String("Java");
System.out.println("==比较: " + (a == b)); // false
System.out.println("equals比较: " + a.equals(b)); // true
System.out.println("忽略大小写: " + a.equalsIgnoreCase("JAVA")); // true
// 字符串截取
String text = "Hello, World!";
String sub1 = text.substring(0, 5); // "Hello"
String sub2 = text.substring(7); // "World!"
System.out.println("截取前5个字符: " + sub1);
System.out.println("从第7个字符开始: " + sub2);
// 字符串查找
System.out.println("是否包含World: " + text.contains("World"));
System.out.println("World的位置: " + text.indexOf("World"));
System.out.println("是否以Hello开头: " + text.startsWith("Hello"));
System.out.println("是否以! " + text.endsWith("!"));
}
}
字符串分割与合并
import java.util.Arrays;
import java.util.List;
import java.util.StringJoiner;
import java.util.stream.Collectors;
public class StringSplitAndJoin {
public static void main(String[] args) {
// 字符串分割
String data = "apple,banana,orange,grape";
String[] fruits = data.split(",");
System.out.println("分割结果: " + Arrays.toString(fruits));
// 限制分割次数
String[] limited = data.split(",", 2);
System.out.println("限制分割次数: " + Arrays.toString(limited));
// 使用正则表达式分割
String text = "a1b2c3d4";
String[] nums = text.split("[a-z]");
System.out.println("正则分割: " + Arrays.toString(nums));
// 字符串合并
List<String> list = Arrays.asList("Hello", "World", "Java");
// 方式1: String.join
String joined1 = String.join("-", list);
System.out.println("String.join结果: " + joined1);
// 方式2: StringJoiner
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("苹果").add("香蕉").add("橙子");
System.out.println("StringJoiner结果: " + joiner.toString());
// 方式3: Stream
String joined3 = list.stream()
.collect(Collectors.joining(" | "));
System.out.println("Stream结果: " + joined3);
}
}
字符串验证与清洗
public class StringValidation {
public static void main(String[] args) {
// 空字符串检查
String emptyStr = "";
String nullStr = null;
String whitespaceStr = " ";
System.out.println("isEmpty: " + emptyStr.isEmpty());
System.out.println("isBlank: " + whitespaceStr.isBlank()); // Java 11+
// 判断是否为空或null
System.out.println("为空或null: " + isEmptyOrNull(nullStr));
// 去除空格
String message = " Hello World ";
System.out.println("trim结果: '" + message.trim() + "'");
System.out.println("strip结果: '" + message.strip() + "'"); // Java 11+
System.out.println("去除首尾空格: '" + message.stripLeading() + "'");
// 数字验证
String number = "123.45";
System.out.println("是否数字: " + number.matches("-?\\d+(\\.\\d+)?"));
System.out.println("是否纯数字: " + "12345".matches("\\d+"));
// 邮箱验证
String email = "user@example.com";
String emailRegex = "^[A-Za-z0-9+_.-]+@(.+)$";
System.out.println("邮箱格式: " + email.matches(emailRegex));
// 手机号验证（中国）
String phone = "13812345678";
String phoneRegex = "^1[3-9]\\d{9}$";
System.out.println("手机号格式: " + phone.matches(phoneRegex));
}
private static boolean isEmptyOrNull(String str) {
return str == null || str.isEmpty();
}
}
字符串格式化与转换
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class StringFormatting {
public static void main(String[] args) {
// 格式化数字
double price = 1234.5678;
System.out.println(String.format("价格: %.2f", price));
System.out.println(String.format("带千分位: %,d", 12345678));
System.out.println(String.format("补零: %05d", 42));
// DecimalFormat
DecimalFormat df = new DecimalFormat("#,##0.00");
System.out.println("DecimalFormat: " + df.format(1234567.891));
// 格式化日期
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("格式化日期: " + sdf.format(date));
// 字符串转数字
String numStr = "123";
int num = Integer.parseInt(numStr);
long longNum = Long.parseLong("1234567890");
double doubleNum = Double.parseDouble("123.45");
System.out.println("字符串转数字: " + (num + longNum + doubleNum));
// 数字转字符串
int number = 456;
String strNum = String.valueOf(number);
String strNum2 = Integer.toString(number);
System.out.println("数字转字符串: " + strNum + " " + strNum2);
// 字符数组与字符串转换
String text = "Hello";
char[] charArray = text.toCharArray();
String backToString = new String(charArray);
System.out.println("字符数组转换: " + backToString);
}
}
实际应用案例：CSV处理
import java.util.ArrayList;
import java.util.List;
public class CSVProcessor {
public static void main(String[] args) {
String csvData = "1,张三,25,北京\n2,李四,30,上海\n3,王五,28,广州";
// 解析CSV数据
List<Person> persons = parseCSV(csvData);
System.out.println("解析CSV结果:");
persons.forEach(System.out::println);
// 生成CSV行
String csvLine = generateCSVLine("4", "赵六", "22", "深圳");
System.out.println("\n生成的CSV行: " + csvLine);
// 包含特殊字符的CSV
String specialData = "1,\"张,三\",25,\"北京\"\n2,李四,30,上海";
List<String[]> rows = parseCSVWithQuotes(specialData);
System.out.println("\n处理带引号的CSV:");
for (String[] row : rows) {
System.out.println(Arrays.toString(row));
}
}
private static List<Person> parseCSV(String csvData) {
List<Person> persons = new ArrayList<>();
String[] lines = csvData.split("\n");
for (String line : lines) {
String[] fields = line.split(",");
if (fields.length == 4) {
Person person = new Person(
Integer.parseInt(fields[0].trim()),
fields[1].trim(),
Integer.parseInt(fields[2].trim()),
fields[3].trim()
);
persons.add(person);
}
}
return persons;
}
private static String generateCSVLine(String... fields) {
return String.join(",", fields);
}
private static List<String[]> parseCSVWithQuotes(String csvData) {
List<String[]> result = new ArrayList<>();
String[] lines = csvData.split("\n");
for (String line : lines) {
// 处理带引号的字段
List<String> fields = new ArrayList<>();
StringBuilder current = new StringBuilder();
boolean inQuotes = false;
for (char c : line.toCharArray()) {
if (c == '"') {
inQuotes = !inQuotes;
} else if (c == ',' && !inQuotes) {
fields.add(current.toString());
current = new StringBuilder();
} else {
current.append(c);
}
}
fields.add(current.toString());
result.add(fields.toArray(new String[0]));
}
return result;
}
static class Person {
private int id;
private String name;
private int age;
private String city;
public Person(int id, String name, int age, String city) {
this.id = id;
this.name = name;
this.age = age;
this.city = city;
}
@Override
public String toString() {
return String.format("Person{id=%d, name='%s', age=%d, city='%s'}",
id, name, age, city);
}
}
}
实际应用案例：日志分析器
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class LogAnalyzer {
public static void main(String[] args) {
String logs = """
2024-01-15 10:15:30 INFO Application started successfully
2024-01-15 10:15:31 ERROR Failed to connect to database
2024-01-15 10:15:32 WARN Connection retry scheduled
2024-01-15 10:15:35 INFO Database connection established
2024-01-15 10:16:00 ERROR Timeout waiting for response
""";
// 解析日志
analyzeLogs(logs);
// 提取错误日志
System.out.println("\n错误日志:");
extractErrors(logs).forEach(System.out::println);
// 统计日志级别
System.out.println("\n日志级别统计:");
countLogLevels(logs).forEach((level, count) ->
System.out.println(level + ": " + count));
}
private static void analyzeLogs(String logs) {
String regex = "(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) (\\w+) (.+)";
Pattern pattern = Pattern.compile(regex);
System.out.println("日志分析结果:");
for (String line : logs.split("\n")) {
Matcher matcher = pattern.matcher(line);
if (matcher.find()) {
String timestamp = matcher.group(1);
String level = matcher.group(2);
String message = matcher.group(3);
System.out.printf("时间: %s | 级别: %s | 内容: %s%n",
timestamp, level, message);
}
}
}
private static List<String> extractErrors(String logs) {
return Arrays.stream(logs.split("\n"))
.filter(line -> line.contains("ERROR"))
.toList();
}
private static Map<String, Long> countLogLevels(String logs) {
String regex = "\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2} (INFO|ERROR|WARN|DEBUG)";
Pattern pattern = Pattern.compile(regex);
return Arrays.stream(logs.split("\n"))
.map(line -> {
Matcher matcher = pattern.matcher(line);
return matcher.find() ? matcher.group(1) : "UNKNOWN";
})
.collect(Collectors.groupingBy(
level -> level,
Collectors.counting()
));
}
}
字符串性能优化
public class StringPerformance {
public static void main(String[] args) {
int iterations = 100000;
// 测试String拼接性能
long start1 = System.currentTimeMillis();
String result1 = "";
for (int i = 0; i < iterations; i++) {
result1 += "a";
}
long end1 = System.currentTimeMillis();
System.out.println("String += 耗时: " + (end1 - start1) + "ms");
// 测试StringBuilder性能
long start2 = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < iterations; i++) {
sb.append("a");
}
String result2 = sb.toString();
long end2 = System.currentTimeMillis();
System.out.println("StringBuilder 耗时: " + (end2 - start2) + "ms");
// 测试预分配容量的StringBuilder
long start3 = System.currentTimeMillis();
StringBuilder sb2 = new StringBuilder(iterations);
for (int i = 0; i < iterations; i++) {
sb2.append("a");
}
String result3 = sb2.toString();
long end3 = System.currentTimeMillis();
System.out.println("预分配容量StringBuilder: " + (end3 - start3) + "ms");
// 字符串常量池
String str1 = "Hello";
String str2 = "Hello"; // 会复用常量池中的对象
String str3 = new String("Hello"); // 创建新对象
System.out.println("\n字符串常量池:");
System.out.println("str1 == str2: " + (str1 == str2)); // true
System.out.println("str1 == str3: " + (str1 == str3)); // false
System.out.println("str1.equals(str3): " + str1.equals(str3)); // true
// intern()方法使用
String str4 = new String("Hello").intern();
System.out.println("str1 == str4: " + (str1 == str4)); // true
}
}
实用工具类
import java.util.HashMap;
import java.util.Map;
public class StringUtils {
// 移除所有空格
public static String removeAllSpaces(String str) {
return str.replaceAll("\\s+", "");
}
// 转化为驼峰命名
public static String toCamelCase(String str, char delimiter) {
StringBuilder result = new StringBuilder();
boolean nextUpperCase = false;
for (char c : str.toCharArray()) {
if (c == delimiter) {
nextUpperCase = true;
} else if (nextUpperCase) {
result.append(Character.toUpperCase(c));
nextUpperCase = false;
} else {
result.append(Character.toLowerCase(c));
}
}
return result.toString();
}
// 反转字符串
public static String reverse(String str) {
return new StringBuilder(str).reverse().toString();
}
// 统计字符频率
public static Map<Character, Integer> characterFrequency(String str) {
Map<Character, Integer> freq = new HashMap<>();
for (char c : str.toCharArray()) {
freq.put(c, freq.getOrDefault(c, 0) + 1);
}
return freq;
}
// 隐藏部分信息（如手机号、邮箱）
public static String maskInfo(String info, String regex, String mask) {
return info.replaceAll(regex, mask);
}
// 检查是否为回文串
public static boolean isPalindrome(String str) {
String clean = str.toLowerCase().replaceAll("[^a-z0-9]", "");
int left = 0, right = clean.length() - 1;
while (left < right) {
if (clean.charAt(left++) != clean.charAt(right--)) {
return false;
}
}
return true;
}
public static void main(String[] args) {
// 测试工具类
System.out.println("移除空格: " + removeAllSpaces("Hello World Java"));
System.out.println("驼峰命名: " + toCamelCase("hello_world_java", '_'));
System.out.println("反转字符串: " + reverse("Hello World"));
Map<Character, Integer> freq = characterFrequency("hello");
System.out.println("字符频率: " + freq);
// 隐藏手机号中间四位
String phone = "13812345678";
System.out.println("隐藏手机号: " + maskInfo(phone, "(\\d{3})\\d{4}(\\d{4})", "$1****$2"));
System.out.println("是否回文: " + isPalindrome("A man, a plan, a canal: Panama"));
}
}
使用建议
- 大量字符串拼接：使用
StringBuilder或StringBuffer（线程安全） - 字符串比较：使用
equals()而不是 - 正则表达式：需要多次使用时，先编译
Pattern可提高性能 - 空值处理：使用
Optional<String>或自定义工具方法避免 NullPointerException - 性能优化：合理设置
StringBuilder初始容量，避免频繁扩容 - 编码处理：处理文本时注意指定正确的字符编码（如 UTF-8）
这些案例覆盖了Java字符串处理的主要场景和最佳实践。
