Java哈希表程序输出冗余零值，求去除零值的解决方案

嘿，我来帮你搞定这个零值的问题～

首先得搞清楚为什么会出现这些零：Java里的int数组在初始化时，所有元素默认值都是0，而你的哈希表目前是用int[]来存储元素的，那些没有被插入过元素的位置自然就保留了默认的0，输出的时候这些0就跟着出来了。

下面给你两个最直接的解决方案：

方案1：使用包装类Integer代替int #

把存储数组改成Integer[]，因为引用类型的默认值是null而不是0，这样未使用的位置就是null，输出的时候只需要判断元素不为null再打印就行。修改后的代码示例如下：

import java.util.Random;
class HashTable {
    Integer[] arr;
    int c;
    public HashTable(int capacity) {
        this.c = nextPrime(capacity);
        arr = new Integer[this.c]; // Integer数组默认元素为null
    }
    public void insert(int ele) {
        arr[ele % c] = ele;
    }
    public void clear() {
        arr = new Integer[c];
    }
    public boolean contains(int ele) {
        int index = ele % c;
        return arr[index] != null && arr[index].equals(ele);
    }
    // 示例打印方法，过滤null值
    public void printTable() {
        for (Integer num : arr) {
            if (num != null) {
                System.out.print(num + " ");
            }
        }
        System.out.println();
    }
    // 实现你之前未完成的nextPrime方法
    private int nextPrime(int n) {
        if (n <= 1) return 2;
        int prime = n;
        boolean found = false;
        while (!found) {
            prime++;
            if (isPrime(prime)) {
                found = true;
            }
        }
        return prime;
    }
    private boolean isPrime(int num) {
        if (num <= 1) return false;
        if (num <= 3) return true;
        if (num % 2 == 0 || num % 3 == 0) return false;
        for (int i = 5; i * i <= num; i += 6) {
            if (num % i == 0 || num % (i + 2) == 0) return false;
        }
        return true;
    }
}

方案2：用布尔数组标记已占用位置 #

保留int[]数组，但额外加一个boolean[]数组来记录每个位置是否被插入过元素。插入时标记对应位置为true，输出时只打印标记为true的位置的元素，这样就能过滤掉未使用位置的0。代码示例：

import java.util.Random;
class HashTable {
    int[] arr;
    boolean[] isOccupied;
    int c;
    public HashTable(int capacity) {
        this.c = nextPrime(capacity);
        arr = new int[this.c];
        isOccupied = new boolean[this.c]; // 初始全为false
    }
    public void insert(int ele) {
        int index = ele % c;
        arr[index] = ele;
        isOccupied[index] = true; // 标记该位置已被占用
    }
    public void clear() {
        arr = new int[c];
        isOccupied = new boolean[c]; // 重置标记数组
    }
    public boolean contains(int ele) {
        int index = ele % c;
        return isOccupied[index] && arr[index] == ele;
    }
    // 示例打印方法，只打印已占用位置的元素
    public void printTable() {
        for (int i = 0; i < c; i++) {
            if (isOccupied[i]) {
                System.out.print(arr[i] + " ");
            }
        }
        System.out.println();
    }
    // 同样实现nextPrime和isPrime方法
    private int nextPrime(int n) {
        if (n <= 1) return 2;
        int prime = n;
        boolean found = false;
        while (!found) {
            prime++;
            if (isPrime(prime)) {
                found = true;
            }
        }
        return prime;
    }
    private boolean isPrime(int num) {
        if (num <= 1) return false;
        if (num <= 3) return true;
        if (num % 2 == 0 || num % 3 == 0) return false;
        for (int i = 5; i * i <= num; i += 6) {
            if (num % i == 0 || num % (i + 2) == 0) return false;
        }
        return true;
    }
}

额外小提醒 #

你的insert方法目前没有处理哈希冲突哦——如果两个不同的元素计算出相同的哈希索引，后面的元素会直接覆盖前面的。如果需要解决这个问题，可以考虑开放寻址法（比如线性探测）或者链地址法（用链表数组存储），这会让你的哈希表功能更完善～

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