Java字符串字符去重与共享字符计数教程

import java.util.HashSet;
import java.util.Set;

public class StringProcessor {

    /**
     * 对输入字符串进行字符去重，返回只包含不重复字符的新字符串。
     *
     * @param s 待去重的字符串。
     * @return 去重后的字符串。
     */
    public static String dist(String s) {
        StringBuilder sb = new StringBuilder();
        Set<Character> set = new HashSet<>();
        for (int i = 0; i < s.length(); i++) {
            char currentChar = s.charAt(i);
            // 如果字符成功添加到Set中（即之前未出现过），则追加到StringBuilder
            if (set.add(currentChar)) {
                sb.append(currentChar);
            }
        }
        return sb.toString();
    }

    // ... 其他方法 ...
}

import java.util.Arrays; // 引入Arrays用于打印结果，实际业务逻辑中可省略

public class StringProcessor {

    /**
     * 对输入字符串进行字符去重，返回只包含不重复字符的新字符串。
     * 此方法已在前面详细解释。
     */
    public static String dist(String s) {
        StringBuilder sb = new StringBuilder();
        Set<Character> set = new HashSet<>();
        for (int i = 0; i < s.length(); i++) {
            char currentChar = s.charAt(i);
            if (set.add(currentChar)) {
                sb.append(currentChar);
            }
        }
        return sb.toString();
    }

    /**
     * 处理字符串数组，对其元素和目标字符串进行去重，并计算共享字符数量。
     *
     * @param b 目标字符串。
     * @param a 字符串数组。
     * @return 一个整数数组，其中每个元素表示对应去重后的a[i]与去重后的b之间共享的字符数量。
     */
    public static int[] mathProfessor(String b, String[] a) {
        // 1. 对目标字符串b进行字符去重
        String distinctB = dist(b);

        // 2. 初始化用于存储去重后的a数组元素和最终计数的数组
        String[] distinctArrayElements = new String[a.length];
        int[] countArray = new int[a.length];

        // 3. 对字符串数组a中的每个元素进行字符去重
        for (int i = 0; i < a.length; i++) {
            distinctArrayElements[i] = dist(a[i]);
        }

        // 4. 进行字符匹配与计数
        int currentCount = 0;
        for (int i = 0; i < distinctArrayElements.length; i++) { // 遍历去重后的a数组中的每个元素
            String currentDistinctElement = distinctArrayElements[i];
            for (int j = 0; j < distinctB.length(); j++) { // 遍历去重后的目标字符串b的每个字符
                char charFromDistinctB = distinctB.charAt(j);
                // 检查当前distinctB的字符是否包含在currentDistinctElement中
                if (currentDistinctElement.contains(Character.toString(charFromDistinctB))) {
                    currentCount++;
                }
            }
            // 存储当前元素的计数，并重置计数器
            countArray[i] = currentCount;
            currentCount = 0;
        }

        return countArray;
    }

    public static void main(String[] args) {
        String inputB = "iyee";
        String[] inputA = {"hi", "bye", "bebe"};
        int[] result = mathProfessor(inputB, inputA);
        System.out.println("输入B: \"" + inputB + "\"");
        System.out.println("输入A: " + Arrays.toString(inputA));
        System.out.println("输出结果: " + Arrays.toString(result)); // 预期输出: [1, 2, 1]

        String inputB2 = "apple";
        String[] inputA2 = {"banana", "orange", "grape"};
        int[] result2 = mathProfessor(inputB2, inputA2);
        System.out.println("\n输入B: \"" + inputB2 + "\"");
        System.out.println("输入A: " + Arrays.toString(inputA2));
        System.out.println("输出结果: " + Arrays.toString(result2)); // 预期输出: [2, 2, 1] (distinctB="aple", distinctA=["ban", "orag", "grape"])
                                                                    // 'a', 'p', 'l', 'e'
                                                                    // "ban": 'a' (1) -> 1
                                                                    // "orag": 'a', 'e' (2) -> 2
                                                                    // "grape": 'a', 'p', 'e' (3) -> 3. Oh wait, my manual check for distinctA2 is wrong.
                                                                    // distinctA2 = ["ban", "orage", "grape"]
                                                                    // Let's re-evaluate:
                                                                    // distinctB = "aple"
                                                                    // distinctA[0] = "ban" -> 'a' in "aple"? Yes. 'p' in "ban"? No. 'l' in "ban"? No. 'e' in "ban"? No. Count = 1.
                                                                    // distinctA[1] = "orage" -> 'o' in "aple"? No. 'r' in "aple"? No. 'a' in "aple"? Yes. 'g' in "aple"? No. 'e' in "aple"? Yes. Count = 2.
                                                                    // distinctA[2] = "grape" -> 'g' in "aple"? No. 'r' in "aple"? No. 'a' in "aple"? Yes. 'p' in "aple"? Yes. 'e' in "aple"? Yes. Count = 3.
                                                                    // So, result2 should be [1, 2,