Java-Programm zur Überprüfung der Array-Grenzen bei der Eingabe von Array-Elementen

Ein Array ist eine lineare Datenstruktur, die zum Speichern von Gruppen von Elementen mit ähnlichen Datentypen verwendet wird. Es speichert Daten sequentiell. Sobald wir ein Array erstellt haben, können wir seine Größe nicht mehr ändern, d. h. es hat eine feste Länge.

Dieser Artikel hilft Ihnen, die Grundkonzepte von Arrays und der Array-Bindung zu verstehen. Außerdem besprechen wir das Java-Programm zum Überprüfen der Grenzen eines Arrays beim Eingeben von Elementen in das Array.

Arrays und Array-Bindungen

Wir können über den Index auf Array-Elemente zugreifen. Angenommen, wir haben ein Array der Länge N, dann

Im obigen Bild können wir sehen, dass das Array 7 Elemente enthält, die Indexwerte jedoch zwischen 0 und 6 liegen, also zwischen 0 und 7 - 1.

Der Bereich eines Arrays wird als seine Grenzen bezeichnet. Der Bereich des obigen Arrays liegt zwischen 0 und 6. Daher können wir auch sagen, dass 0 bis 6 die Grenzen des angegebenen Arrays sind. Wenn wir versuchen, auf einen Indexwert außerhalb des zulässigen Bereichs oder auf einen negativen Index zuzugreifen, erhalten wir eine ArrayIndexOutOfBoundsException. Dies ist ein Fehler, der zur Laufzeit auftritt.

Syntax zum Deklarieren von Arrays

Data_Type[] nameOfarray; 
// declaration
Or,
Data_Type nameOfarray[]; 
// declaration
Or,
// declaration with size
Data_Type nameOfarray[] = new Data_Type[sizeofarray]; 
// declaration and initialization
Data_Type nameOfarray[] = {values separated with comma};

Wir können jede der oben genannten Syntaxen in unseren Programmen verwenden.

Überprüfen Sie die Array-Grenzen, wenn Sie Elemente in das Array eingeben

Beispiel 1

Wenn wir auf Elemente im Bereich des Arrays zugreifen, erhalten wir keine Fehlermeldung. Das Programm wird erfolgreich ausgeführt.

public class Main {
   public static void main(String []args) {
      // declaration and initialization of array ‘item[]’ with size 5
      String[] item = new String[5]; 
      // 0 to 4 is the indices 
      item[0] = "Rice";
      item[1] = "Milk";
      item[2] = "Bread";
      item[3] = "Butter";
      item[4] = "Peanut";
      System.out.print(" Elements of the array item: " );
      // loop will iterate till 4 and will print the elements of ‘item[]’
      for(int i = 0; i <= 4; i++) {
         System.out.print(item[i] + " ");
      }
   }
}

Ausgabe

Elements of the array item: Rice Milk Bread Butter Peanut

Beispiel 2

Versuchen wir, Werte außerhalb des Bereichs des angegebenen Arrays zu drucken.

public class Tutorialspoint {
      public static void main(String []args) {
      String[] item = new String[5];
      item[0] = "Rice";
      item[1] = "Milk";
      item[2] = "Bread";
      item[3] = "Butter";
      item[4] = "Peanut";
      // trying to run the for loop till index 5
      for(int i = 0; i <= 5; i++) {
         System.out.println(item[i]);
      }
   }
}

Ausgabe

Rice
Milk
Bread
Butter
Peanut
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
at Tutorialspoint.main(Tutorialspoint.java:11)

Wie wir bereits besprochen haben, erhalten wir eine ArrayIndexOutOfBoundsException, wenn wir versuchen, auf ein Array mit einem Indexwert außerhalb seines Bereichs oder einem negativen Index zuzugreifen.

Im obigen Programm haben wir versucht, eine for-Schleife bis zum Index 5 des Arrays „item[]“ auszuführen, aber ihr Bereich liegt nur zwischen 0 und 4. Nach dem Drucken der Elemente bis 4 erhalten wir den Fehler.

Beispiel 3

In diesem Beispiel versuchen wir, ArrayIndexOutOfBoundsException mithilfe von Try- und Catch-Blöcken zu behandeln. Wir überprüfen die Array-Grenzen, wenn der Benutzer Elemente in das Array eingibt.

import java.util.*;
public class Tutorialspoint {
   public static void main(String []args) throws ArrayIndexOutOfBoundsException {
      // Here ‘sc’ is the object of scanner class
      Scanner sc = new Scanner(System.in); 
      System.out.print("Enter number of items: ");
      int n = sc.nextInt();
      // declaration and initialization of array ‘item[]’
      String[] item = new String[n]; 
      // try block to test the error
      try {
         // to take input from user
         for(int i =0; i<= item.length; i++) {
            item[i] = sc.nextLine();
         }
      }
      // We will handle the exception in catch block
      catch (ArrayIndexOutOfBoundsException exp) {
         // Printing this message to let user know that array bound exceeded
         System.out.println(
         " Array Bounds Exceeded  \n Can't take more inputs ");
      }
   }
}

Ausgabe

Enter number of items: 3

Fazit

In diesem Artikel haben wir etwas über Arrays und Array-Bindung gelernt. Wir haben besprochen, warum wir eine Fehlermeldung erhalten, wenn wir versuchen, auf ein Array-Element außerhalb seines Gültigkeitsbereichs zuzugreifen, und wie wir mit dieser Fehlermeldung mithilfe von Try- und Catch-Blöcken umgehen.

Das obige ist der detaillierte Inhalt vonJava-Programm zur Überprüfung der Array-Grenzen bei der Eingabe von Array-Elementen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!