Java 数组越界

eclipes说，我不明白为什么数组超出了它的边界，问题出在第15行

int d=数组[1]-数组[0]

import java.util.*；
公共类数组1{
静态扫描仪阅读器=新扫描仪（System.in）；
公共静态void main（字符串[]args）{
int N=reader.nextInt（）；
int[]数组=新的int[N]；
布尔右=真；
对于（int i=0；i，因为您从读取器读取数组的边界，它可能是0或1。为了确保它足够大，您可以尝试以下操作：

   if(N > 1) {
        int d = array[1] - array[0];
        if ((array[N]-1)%d !=0)
        {
            right = false;
        }
   }

如果您的应用程序必须大于1才能正常工作，您可以在开始时强制执行此约束：

int N = reader.nextInt();
if(N <= 1) {
   System.out.println("N must be bigger than 1");
   System.exit(1); // exit with error code
}

int N=reader.nextInt（）；
如果（N因为您从读卡器读取了数组的边界，它可能是0或1。为了确保它足够大，您可以尝试以下方法：

   if(N > 1) {
        int d = array[1] - array[0];
        if ((array[N]-1)%d !=0)
        {
            right = false;
        }
   }

如果您的应用程序必须大于1才能正常工作，您可以在开始时强制执行此约束：

int N = reader.nextInt();
if(N <= 1) {
   System.out.println("N must be bigger than 1");
   System.exit(1); // exit with error code
}

int N=reader.nextInt（）；
如果（N因为您从读卡器读取了数组的边界，它可能是0或1。为了确保它足够大，您可以尝试以下方法：

   if(N > 1) {
        int d = array[1] - array[0];
        if ((array[N]-1)%d !=0)
        {
            right = false;
        }
   }

如果您的应用程序必须大于1才能正常工作，您可以在开始时强制执行此约束：

int N = reader.nextInt();
if(N <= 1) {
   System.out.println("N must be bigger than 1");
   System.exit(1); // exit with error code
}

int N=reader.nextInt（）；
如果（N因为您从读卡器读取了数组的边界，它可能是0或1。为了确保它足够大，您可以尝试以下方法：

   if(N > 1) {
        int d = array[1] - array[0];
        if ((array[N]-1)%d !=0)
        {
            right = false;
        }
   }

如果您的应用程序必须大于1才能正常工作，您可以在开始时强制执行此约束：

int N = reader.nextInt();
if(N <= 1) {
   System.out.println("N must be bigger than 1");
   System.exit(1); // exit with error code
}

int N=reader.nextInt（）；
如果（N你可能想要这样的东西：

public class Main {

    static Scanner reader = new Scanner(System.in);

    public static void main(String[] args) {
        int N = reader.nextInt();
        int[] array = new int[N];
        boolean right = true;
        for (int i=0; i<array.length; i++)
        {
            System.out.println("Enter number for array");
            array[i] = reader.nextInt();
        }
        int d = array[1] - array[0];
        if ((array[N-1])%d !=0)
        {
            right = false;
        }
    }

}

您正在执行：
if（（数组[N]-1）%d！=0）

顺便说一句，信任扫描总是一个问题，您需要几次验证。
您可能需要这样的东西：

public class Main {

    static Scanner reader = new Scanner(System.in);

    public static void main(String[] args) {
        int N = reader.nextInt();
        int[] array = new int[N];
        boolean right = true;
        for (int i=0; i<array.length; i++)
        {
            System.out.println("Enter number for array");
            array[i] = reader.nextInt();
        }
        int d = array[1] - array[0];
        if ((array[N-1])%d !=0)
        {
            right = false;
        }
    }

}

您正在执行：
if（（数组[N]-1）%d！=0）

顺便说一句，信任扫描总是一个问题，您需要几次验证。
您可能需要这样的东西：

public class Main {

    static Scanner reader = new Scanner(System.in);

    public static void main(String[] args) {
        int N = reader.nextInt();
        int[] array = new int[N];
        boolean right = true;
        for (int i=0; i<array.length; i++)
        {
            System.out.println("Enter number for array");
            array[i] = reader.nextInt();
        }
        int d = array[1] - array[0];
        if ((array[N-1])%d !=0)
        {
            right = false;
        }
    }

}

您正在执行：
if（（数组[N]-1）%d！=0）

顺便说一句，信任扫描总是一个问题，您需要几次验证。
您可能需要这样的东西：

public class Main {

    static Scanner reader = new Scanner(System.in);

    public static void main(String[] args) {
        int N = reader.nextInt();
        int[] array = new int[N];
        boolean right = true;
        for (int i=0; i<array.length; i++)
        {
            System.out.println("Enter number for array");
            array[i] = reader.nextInt();
        }
        int d = array[1] - array[0];
        if ((array[N-1])%d !=0)
        {
            right = false;
        }
    }

}

您正在执行：
if（（数组[N]-1）%d！=0）

顺便说一句，信任扫描总是一个问题，您需要多次验证。
在读取
数组
项之前，尝试验证用户输入，因为用户可能会输入1，例如，当提示他输入数组大小时，因此数组中只有一个项，并访问第二个索引中的项（1，因为它基于0）将导致出现
BoundsException数组
：

import java.util.*；
公共类数组1{
静态扫描仪阅读器=新扫描仪（System.in）；
公共静态void main（字符串[]args）{
int N=reader.nextInt（）；
而（N<2）{
System.out.println（“输入数组的有效大小”）；
N=reader.nextInt（）；
}
int[]数组=新的int[N]；
布尔右=真；
对于（int i=0；i在读取
数组
项之前，请尝试验证用户输入，因为用户可能会输入1，例如，当提示他输入数组大小时，因此数组中只有一个项，并访问第二个索引中的项（1，因为它基于0）将导致BoundsException的
排列

import java.util.*；
公共类数组1{
静态扫描仪阅读器=新扫描仪（System.in）；
公共静态void main（字符串[]args）{
int N=reader.nextInt（）；
而（N<2）{
System.out.println（“输入数组的有效大小”）；
N=reader.nextInt（）；
}
int[]数组=新的int[N]；
布尔右=真；
对于（int i=0；i在读取
数组
项之前，请尝试验证用户输入，因为用户可能会输入1，例如，当提示他输入数组大小时，因此数组中只有一个项，并访问第二个索引中的项（1，因为它基于0）将导致BoundsException的
排列

import java.util.*；
公共类数组1{
静态扫描仪阅读器=新扫描仪（System.in）；
公共静态void main（字符串[]args）{
int N=reader.nextInt（）；
而（N<2）{
System.out.println（“输入数组的有效大小”）；
N=reader.nextInt（）；
}
int[]数组=新的int[N]；
布尔右=真；
对于（int i=0；i在读取
数组
项之前，请尝试验证用户输入，因为用户可能会输入1，例如，当提示他输入数组大小时，因此数组中只有一个项，并访问第二个索引中的项（1，因为它基于0）将导致BoundsException的
排列

import java.util.*；
公共类数组1{
静态扫描仪阅读器=新扫描仪（System.in）；
公共静态void main（字符串[]args）{
int N=reader.nextInt（）；
而（N<2）{
System.out.println（“输入数组的有效大小”）；
N=reader.nextInt（）；
}
int[]数组=新的int[N]；
布尔右=真；
for（int i=0；iNever trust user Input！从不信任用户输入！从不信任用户输入！从不信任用户输入！