Question

所以我创建了一个带有随机数的数组，我打印并计算了重复的数字，现在我只需要创建一个具有相同数字的新数组，但不需要重复。顺便说一下，不能使用ArrayList。

我拥有的是什么。

public static void main(String[] args) {

    Random generator = new Random();
    int aR[]= new int[20];

    for(int i=0;i<aR.length;i++){
        int number=generator.nextInt(51);
        aR[i]=number;
        System.out.print(aR[i]+" ");

    }
    System.out.println();
    System.out.println();
    int countRep=0;
    for(int i=0;i<aR.length;i++){
        for(int j=i+1;j<aR.length-1;j++){
            if(aR[i]==aR[j]){
                countRep++;
                System.out.println(aR[i]+" "+aR[j]);
                break;
            }
        }
    }   
    System.out.println();
    System.out.println("Repeated numbers:  "+countRep);

    int newaR[]= new int[aR.length - countRep];




}

有人可以帮忙吗？

编辑：也不能真正使用HashSet。此外，新阵列需要具有正确的大小。

Answer 1

使用Java 8和流，您可以执行以下操作：

int[] array = new int[1024];
//fill array
int[] arrayWithoutDuplicates = Arrays.stream(array)
        .distinct()
        .toArray();

这将：

将您的int[]变为IntStream。
过滤掉所有重复项，以便保留不同的元素。
将其保存在int[]类型的新数组中。

Answer 2

尝试：

Set<Integer> insertedNumbers = new HashSet<>(newaR.length);
int index = 0;
for(int i = 0 ; i < aR.length ; ++i) {
    if(!insertedNumbers.contains(aR[i])) {
        newaR[index++] = aR[i];
    }
    insertedNumbers.add(aR[i]);
}

Answer 3

一种可能的方法是遍历数组，并为每个值计算数组中再次的索引（如果数字不再出现，则为-1）。 not 再次出现的值的数量是唯一值的数量。然后从数组中收集相应索引为-1的所有值。

import java.util.Arrays;
import java.util.Random;

public class UniqueIntTest
{
    public static void main(String[] args)
    {
        int array[] = createRandomArray(20, 0, 51);
        System.out.println("Array " + Arrays.toString(array));

        int result[] = computeUnique(array);
        System.out.println("Result " + Arrays.toString(result));
    }

    private static int[] createRandomArray(int size, int min, int max)
    {
        Random random = new Random(1);
        int array[] = new int[size];
        for (int i = 0; i < size; i++)
        {
            array[i] = min + random.nextInt(max - min);
        }
        return array;
    }

    private static int[] computeUnique(int array[])
    {
        int indices[] = new int[array.length];
        int unique = computeIndices(array, indices);
        int result[] = new int[unique];
        int index = 0;
        for (int i = 0; i < array.length; i++)
        {
            if (indices[i] == -1)
            {
                result[index] = array[i];
                index++;
            }
        }
        return result;
    }

    private static int computeIndices(int array[], int indices[])
    {
        int unique = 0;
        for (int i = 0; i < array.length; i++)
        {
            int value = array[i];
            int index = indexOf(array, value, i + 1);
            if (index == -1)
            {
                unique++;
            }
            indices[i] = index;
        }
        return unique;
    }

    private static int indexOf(int array[], int value, int offset)
    {
        for (int i = offset; i < array.length; i++)
        {
            if (array[i] == value)
            {
                return i;
            }
        }
        return -1;
    }
}

Answer 4

这听起来像是一个家庭作业问题，如果是这样，你应该采用的技术是先对数组进行排序。

一旦数组被排序，重复的条目将彼此相邻，因此它们很容易找到：

int[] numbers = //obtain this however you normally would
java.util.Arrays.sort(numbers);

//find out how big the array is
int sizeWithoutDuplicates = 1; //there will be at least one entry
int lastValue = numbers[0];

//a number in the array is unique (or a first duplicate)
//if it's not equal to the number before it
for(int i = 1; i < numbers.length; i++) {
    if (numbers[i] != lastValue) {
        lastValue = i;
        sizeWithoutDuplicates++;
    }
}

//now we know how many results we have, and we can allocate the result array
int[] result = new int[sizeWithoutDuplicates];

//fill the result array
int positionInResult = 1; //there will be at least one entry
result[0] = numbers[0];
lastValue = numbers[0];

for(int i = 1; i < numbers.length; i++) {
    if (numbers[i] != lastValue) {
        lastValue = i;
        result[positionInResult] = i;
        positionInResult++;
    }
}

//result contains the unique numbers

无法使用列表意味着我们必须在单独的传递中弄清楚数组的大小 - 如果我们可以使用ArrayList来收集结果，那么我们只需要通过一个循环一系列数字。

这种方法比通过数组的双嵌套循环更快（O（n log n）vs O（n ^ 2））来查找重复项。在O（n）处使用HashSet会更快。

创建一个具有相同数字的数组，但没有重复

4 个答案: