线程中的java编程异常；“主要”；这个错误是什么？

我编写这个程序是为了找到项目，然后删除所有小于项目的元素。没有编译错误，但是当我运行程序时，会出现以下消息

Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 5, Size: 5
    at java.util.ArrayList.rangeCheck(ArrayList.java:653)
    at java.util.ArrayList.remove(ArrayList.java:492)
    at bb.deleteValues(bb.java:15)
    at bb.main(bb.java:33)

Process completed. "

代码：

import java.util.ArrayList；
导入java.util.Scanner；
公共类bb{
公共静态布尔删除值（ArrayList，int项）
{int p=list.indexOf（项目）；
如果（！list.contains（项））
返回false；
其他的
for（int i=p；ilist.get（i+1））
删除（p）；
列表。删除（i+1）；
}
返回true；
}
公共静态void main（字符串[]args）{
ArrayList a=新的ArrayList（8）；
a、 增加（3）；
a、 增加（10）；
a、 增加（4）；
a、 增加（5）；
a、 增加（3）；
a、 增加（2）；
a、 增加（8）；
a、 增加（6）；
a、 增加（4）；
如果（删除值（a，4））
for（int x:a）
系统输出打印（x+“”）；
}
}

列表。删除（i+1）将超过
列表的大小。例如，当您传递第4个元素时，它将在
5th
位置搜索该元素
deleteValues
方法循环
i
从
p
到
list.size（）-1
，但循环体包含
list.get（i+1）
和
list.remove（i+1）
，因此当
i==list.size（）-1
时，
list.get（i+1）
和
list.remove（i+1）
将尝试从列表中不存在的索引中访问项目，这是异常的原因

删除比传递的项小的元素需要迭代列表中的所有元素，并将每个元素与传递的
项进行比较。请注意，当您从列表中删除第i个元素时，（i+1）个元素将成为新的第i个元素。这就是为什么只有在不从列表中删除元素时，我才应该递增

public static boolean deleteValues(ArrayList<Integer> list, int item)
{
    int p = list.indexOf(item);
    if(p<0)
        return false;
    for(int i=0; i<list.size();) {
        if (list.get(i) < item) {
            list.remove(i);
        } else {
            i++;
        }
    }
    return true;   
}

公共静态布尔删除值（ArrayList列表，int项）
{
INTP=列表索引（项目）；
如果（p问题在于
deleteValues
函数，当
i
小于
ArrayList
的大小时循环，但当调用
get
函数时添加1，这会导致
IndexOutOfBoundsException
，因为它可以使
i
等于ArrayList的大小，即无效。请更改for循环，并删除具有
i+1
的情况，如下所示：

for(int i=p; i<list.size();i++ )
{
    int n=list.get(i);

    if (n>list.get(i))
        list.remove(p);

    list.remove(i);

}

for（int i=p；ilist.get（i））
删除（p）；
列表。删除（i）；
}

此外，如果您的函数要删除某个值的所有副本，则代码可以非常简单、清晰：

public static boolean deleteValues(ArrayList<Integer> list, int item)
{
    if (list.contains(item))
    {
        for (int i = 0; i < list.size(); i++)
            if (list.get(i) == item)
                list.remove(i);
        return true;
    }
    return false;
}

公共静态布尔删除值（ArrayList列表，int项）
{
if（列表包含（项目））
{
对于（int i=0；i
导入java.util.ArrayList；
导入java.util.Scanner；
公共类{
公共静态布尔删除值（ArrayList列表）
{
for（int i=0；ilist.get（i+1））
//列表。删除（i）；
列表。删除（i+1）；
}
返回true；
}
公共静态void main（字符串[]args）{
ArrayList a=新的ArrayList（8）；
a、 增加（3）；
a、 增加（10）；
a、 增加（4）；
a、 增加（5）；
a、 增加（3）；
a、 增加（2）；
a、 增加（8）；
a、 增加（6）；
//a.加入（4）；
如果（删除值（a））
for（int x:a）
系统输出打印（x+“”）；
}
}

您正在使用指定的itz大小向arraylist添加一个额外的对象，并且在deleteValues方法中错误地使用了索引值，所以请使用这两个代码进行plz检查

import java.util.ArrayList;
import java.util.Scanner;


public class Ex {
public static   boolean deleteValues(ArrayList<Integer> list, int item)
    { int p =list.indexOf(item);
        if(!list.contains(item))
            return false;
            else 
                for(int i=0; i<list.size();i++ )
                {int n=list.get(i);
                if (n>list.get(i+1))
                list.remove(p);
                //list.remove(i+1);

                }
                return true; 
    }

    public static void main(String[] args) {
        ArrayList<Integer> a= new ArrayList<Integer>(8);
        a.add(3);
        a.add(10);
            a.add(4);
            a.add(5);
            a.add(3);
            a.add(2);
            a.add(8);
            //a.add(6);
            a.add(4);
        if(deleteValues(a,4))
            for(int x : a)
                System.out.print(x+ " ");
    }
}

import java.util.ArrayList；
导入java.util.Scanner；
公共类{
公共静态布尔删除值（ArrayList，int项）
{int p=list.indexOf（项目）；
如果（！list.contains（项））
返回false；
其他的
for（int i=0；ilist.get（i+1））
删除（p）；
//列表。删除（i+1）；
}
返回true；
}
公共静态void main（字符串[]args）{
ArrayList a=新的ArrayList（8）；
a、 增加（3）；
a、 增加（10）；
a、 增加（4）；
a、 增加（5）；
a、 增加（3）；
a、 增加（2）；
a、 增加（8）；
//a、 增加（6）；
a、 增加（4）；
如果（删除值（a，4））
for（int x:a）
系统输出打印（x+“”）；
}
}
8的初始容量无关紧要，因为ArrayList的大小会在需要时自动增加。我同意，我不知道在发布该评论时我在哪里丢失了！+1。
import java.util.ArrayList;
import java.util.Scanner;

    public class Ex {
    public static   boolean deleteValues(ArrayList<Integer> list)
        {

                    for(int i=0; i<list.size();i++ )
                    {int n=list.get(i);
                    if (n>list.get(i+1))
                  //  list.remove(i);
                    list.remove(i+1);

                    }
                    return true; 

        }

        public static void main(String[] args) {
            ArrayList<Integer> a= new ArrayList<Integer>(8);
            a.add(3);
            a.add(10);
               a.add(4);
                a.add(5);
               a.add(3);
                a.add(2);
              a.add(8);
               a.add(6);
              // a.add(4);
            if(deleteValues(a))
                for(int x : a)
                    System.out.print(x+ " ");
        }
    }

import java.util.ArrayList;
import java.util.Scanner;


public class Ex {
public static   boolean deleteValues(ArrayList<Integer> list, int item)
    { int p =list.indexOf(item);
        if(!list.contains(item))
            return false;
            else 
                for(int i=0; i<list.size();i++ )
                {int n=list.get(i);
                if (n>list.get(i+1))
                list.remove(p);
                //list.remove(i+1);

                }
                return true; 
    }

    public static void main(String[] args) {
        ArrayList<Integer> a= new ArrayList<Integer>(8);
        a.add(3);
        a.add(10);
            a.add(4);
            a.add(5);
            a.add(3);
            a.add(2);
            a.add(8);
            //a.add(6);
            a.add(4);
        if(deleteValues(a,4))
            for(int x : a)
                System.out.print(x+ " ");
    }
}