如何删除数组中的0值并收缩数组？添加指定收缩函数的技术咨询

1. 基础操作：删除数组中的0值并实现数组收缩 #

不管用什么语言，核心思路都是遍历数组筛选出非0元素，再通过生成新数组或原地修改的方式完成收缩。这里用两种常用语言给出具体实现：

JavaScript 实现 #

如果不介意生成新数组，用filter方法最简洁：

let arr = [1, 0, 3, 0, 5, 0];
// 直接筛选出非0元素，得到收缩后的数组
arr = arr.filter(item => item !== 0);
console.log(arr); // 输出: [1, 3, 5]

要是需要在原数组上原地修改（减少内存开销），可以用双指针法：

let arr = [1, 0, 3, 0, 5, 0];
let validIndex = 0;
for (let i = 0; i < arr.length; i++) {
  if (arr[i] !== 0) {
    arr[validIndex] = arr[i];
    validIndex++;
  }
}
// 截断数组到有效元素的长度
arr.length = validIndex;
console.log(arr); // 输出: [1, 3, 5]

Java 实现 #

Java数组长度固定，推荐用ArrayList来自动处理收缩，最后再转回数组：

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

public class ArrayShrinkDemo {
    public static void main(String[] args) {
        Integer[] arr = {1, 0, 3, 0, 5, 0};
        List<Integer> nonZeroList = new ArrayList<>();
        for (Integer num : arr) {
            if (num != 0) {
                nonZeroList.add(num);
            }
        }
        // 转换为收缩后的数组
        Integer[] shrunkArr = nonZeroList.toArray(new Integer[0]);
        System.out.println(Arrays.toString(shrunkArr)); // 输出: [1, 3, 5]
    }
}

2. 添加条件触发的收缩函数 #

要实现当数组中0的数量超过5个时自动删除0并移位的功能，只需要在基础收缩逻辑前加一层统计判断即可：

JavaScript 示例函数 #

function shrinkArrayOnZeroThreshold(arr) {
    // 先统计数组中0的数量
    const zeroCount = arr.filter(item => item === 0).length;
    if (zeroCount > 5) {
        // 满足条件时执行收缩，这里用原地修改的方式
        let validIndex = 0;
        for (let i = 0; i < arr.length; i++) {
            if (arr[i] !== 0) {
                arr[validIndex] = arr[i];
                validIndex++;
            }
        }
        arr.length = validIndex;
        return arr;
    }
    // 不满足条件则返回原数组
    return arr;
}

// 测试用例
let testArr1 = [0,0,0,0,0,0,1,2,3]; // 6个0，触发收缩
testArr1 = shrinkArrayOnZeroThreshold(testArr1);
console.log(testArr1); // 输出: [1,2,3]

let testArr2 = [0,0,0,4,5]; // 3个0，不触发收缩
testArr2 = shrinkArrayOnZeroThreshold(testArr2);
console.log(testArr2); // 输出: [0,0,0,4,5]

Java 示例函数 #

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

public class ConditionalShrinkDemo {
    public static Integer[] shrinkIfZeroExceedsFive(Integer[] arr) {
        int zeroCount = 0;
        // 统计0的数量
        for (Integer num : arr) {
            if (num == 0) {
                zeroCount++;
            }
        }
        if (zeroCount > 5) {
            List<Integer> nonZeroList = new ArrayList<>();
            for (Integer num : arr) {
                if (num != 0) {
                    nonZeroList.add(num);
                }
            }
            return nonZeroList.toArray(new Integer[0]);
        }
        // 不满足条件返回原数组
        return arr;
    }

    public static void main(String[] args) {
        Integer[] testArr1 = {0,0,0,0,0,0,6,7,8};
        testArr1 = shrinkIfZeroExceedsFive(testArr1);
        System.out.println(Arrays.toString(testArr1)); // 输出: [6,7,8]

        Integer[] testArr2 = {0,0,1,2,3};
        testArr2 = shrinkIfZeroExceedsFive(testArr2);
        System.out.println(Arrays.toString(testArr2)); // 输出: [0,0,1,2,3]
    }
}

额外提示 #

• 如果用的是Python、C#等其他语言，核心逻辑完全一致：先统计0的数量，判断是否超过阈值，再筛选非0元素完成收缩。
• 对性能要求高的场景，优先用原地修改的双指针法，避免生成新数组带来的内存开销。

内容的提问来源于stack exchange，提问作者user9439221