Почему массивы не принимают ввод, превышающий их длину?

Question

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

Спасибо!

Вот код. Когда я ввожу целое число больше 5, я получаю исключение за пределы. Если я ввожу целые числа менее 5, код работает отлично.

public class NumOfOccur 
{ 
    static Scanner input = new Scanner(System.in); 
    static int[] cards = new int[5]; 
    static int[] numOccurence = new int[5]; 
    public static void main(String[] args) 
    { 
     System.out.println("Enter five values: "); 

     for (int i = 0; i < 5; i++) 
     { 
      System.out.print("Card " + (i + 1) + " : "); 
      cards[i] = input.nextInt(); 
     } 

     containsPair(cards); 
    } 

    public static boolean containsPair(int hand[]) 
    { 

     for (int i = 0; i < hand.length; i++) 
      numOccurence[hand[i]]++; 

     for (int i = 1; i < numOccurence.length; i++) 
     { 
      if (numOccurence[i] > 0) 
       System.out.println("The number " + i + " occurs " + numOccurence[i] + " times."); 
     } 

     return false; 

    } 
} 

Answer 1

То, что вы предлагаете здесь, неверно. Массив целых чисел может содержать любое целое число. Когда вы храните целое число в массив (или какое-либо значение), вы должны убедиться, что индекс, в который вы его вставляете, является допустимым.

Например

//perfectly valid 
int[] foo = new int[1]; 
foo[0] = 500; 

Я подозреваю, что вы делаете что-то вроде этого.

//throws index out of bounds exception 
int[] foo = new int[1]; 
foo[500] = 500; 

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

Основываясь на вашем Теперь публикуемую код, ваша проблема здесь:

for (int i = 0; i < hand.length; i++) 
      numOccurence[hand[i]]++; 

Чтобы кратко объяснить, что происходит.

1) вы сначала инициализируете numOccurence длиной 5 целых чисел.
2) Вы вводите ввод пользователя в карты [], тогда вы передаете массив карт в функцию containsPair()
3) Если пользователь вводит число больше 5, скажем 7, операция hands[i] будет равна 7 . Это будет то же самое, что и numOccurence[7], который находится за пределами

Answer 2

Без какого-либо кода я предполагаю, что вы просто не понимаете, что делаете со своим массивом. Вам просто нужно убедиться, что вы обращаетесь к действительному индексу. Нет никаких ограничений на то, какое целое число можно хранить в массиве с целым числом.

// Make an array of length ten 
int[] myIntArray = new int[10]; 
System.out.println(myIntArray.length); 

// Set the first value in the array to 99: perfectly legal 
myIntArray[0] = 99; 
System.out.println(myIntArray[0]); 

// The following line throws ArrayIndexOutOfBoundsException 
myIntArray[99] = 100; // The last index in the array is only 9, not 99! 
System.out.println(myIntArray[99]); // This line would also crash, for the same reason 

Answer 3

Я уверен, что вопрос неверен. Вы говорите, что это невозможно.

int[] anArray = new int[10]; 
anArray[5] = 20; 

Это, очевидно, не так.

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

Если вы хотите, чтобы ваш массив больше или что-то в этом роде, вы должны рассмотреть возможность использования ArrayList или чего-то подобного. Отправьте свой код, чтобы мы могли вам помочь.

Answer 4

Увидев код, я думаю, что проблема с этим:

Во-первых, ваш numOccurence массив всегда имеет длину 5, но в строке

numOccurence[hand[i]]++; 

Вы получите OutOfBoundsException если hand[i] составляет 5 или больше (это означает, что вы вводили значение 5 или больше).

Чтобы исправить это, вы должны либо:

1. ограничения Помещенные на какую карту значения пользователь может ввести
2. сделать эту линию numOccurence[i]++, если вы имеете в виду, чтобы отслеживать количество раз каждой позиции карты был нарисован
3. Сделайте numOccurence более длинным массивом, чтобы он мог хранить количество раз, когда каждая возможная карта (например, от 1 до 13 для Ace to King).