如何从数组中获取值而不计算其重复项？

Question

我知道这个标题真的很糟糕，但我花了大约 10 分钟的时间想一个简洁的方式来描述我的问题，但我做不到。 该程序应该创建一个 numUnique() 静态方法，该方法返回数组中唯一数字的数量。因此，例如，如果我有一个包含 {2, 4, 2, 7, 16, 4} 的数组，则唯一数字的数量将为 4（2、4、7 和 16）。

我正在编写代码以在我的数组中查找重复项，然后我意识到当我有重复项时我不知道如何处理它，我一直在努力思考解决方案但我不能。

这是目前为止的代码：

public class Unique {
    public static void main(String[] args) {
        int[] numbers = {1, 6, 2, 14, 6, 8, 2, 1, 23};
        numUnique(numbers);
    }

    public static void numUnique(int[] array){
        Arrays.sort(array);
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] == array[j])
                    //code here
            }
        }
    }
}

Answer 1

我的理解是您计算（而不是全部返回）数组中唯一元素的数量。您正试图一直向下看，但只要跟踪重复的数量就足够了。这段代码回顾一下当前条目是否与前一个条目重复（这有效，因为您进行了排序，这是一个很好的步骤）。

import java.util.Arrays;
public class Unique {
public static void main(String[] args) {
    int[] numbers = {
        1,
        6,
        2,
        14,
        6,
        8,
        2,
        1,
        23
    };
    System.out.println(numUnique(numbers));
}

public static int numUnique(int[] array) {
    Arrays.sort(array);
    int dups = 0;
    for (int i = 1; i < array.length; i++) {
        if (array[i] == array[i - 1]) {
            dups++;
        }
    }
    return (array.length - dups);
}
}

Answer 2

如果您想保留目前的代码并对列表进行排序，有两个选项似乎很有意义。其中一种是返回唯一整数的个数，另一种是返回唯一整数的列表。

返回唯一数字的数量：

public static int numUnique(int[] array) {
    ArrayList<Integer> uniques = new ArrayList<>();
    Arrays.sort(array);

    uniques.add(array[0]);

    int prev = array[0];
    for (int i = 1; i < array.length; i++) {
        if(array[i] != prev){
            uniques.add(array[i]);
            prev = array[i]
        }
    }
    return uniques.size();
}

返回唯一编号列表，只需要您返回唯一列表，不带 .size()。

如果你想要一个数组而不是一个列表，你需要返回以下内容：

return uniques.toArray(new Integer[list.size()]);

Answer 3

如果您正在使用数组，为什么不进一步探索它

private static long numUnique(int[] numbers) {
    return Arrays.stream(numbers).distinct().count();
}

Answer 4

保持代码不变：

如果您想知道数组中有多少非重复项：

public static void numUnique(int[] array) {
        Arrays.sort(array);
// Here, make a variable that keeps size of an array
        int arrayLenght = array.length;
// Here is our counter:
        int duplicates = 0;

        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] == array[j])
                    // when you find duplicate, add 1 to our counter:
                    duplicates++;

            }
        }
        //at the end you can count how many non-duplicates are in the array:
        arrayLenght -= duplicates;
        System.out.println("There are " + arrayLenght + " non duplicates in our array.");
    }

编辑 此解决方案并非适用于所有情况。

我知道这不是最好的方法，但我唯一知道的哈：

public static void numUnique(int[] array) {
        Arrays.sort(array);

        int arrayLenght = array.length;
        int duplicates = 0;

        for (int i = 0; i < array.length; i++) {
//a little change in our second for-loop:
            for (int j = 0; j < array.length; j++) {
                if (array[i] == array[j]) { 
//Here i'm just summing up the duplicates
                duplicates ++;
                }

            }
// Aaand here, on a console, i print the value (array[i]) and how many duplicates does it have.

//to be exact, if the duplcicates rise only once so it's equal to 1, it means that there is no duplicate of this value (it found itself in the loop).

            if (duplicates == 1) {
                duplicates = 0;
            }

            System.out.println(array[i] + " have " + duplicates + "duplicates");

// And what is imporatnt We have to reset our duplication-container!
// so in further loops it will count duplicates for each value in array

            duplicates = 0;

        }

    }

如果您发现其他问题，请立即询问我