Java实现获取一段文字中文字符数量的工具类

public static int countChinese(String text) {
    if (text == null || text.isEmpty()) return 0;
    Matcher m = DEFAULT_PATTERN.matcher(text);
    int count = 0;
    while (m.find()) count++;
    return count;
}

public static long countByCodePoint(String text) {
    if (text == null) return 0;
    return text.codePoints()
        .filter(cp -> cp >= 0x4E00 && cp <= 0x9FFF)
        .count();
}

public static int countChinese(Reader reader) {
    BufferedReader br = new BufferedReader(reader);
    String line;
    int total = 0;
    while ((line = br.readLine()) != null) {
        total += countChinese(line);
    }
    return total;
}

// 文件：ChineseCounter.java
package com.example.textcounter;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 中文字符统计工具类
 * 支持静态方法与可配置实例对象两种方式
 */
public final class ChineseCounter {
    // 默认匹配汉字的正则：包含常用汉字（CJK Unified Ideographs）
    private static final Pattern DEFAULT_PATTERN = Pattern.compile("[\\u4E00-\\u9FFF]");

    // 私有构造，禁止实例化
    private ChineseCounter() {}

    /**
     * 静态方法：统计字符串中的中文字符数量（使用默认范围）
     * @param text 输入文本
     * @return 中文字符个数
     */
    public static int countChinese(String text) {
        if (text == null || text.isEmpty()) return 0;
        Matcher matcher = DEFAULT_PATTERN.matcher(text);
        int count = 0;
        while (matcher.find()) {
            count++;
        }
        return count;
    }

    /**
     * 静态方法：基于字符码点方式统计中文数量（推荐：性能更优）
     * @param text 输入文本
     * @return 中文字符个数
     */
    public static long countChineseByCodePoint(String text) {
        if (text == null) return 0;
        return text.codePoints()
            .filter(cp -> (cp >= 0x4E00 && cp <= 0x9FFF)) // 可扩展至其他 Unicode 区
            .count();
    }

    /**
     * 静态方法：按行读取字符流并统计中文数量（适合大文本）
     * @param reader 字符流 Reader
     * @return 中文字符个数
     * @throws IOException 读取异常
     */
    public static int countChinese(Reader reader) throws IOException {
        if (reader == null) return 0;
        BufferedReader br = new BufferedReader(reader);
        String line;
        int total = 0;
        while ((line = br.readLine()) != null) {
            total += countChinese(line);
        }
        return total;
    }

    /**
     * 可配置实例类（支持自定义正则）
     */
    public static class Instance {
        private final Pattern pattern;

        /**
         * 使用正则表达式创建统计实例
         * @param regex 自定义正则（必须非空）
         */
        public Instance(String regex) {
            if (regex == null || regex.isEmpty()) {
                throw new IllegalArgumentException("正则表达式不能为空");
            }
            this.pattern = Pattern.compile(regex);
        }

        /**
         * 使用 Unicode 范围创建统计实例
         * @param start 起始码点（如 0x4E00）
         * @param end   结束码点（如 0x9FFF）
         */
        public Instance(int start, int end) {
            if (start > end) {
                throw new IllegalArgumentException("起始码点不能大于结束码点");
            }
            String regex = String.format("[%s-%s]",
                new String(Character.toChars(start)),
                new String(Character.toChars(end)));
            this.pattern = Pattern.compile(regex);
        }

        /**
         * 使用该实例统计字符串中的匹配字符数量
         * @param text 输入文本
         * @return 匹配字符数量
         */
        public int count(String text) {
            if (text == null || text.isEmpty()) return 0;
            Matcher matcher = pattern.matcher(text);
            int count = 0;
            while (matcher.find()) {
                count++;
            }
            return count;
        }
    }
}

// 文件：ChineseCounterTest.java
package com.example.textcounter;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 中文字符统计测试类
 */
public class ChineseCounterTest {

    @Test
    public void testNullAndEmpty() {
        assertEquals(0, ChineseCounter.countChinese(null));
        assertEquals(0, ChineseCounter.countChinese(""));
    }

    @Test
    public void testMixedContent() {
        String text = "你好，world！123";
        assertEquals(2, ChineseCounter.countChinese(text));
    }

    @Test
    public void testOnlyChinese() {
        String text = "这是纯中文";
        assertEquals(5, ChineseCounter.countChinese(text));
    }

    @Test
    public void testCodePointMethod() {
        String text = "ABC和中文组合🙂";
        assertEquals(3, ChineseCounter.countChineseByCodePoint(text));
    }

    @Test
    public void testCustomInstanceRegex() {
        ChineseCounter.Instance custom = new ChineseCounter.Instance("[\\u4E00-\\u9FFF]");
        assertEquals(4, custom.count("中英文混排测试"));
    }

    @Test
    public void testUnicodeRange() {
        ChineseCounter.Instance range = new ChineseCounter.Instance(0x4E00, 0x9FFF);
        assertEquals(2, range.count("Hello中国"));
    }

    @Test
    public void testInvalidRegex() {
        assertThrows(IllegalArgumentException.class, () -> new ChineseCounter.Instance(""));
    }

    @Test
    public void testInvalidUnicodeRange() {
        assertThrows(IllegalArgumentException.class, () -> new ChineseCounter.Instance(0x9FFF, 0x4E00));
    }
}