字符串去重与字符匹配计数：高效处理字符数组的Java教程

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

/**
 * 从给定字符串中提取所有不重复的字符，并按其首次出现的顺序返回。
 *
 * @param s 待去重的字符串。
 * @return 包含去重字符的新字符串。
 */
public static String dist(String s) {
    StringBuilder sb = new StringBuilder();
    Set<Character> set = new HashSet<>(); // 使用HashSet存储已遇到的字符
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        // 如果字符首次添加到set中，则将其追加到结果字符串
        if (set.add(c)) { 
            sb.append(c);
        }
    }
    return sb.toString();
}

import java.util.stream.Collectors;

// ... (在同一个类中)
public static String distWithStream(String s) {
    return s.chars() // 将字符串转换为IntStream，表示字符的ASCII值
            .distinct() // 去除重复的字符
            .mapToObj(c -> String.valueOf((char) c)) // 将int转换回char并包装为String
            .collect(Collectors.joining()); // 将所有字符连接成一个字符串
}

// 假设我们有一个字符串数组 a
String[] a = {"hi", "bye", "bebe"};
String[] distinctArray = new String[a.length];

for (int i = 0; i < a.length; i++) {
    distinctArray[i] = dist(a[i]); // 对数组中的每个字符串调用去重方法
}
// 此时 distinctArray 变为 ["hi", "bye", "be"]

/**
 * 计算两个去重后的字符串有多少个共同字符。
 *
 * @param s1 第一个去重字符串。
 * @param s2 第二个去重字符串。
 * @return 共同字符的数量。
 */
public static int countCommonDistinctChars(String s1, String s2) {
    int count = 0;
    // 遍历其中一个字符串的每个字符
    for (int i = 0; i < s1.length(); i++) {
        char c = s1.charAt(i);
        // 检查这个字符是否存在于另一个字符串中
        if (s2.contains(String.valueOf(c))) {
            count++;
        }
    }
    return count;
}

import java.util.HashSet;
import java.util.Set;
import java.util.Arrays; // 用于打印数组，方便测试

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 c = s.charAt(i);
            if (set.add(c)) {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 根据指定逻辑处理字符串和字符串数组：
     * 1. 对目标字符串 B 进行去重。
     * 2. 对数组 a 中的每个字符串进行去重。
     * 3. 计算去重后的数组元素与去重后的目标字符串 B 的共同字符数量。
     *
     * @param b 目标字符串。
     * @param a 字符串数组。
     * @return 一个整数数组，包含每个数组元素与目标字符串的共同字符数量。
     */
    public static int[] mathProfessor(String b, String[] a) {
        // 1. 对目标字符串 B 进行去重
        String distinctB = dist(b);

        // 2. 对数组 a 中的每个字符串进行去重，并存储到新数组中
        String[] distinctArrayElements = new String[a.length];
        for (int i = 0; i < a.length; i++) {
            distinctArrayElements[i] = dist(a[i]);
        }

        // 3. 计算共同字符数量并存储结果
        int[] countResult = new int[a.length];
        for (int i = 0; i < distinctArrayElements.length; i++) {
            int currentCount = 0;
            String currentElement = distinctArrayElements[i];

            // 遍历去重后的目标字符串 B 的每个字符
            for (int j = 0; j < distinctB.length(); j++) {
                char charFromB = distinctB.charAt(j);
                // 检查当前字符是否存在于去重后的数组元素中
                if (currentElement.contains(String.valueOf(charFromB))) {
                    currentCount++;
                }
            }
            countResult[i] = currentCount;
        }

        return countResult;
    }

    public static void main(String[] args) {
        String sampleB = "iyee";
        String[] sampleA = {"hi", "bye", "bebe"};
        int[] output = mathProfessor(sampleB, sampleA);
        System.out.println("Sample Input B: \"" + sampleB + "\"");
        System.out.println("Sample Input A: " + Arrays.toString(sampleA));
        System.out.println("Sample Output: " + Arrays.toString(output)); // 预期输出: [1, 2, 1]

        String sampleB2 = "programming";
        String[] sampleA2 = {"java", "python", "javascript", "go"};
        int[] output2 = mathProfessor(sampleB2, sampleA2);
        System.out.println("\nSample Input B: \"" + sampleB2 + "\"");
        System.out.println("Sample Input A: " + Arrays.toString(sampleA2));
        System.out.println("Sample Output: " + Arrays.toString(output2)); 
        // distinctB = "progami"
        // distinctA2 = ["jav", "pytho", "javascrit", "go"]
        // "jav" vs "progami" -> 'a' -> 1
        // "pytho" vs "progami" -> 'p', 'o' -> 2
        // "javascrit" vs "progami" -> 'a', 'r', 'g', 'i' -> 4
        // "go" vs "progami" -> 'g', 'o' -> 2
        // Expected: [1, 2, 4, 2]
    }
}