Откуда эта программа получает свои числа и почему это вызвано увеличением размера 1 массива?(Джава)

Question

Эта программа просто должна удалять дубликаты из массива. Однако вторым циклом for в методе исключений было исключение вне границ. Я искал и не мог видеть, как это могло быть, поэтому я решил, что увеличу размер массива на 1, чтобы заставить его работать, с единственным недостатком - добавлением 0 в конец.

К моему удивлению, когда я увеличил размер трекера [] с 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]

РЕДАКТИРОВАТЬ: размер массива = 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;
}

Answer 1

Еще раз побежден <= </p>

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

Размер массива 10 означает 0-9, этот цикл будет идти 0-10

Для того, откуда приходят цифры1006 *

singles[l] = l;

присваивает значения счетчиков полям синглов, поэтому синглам [1] присваивается 1 и т. Д.

Answer 2

Поскольку массивы начинаются с 0, размер вашего массива будет на единицу больше, чем число уникальных чисел, поэтому ваш последний цикл проходит один слишком много раз. Другими словами, «l» (буква l - попробуйте использовать другое имя переменной) получит значение 11, если у вас есть 10 уникальных чисел, а трекер имеет только пункты 0-10, таким образом, исключение вне границ. Попробуйте изменить объявление на int arraysize = 0;

Answer 3

Отредактируйте как 20, потому что я действительно должен спать.Понимая, что я, вероятно, просто сделал вашу домашнюю работу для вас, поэтому я удалил код.

arraySize должен начинаться с 0, потому что вы начинаете без цифр и начинаете прибавлять к этому размеру, когда находите дубликаты.Предполагая, что только один номер повторяется десять раз, вы бы создали массив размером 2 для хранения 1 номера.int arraysize = 0;

Ваш первый цикл for должен проходить через numbers, поэтому имеет смысл использовать длину чисел в ограничении цикла.for( int i = 0; i < numbers.length; i ++)

Для второго цикла for: вам нужно пройти по всему массиву tracker, поэтому можно использовать длину для этого (tracker.length).Меньше магических чисел - это всегда хорошо.Вам также нужны другие переменные, чтобы отслеживать ваше место в массиве singles.Если бы числа были массивом из 10 9, то только трекер [9] был бы верным, но это должно быть помещено в синглы [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];

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

    return singles;
}

Answer 4

Диапазон допустимых индексов в массиве в Java равен [0, SIZE), т.е.от 0 до arraysize-1.

Причина, по которой вы получаете исключение, заключается в том, что в цикле вы выполняете итерацию от 0 до arraysize включительно , слишком далеко на 1 индекс:

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

Поэтому, когда вы получите if(tracker[l] == true) на последней итерации, l будет равно arraysize и tracker[l] будет вне границ массива.Вы можете легко исправить это, изменив <= на < в вашем for состоянии цикла.

Причина того, что проблема исчезает, когда размер вашего массива изменяется с 10 на 11, связана с увеличением arraysize до 10 в цикле for над тем, что вызывает проблемы.На этот раз singles[10] является допустимым элементом в массиве, поскольку диапазон индексов в вашем массиве теперь равен [0, 11).

EDIT: На самом деле arraysize потенциально может бытьувеличенный до 11, я думал, что он был инициализирован до 0, в этом случае он получит только 10. В любом случае вышеприведенное все еще действует;последний индекс, к которому вы пытаетесь получить доступ в вашем массиве, должен быть на 1 меньше длины вашего массива, чтобы избежать получаемого исключения, поскольку массивы начинаются с нуля.Так что да, короче говоря, <= должно быть <.

Answer 5

Я чувствую, что вы делаете слишком много обработки для получения дубликата, если у вас нет ограничения на не использование коллекций, вы можете попробовать это

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[]{});
     }
}

Чтобы ответить на ваш вопрос, ваш последний цикл будет на один индекс больше, чем размер.