Java字符串处理案例

本文目录导读：

1. 字符串基础操作案例
2. 字符串分割与合并
3. 字符串验证与清洗
4. 字符串格式化与转换
5. 实际应用案例：CSV处理
6. 实际应用案例：日志分析器
7. 字符串性能优化
8. 实用工具类
9. 使用建议

我来为您提供几个实用的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"));
    }
}

使用建议

1. 大量字符串拼接：使用 StringBuilder 或 StringBuffer（线程安全）
2. 字符串比较：使用 equals() 而不是
3. 正则表达式：需要多次使用时，先编译 Pattern 可提高性能
4. 空值处理：使用 Optional<String> 或自定义工具方法避免 NullPointerException
5. 性能优化：合理设置 StringBuilder 初始容量，避免频繁扩容
6. 编码处理：处理文本时注意指定正确的字符编码（如 UTF-8）

这些案例覆盖了Java字符串处理的主要场景和最佳实践。