Java中高效过滤整型数组：使用ArrayList处理动态数据集合

public int[] getValuesAboveThreshold(int threshold) {
    int[] a = new int[] { 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93 };
    int temp[] = new int[1]; // 初始数组大小不确定

    for (int d : a) {
        if (d > threshold) {
            // 每次找到符合条件的元素，都重新创建一个更大的数组
            temp = new int[temp.length + 1];
            // 错误：这里的内层循环会用当前d的值填充整个新创建的temp数组
            for (int i = 0; i < temp.length; i++) {
                temp[i] = d;
            }
        }
    }
    return temp;
}

import java.util.ArrayList;
import java.util.List; // 推荐使用接口类型声明

public class ArrayFilter {

    /**
     * 根据指定阈值过滤整型数组，并返回符合条件的元素列表。
     *
     * @param threshold 过滤阈值，只有大于此阈值的元素才会被包含在结果中。
     * @return 包含所有大于阈值元素的ArrayList。
     */
    public static ArrayList<Integer> getValuesAboveThreshold(int threshold) {
        // 原始数据数组
        int[] a = new int[] { 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93 };

        // 创建一个ArrayList来存储符合条件的元素
        ArrayList<Integer> resultList = new ArrayList<>();

        // 遍历原始数组
        for (int d : a) {
            // 判断元素是否大于阈值
            if (d > threshold) {
                // 如果符合条件，则将其添加到ArrayList中
                resultList.add(d);
            }
        }
        // 返回包含过滤后元素的ArrayList
        return resultList;
    }

    public static void main(String[] args) {
        int threshold = 78;
        ArrayList<Integer> filteredValues = getValuesAboveThreshold(threshold);
        System.out.println("Output for values above " + threshold + ": " + filteredValues);
        // 预期输出: Output for values above 78: [85, 93, 81, 79, 81, 93]
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamFilterExample {
    public static List<Integer> getValuesAboveThresholdWithStream(int threshold) {
        int[] a = new int[] { 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93 };

        return Arrays.stream(a) // 将int[]转换为IntStream
                     .filter(d -> d > threshold) // 过滤元素
                     .boxed() // 将int转换为Integer，以便收集到List<Integer>
                     .collect(Collectors.toList()); // 收集结果到List
    }

    public static void main(String[] args) {
        int threshold = 78;
        List<Integer> filteredValues = getValuesAboveThresholdWithStream(threshold);
        System.out.println("Output for values above " + threshold + " (Stream): " + filteredValues);
    }
}

import java.util.ArrayList;
import java.util.List;

public class ConvertToListToArray {
    public static int[] getValuesAboveThresholdAsArray(int threshold) {
        ArrayList<Integer> filteredList = getValuesAboveThreshold(threshold); // 调用之前的ArrayList方法

        // 将ArrayList<Integer>转换为int[]
        int[] resultArray = new int[filteredList.size()];
        for (int i = 0; i < filteredList.size(); i++) {
            resultArray[i] = filteredList.get(i); // 自动拆箱
        }
        return resultArray;
    }

    // getValuesAboveThreshold 方法同上文
    public static ArrayList<Integer> getValuesAboveThreshold(int threshold) {
        int[] a = new int[] { 58, 78, 61, 72, 93, 81, 79, 78, 75, 81, 93 };
        ArrayList<Integer> resultList = new ArrayList<>();
        for (int d : a) {
            if (d > threshold) {
                resultList.add(d);
            }
        }
        return resultList;
    }

    public static void main(String[] args) {
        int threshold = 78;
        int[] filteredArray = getValuesAboveThresholdAsArray(threshold);
        System.out.print("Output for values above " + threshold + " (as int[]): [");
        for (int i = 0; i < filteredArray.length; i++) {
            System.out.print(filteredArray[i]);
            if (i < filteredArray.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }
}