1

该程序只是应该从数组中消除重复项。但是，消除方法中的第二个 for 循环抛出了越界异常。我一直在看，但看不到这是怎么回事，所以我想我会将数组大小增加 1，这样我就可以让它工作，唯一的缺点是在末尾附加了一个额外的 0。

令我惊讶的是，当我将 tracker[] 的大小从 10 增加到 11 时，即使我没有输入大部分数字，程序也会打印出从 0 到 9 的每个数字。这些数字来自哪里，为什么我会遇到这个问题？

import java.util.*;
class nodupes 
{
    public static void main(String[] args) 
    {   

        int[] dataset = new int[10];


        //getting the numbers
        for (int i = 0; i <= 9 ; i++)
        {
            Scanner input = new Scanner(System.in);
            System.out.println("Enter a one digit number");
            dataset[i] = input.nextInt();
        }

        int[] answer = (eliminateduplicates(dataset));
        System.out.println(Arrays.toString(answer));
    }

    public static int[] eliminateduplicates(int[] numbers)
    {

        boolean[] tracker = new boolean[11];
        int arraysize = 1; 
        for(int k = 0; k <= 9; k++)
        {

            if(tracker[numbers[k]] == false)
            {
                arraysize++;
                tracker[numbers[k]] = true;
            }

        }
        int[] singles = new int[arraysize];

        for(int l = 0; l <= arraysize; l++)
        {
            if(tracker[l] == true)
            {
                singles[l] = l;

            }


        }

        return singles;
    }
}

这部分发生了异常

     if(tracker[l] == true)

但仅当跟踪器大小为 10 时。在 11 时它只打印 [0,1,2,3,4,5,6,7,8,9]

编辑： arraysize = 1 是调试的保留，最初它是 0

编辑：修复它，但现在末尾有一个 0，即使数组应该被完全填满。

public static int[] eliminateduplicates(int[] numbers)
{

    boolean[] tracker = new boolean[10];
    int arraysize = 0; 

    for(int k = 0; k < numbers.length; k++)
    {

        if(tracker[numbers[k]] == false)
        {
            arraysize++;
            tracker[numbers[k]] = true;
        }

    }
    int[] singles = new int[arraysize];
    int counter = 0;

    for(int l = 0; l < arraysize; l++)
    {
        if(tracker[l] == true)
        {
            singles[counter] = l;
            counter++;
        }


    }

    return singles;
}
4

5 回答 5

1

由于数组从 0 开始，因此您的数组大小将比唯一数字的数量大 1，因此您的最终循环经历了太多次。换句话说，如果您有 10 个唯一编号并且跟踪器只有项目 0-10，则“l”（字母 l - 尝试使用不同的变量名）将达到 11，因此是越界异常。尝试将声明更改为 int arraysize = 0;

于 2011-12-01T02:59:42.077 回答
1

再次被<=打败

for(int l = 0; l <= arraysize; l++)

数组大小为 10 表示 0-9，此循环将进入 0-10

对于数字的来源，

singles[l] = l;

将计数值分配给单打字段，因此单打 [1] 被分配 1，等等。

于 2011-12-01T03:01:36.820 回答
0

我觉得您为获得不重复所做的处理太多，如果您没有不使用 Collections 的限制，那么您可以试试这个

public class NoDupes {
    public static void main(String[] args) {
        Integer[] dataset = new Integer[10];
        for (int i = 0; i < 10; i++) {
          Scanner input = new Scanner(System.in);
          System.out.println("Enter a one digit number");
          dataset[i] = input.nextInt();
        }
        Integer[] arr = eliminateduplicates(dataset);
        for (Integer integer : arr) {
           System.out.println(integer);
        }
    }

     public static Integer[] eliminateduplicates(Integer[] numbers) {
        return new HashSet<Integer>(Arrays.asList(numbers)).toArray(new Integer[]{});
     }
}

要回答您的问题，您的最终循环将比大小多一个索引。

于 2011-12-01T03:07:52.647 回答
0

Java中数组中有效索引的范围是[0, SIZE)，即。从 0 到arraysize-1.

你得到异常的原因是因为在你的循环中你从 0 迭代到arraysize inclusively， 1 索引太远了：

for(int l = 0; l <= arraysize; l++)

因此，当您到达if(tracker[l] == true)最后一次迭代时，l将等于arraysize并且tracker[l]将超出数组的范围。您可以通过更改<=为循环条件轻松解决此问题。<for


当数组的大小从 10 更改为 11 时问题消失的原因与在导致问题的循环上方的循环arraysize中递增到 10有关。for这一次，singles[10]是数组中的一个有效元素，因为数组中的索引范围是 now [0, 11)。

编辑：实际上arraysize有可能增加到 11，我认为它被初始化为 0，在这种情况下它只会达到 10。以上任何一种方式仍然有效；您在数组中尝试访问的最后一个索引必须比数组的长度小 1，以避免出现异常，因为数组是从零开始的。所以，是的，长话短说，<=应该是<。

于 2011-12-01T03:08:25.767 回答
0

像 20 一样编辑，因为我真的应该睡着了。意识到我可能刚刚为你做了功课，所以我删除了代码。

arraySize 应该从 0 开始，因为您从没有数字开始，并在找到重复项时开始添加到这个大小。假设只有 1 个数字重复十次，您将创建一个大小为 2 的数组来存储 1 个数字。int arraysize = 0;

您的第一个 for 循环应该遍历numbers，因此在循环约束中使用数字的长度是有意义的。for( int i = 0; i < numbers.length; i ++)

对于第二个 for 循环：您需要遍历整个tracker数组，因此不妨使用该 ( tracker.length) 的长度。更少的幻数总是一件好事。您还需要其他变量来跟踪您在singles数组中的位置。如果 numbers 是 10 个 9 的数组，那么只有 tracker[9] 为真，但这应该放在 singles[0] 中。再说一次，我解释的不好，但没有图表很难。

Derp derp，我觉得很好/去睡觉了，所以瞧，我使用的代码（它在我尝试测试它的一次工作）：

public static int[] eliminateduplicates(int[] numbers)
{
    boolean[] tracker = new boolean[10];
    int arraysize = 0; 

    for(int k = 0; k < numbers.length; k++)
    {
        if(tracker[numbers[k]] == false)
        {
            arraysize++;
            tracker[numbers[k]] = true;
        }
    }

    int[] singles = new int[arraysize];

    for(int l = 0, count = 0; l < tracker.length; l++)
    {
        if(tracker[l] == true)
        {
            singles[count++] = l;
        }
    }

    return singles;
}
于 2011-12-01T03:08:58.537 回答