Java 如何防止数组越界

我正试图写一个程序，最大限度地提高买卖股票的利润。我试图检查下一个索引中的值是否大于当前索引位置中的值，但是我的循环导致数组超出范围。如果（（共享[i]）<（共享[i+1]））发生，则其发生在这一行什么是防止这种情况的最佳方法

编辑：我得到了一份股票价格表。每天我要么买，要么卖，要么买，要么卖。我的方法是找出股票价格的平均值。如果价格低于平均水平，则“买入”，如果未来几天价格仍然较低，则持有“买入”。反之亦然。如果数量大于平均值，则卖出；如果之后的一天大于平均值，则继续卖出。理想情况下，在股票[9]上，我将以4欧元买入，在股票[11]上，我将以19欧元卖出。然而，当它试图检查股票之后的下一个指数时，在检查是否出售股票时，结果超出了范围[11]

public static void main(String[] args)
{
    int [] shares ={3,7,4,2,10,11,8,5,4,8,19};
    int average= 0;
    int  buyOrSell = 0;
    int profit = 0;

    for(int i = 0; i< shares.length; i++)
    {
        average += shares[i];
    }

    average  /= shares.length;
    System.out.println(average);

    for(int i = 0; i < shares.length; i++)
    {
            if((shares[i] <= average) && (buyOrSell == 0))
            {
                if((shares[i]) < (shares[i+1]))
                {
                System.out.println("Buy" + shares[i]);
                buyOrSell++;
                System.out.println("Profit: " + (profit -= shares[i]));
                }
                else System.out.println("Hold Buy" + shares[i]);

            }

            if(shares[i] >= average && buyOrSell == 1)
            {
                if((shares[i]) > (shares[i+1]))
                {
                System.out.println("Sell" + shares[i]);
                buyOrSell--;
                System.out.println("Profit: " + (profit += shares[i]));
                }

                else System.out.println("Hold Sell" + shares[i]);
            }


    }

    System.out.println("Profit: "+ profit);

}

---

当到达数组末尾时，

共享[i+1]

将抛出异常。您应该将循环中的限制减少一：

for（int i=0；i

当您到达数组末尾时，

共享[i+1]

将引发异常。您应该将循环中的限制减少一：

for（inti=0；i

您的第二个

for

循环查看索引

[i+1]

，当

i==length-1时，它超出了循环最后一次迭代的范围。要解决此问题，循环应迭代到
length-1
，如下所示：

for(int i = 0; i < shares.length - 1; i++) 
{...}

for（int i=0；i

这样，您就可以始终访问
[i+1]
您的第二个
for
循环查看索引
[i+1]
，当
i==length-1
时，该索引超出了循环最后一次迭代的范围。要解决此问题，循环应迭代到
length-1
，如下所示：

for(int i = 0; i < shares.length - 1; i++) 
{...}

for（int i=0；i

这样，您就可以始终从0开始访问
[i+1]
数组，因此
共享[i+1]
在
i==shares.length

根据你的逻辑，你可以做很多事情，比如

改变

if((shares[i]) < (shares[i+1]))

if（（股份[i]）<（股份[i+1]））

到

if（（i+1

或

if((shares[i-1]) < (shares[i]))

if（（股份[i-1]）<（股份[i]））

或者您可以将循环中的条件更改为

for(int i = 0; i < shares.length - 1; i++)

for（int i=0；i

这完全取决于逻辑的工作方式。
数组从0开始，因此
共享[i+1]
在
i==shares.length

根据你的逻辑，你可以做很多事情，比如

改变

if((shares[i]) < (shares[i+1]))

if（（股份[i]）<（股份[i+1]））

到

if（（i+1

或

if((shares[i-1]) < (shares[i]))

if（（股份[i-1]）<（股份[i]））

或者您可以将循环中的条件更改为

for(int i = 0; i < shares.length - 1; i++)

for（int i=0；i

这完全取决于逻辑的工作方式
循环从
i=0
运行到
i=shares.length-1
。这意味着
i
获取的最大值为
shares.length-1
。因此，执行
共享[i+1]
相当于执行
共享[shares.length]
。这就是为什么会出现
ArrayIndexOutOfBoundsException
，因为数组索引从
0
开始，而不是
1
。您可以通过将循环条件更改为
i
来避免它。循环从
i=0
运行到
i=shares.length-1
。这意味着
i
获取的最大值为
shares.length-1
。因此，执行
共享[i+1]
相当于执行
共享[shares.length]
。这就是为什么会出现
ArrayIndexOutOfBoundsException
，因为数组索引从
0
开始，而不是
1
。您可以通过将循环条件更改为
i
来避免这种情况。除了像大家正确建议的那样实施范围限制之外，您还必须考虑数组最后一项的边界情况。如果迭代到
length-2
，那么位于
length-1
位置的元素会发生什么情况

你可以采取两种方法。一种是迭代到
length-2
，然后处理循环外的最后一个元素

for(int i = 0; i < shares.length - 1; i++)
//Your code
int finalShare = shares[length - 1];
//Manage the final item here

for（int i=0；i

另一种方法是保持迭代的原样，同时添加一个特定的检查，确定迭代是否已经结束，处理最终元素，然后中断迭代

for(int i = 0; i < shares.length; i++) {
    if(i == length - 1) {
        //handle final element here...
        break;
    }
}

for（int i=0；i
除了像大家正确建议的那样实施范围限制外，还必须考虑数组最后一项的边界情况。如果迭代到
length-2
，那么位于
length-1
位置的元素会发生什么情况

你可以采取两种方法。一种是迭代到
length-2
，然后处理循环外的最后一个元素

for(int i = 0; i < shares.length - 1; i++)
//Your code
int finalShare = shares[length - 1];
//Manage the final item here

for（int i=0；i

另一种方法是保持迭代的原样，同时添加一个特定的检查，确定迭代是否已经结束，处理最终元素，然后中断迭代

for(int i = 0; i < shares.length; i++) {
    if(i == length - 1) {
        //handle final element here...
        break;
    }
}

for（int i=0；i