限制数组元素出现次数：高效保留指定频率的策略

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;

public class ArrayFrequencyLimiter {

    /**
     * 限制数组中每个元素的出现次数不超过指定上限，并返回新数组。
     * 保持原始元素的相对顺序。
     *
     * @param arr   输入整数数组
     * @param limit 每个元素允许出现的最大次数
     * @return 经过处理的新数组
     */
    public static int[] removeOccurrencesAboveLimit(int[] arr, int limit) {
        // 使用HashMap存储每个元素的当前出现频率
        // Key: 元素值, Value: 该元素在结果列表中已出现的次数
        Map<Integer, Integer> occurrences = new HashMap<>();

        // 用于构建结果的新列表
        List<Integer> resultList = new ArrayList<>();

        // 遍历原始数组中的每个元素
        for (int next : arr) {
            // 使用 Map.merge() 方法简洁地更新元素的频率。
            // 如果元素不存在，则将其频率设为1；如果存在，则将其频率加1。
            // merge方法返回的是更新后的值。
            int currentFreq = occurrences.merge(next, 1, Integer::sum);

            // 如果当前元素的频率（在结果列表中）尚未超过限制，则将其添加到结果列表
            if (currentFreq <= limit) {
                resultList.add(next);
            }
            // 如果 currentFreq > limit，则表示该元素已超出限制，不添加到结果列表
        }

        // 将结果列表转换为整数数组并返回
        return toIntArray(resultList);
    }

    /**
     * 辅助方法：将 List<Integer> 转换为 int[]。
     *
     * @param list 待转换的整数列表
     * @return 转换后的整数数组
     */
    public static int[] toIntArray(List<Integer> list) {
        // 使用Java 8 Stream API 将 List<Integer> 转换为 int[]
        return list.stream().mapToInt(Integer::intValue).toArray();
    }

    public static void main(String[] args) {
        // 示例一：
        int[] arr1 = {2, 2, 2, 3, 4, 4, 5};
        System.out.println("原始数组1: " + Arrays.toString(arr1));
        System.out.println("限制为2次后的结果1: " + Arrays.toString(removeOccurrencesAboveLimit(arr1, 2))); // 预期: [2, 2, 3, 4, 4, 5]

        System.out.println("--------------------");

        // 示例二：
        int[] arr2 = {3, 1, 2, 1, 3, 3, 4, 4, 5, 1, 3, 5};
        System.out.println("原始数组2: " + Arrays.toString(arr2));
        System.out.println("限制为2次后的结果2: " + Arrays.toString(removeOccurrencesAboveLimit(arr2, 2))); // 预期: [3, 1, 2, 1, 3, 4, 4, 5, 5]

        System.out.println("--------------------");

        // 示例三：
        int[] arr3 = {1, 1, 1, 1, 2, 2, 3, 3, 3};
        System.out.println("原始数组3: " + Arrays.toString(arr3));
        System.out.println("限制为1次后的结果3: " + Arrays.toString(removeOccurrencesAboveLimit(arr3, 1))); // 预期: [1, 2, 3]
    }
}

原始数组1: [2, 2, 2, 3, 4, 4, 5]
限制为2次后的结果1: [2, 2, 3, 4, 4, 5]
--------------------
原始数组2: [3, 1, 2, 1, 3, 3, 4, 4, 5, 1, 3, 5]
限制为2次后的结果2: [3, 1, 2, 1, 3, 4, 4, 5, 5]
--------------------
原始数组3: [1, 1, 1, 1, 2, 2, 3, 3, 3]
限制为1次后的结果3: [1, 2, 3]