Java数组元素频率限制：高效控制最大重复次数的教程

// 1. HashMap to count frequency of each element
Map<Integer, Integer> data = new HashMap<>();
for (int element : arr) {
    data.put(element, data.getOrDefault(element, 0) + 1);
}

// 2. 假设找到一个出现次数超过限制的元素 need_to_remove
// 例如：元素2出现了3次，限制为2
// 3. 尝试从map中移除 'need_to_remove'
// data.remove(need_to_remove); // 这将移除所有关于 'need_to_remove' 的信息，而非仅仅减少计数
// 并且，这也不能直接修改原始数组或列表

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; // 用于toArray方法

public class ArrayElementFrequencyLimiter {

    /**
     * 限制数组中每个元素的出现次数，使其不超过指定限制。
     * 保持元素的相对顺序。
     *
     * @param arr   原始整数数组
     * @param limit 每个元素允许出现的最大次数
     * @return 经过处理后的新数组，其中每个元素的出现次数不超过limit
     */
    public static int[] removeOccurrencesAboveLimit(int[] arr, int limit) {
        // 用于存储每个元素及其当前出现次数
        Map<Integer, Integer> occurrences = new HashMap<>();
        // 用于构建最终结果列表
        List<Integer> result = new ArrayList<>();

        // 遍历原始数组
        for (int next : arr) {
            // 使用 merge 方法更新元素的出现次数。
            // merge(key, value, remappingFunction) 的工作原理：
            // 如果 key 不存在，则插入 (key, value)。
            // 如果 key 存在，则将 key 对应的旧值与 value 传入 remappingFunction 进行计算，
            // 并用计算结果更新 key 的值。
            // 这里 value 是 1 (表示当前元素又出现了一次)，remappingFunction 是 Integer::sum (将旧值与1相加)。
            // merge 方法返回的是更新后的值，即当前元素的最新出现次数。
            int freq = occurrences.merge(next, 1, Integer::sum);

            // 如果当前元素的出现次数未超过限制，则将其添加到结果列表中
            if (freq <= limit) {
                result.add(next);
            }
        }

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

    /**
     * 将 List<Integer> 转换为 int[] 数组。
     *
     * @param list 待转换的整数列表
     * @return 转换后的整数数组
     */
    public static int[] toArray(List<Integer> list) {
        // 使用 Java 8 Stream API 将 List<Integer> 转换为 int[]
        return list.stream().mapToInt(i -> i).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("--------------------");

        // 示例三：限制次数为1（去重）
        int[] arr3 = {1, 1, 1, 2, 2, 3, 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, 2, 2, 3, 3, 3, 3]
限制次数1后的结果3: [1, 2, 3]