Java ArrayIndexOutOfBound异常

我正在尝试将google任务与我的应用程序同步。为此，我创建了一个类，在这个类中，我创建了获取任务列表和创建列表等所需的所有方法

现在我想测试这些方法是否有效。为此，我创建了一个类，该类扩展了一个

AsyncTask

我必须在这个任务中传递一些参数，就像在方法中传递参数一样。类似于

getTaskList（striglistid）

。要从任何列表中获取任务，我需要提供列表的id

现在，当我尝试在AsyncTask中传递参数时。打电话进来的时候

result = gTaskSyncer.getTaskList(params[0].toString());

它在这里抛出一个

ArrayIndexOutOfBoundException

测试同步任务

 public class TestAsyncTask extends AsyncTask<Object,Void,List<Task>>{

    private com.google.api.services.tasks.Tasks mService = null;
    private Exception mLastError = null;
    private MainActivity activity;
    private com.google.api.services.tasks.Tasks client = null;

    public TestAsyncTask(GoogleAccountCredential credential, MainActivity activity) {
        HttpTransport transport = AndroidHttp.newCompatibleTransport();
        JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();
        mService = new com.google.api.services.tasks.Tasks.Builder(
                transport, jsonFactory, credential)
                .setApplicationName("Google Tasks API Android Quickstart")
                .build();
        this.activity = activity;
    }

    protected List<Task> doInBackground(Object... params) {



        GTaskSyncer gTaskSyncer = new GTaskSyncer(activity);

        List<Task> result = new ArrayList<>();

        try {

            result = gTaskSyncer.getTaskList(params[0].toString());

        } catch (IOException e) {

            Handler handler = new Handler(Looper.getMainLooper());
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(activity, "No tasks.", Toast.LENGTH_SHORT).show();
                }
            });

        }
        return result;
    }


    @Override
    protected void onPostExecute(List<Task> output) {
        activity.mProgress.hide();
        if (output == null || output.size() == 0) {
            activity.mOutputText.setText("No results returned.");
        } else {
            activity.mOutputText.setText(TextUtils.join("\n", output));
        }
    }
}

公共类TestAsyncTask扩展了AsyncTask{
private com.google.api.services.tasks.tasks mService=null；
私有异常mLastError=null；
私人活动；
private com.google.api.services.tasks.tasks客户端=null；
公共TestAsyncTask（GoogleAccountCredential凭证，Main活动）{
HttpTransport-transport=AndroidHttp.newCompatibleTransport（）；
JsonFactory JsonFactory=JacksonFactory.getDefaultInstance（）；
mService=new com.google.api.services.tasks.tasks.Builder(
运输、jsonFactory、凭证）
.setApplicationName（“谷歌任务API Android快速启动”）
.build（）；
这个。活动=活动；
}
受保护列表doInBackground（对象…参数）{
GTaskSyncer GTaskSyncer=新的GTaskSyncer（活动）；
列表结果=新建ArrayList（）；
试一试{
结果=gTaskSyncer.getTaskList（参数[0].toString（））；
}捕获（IOE异常）{
Handler Handler=新处理程序（Looper.getMainLooper（））；
handler.post（新的Runnable（）{
@凌驾
公开募捐{
Toast.makeText（活动，“无任务”，Toast.LENGTH_SHORT）.show（）；
}
});
}
返回结果；
}
@凌驾
受保护的void onPostExecute（列表输出）{
activity.mProgress.hide（）；
if（output==null | | output.size（）==0）{
activity.mouttext.setText（“未返回结果”）；
}否则{
activity.mouttext.setText（TextUtils.join（“\n”，output））；
}
}
}

GTaskSyncer

 public class GTaskSyncer
{

    final MainActivity activity;
    final com.google.api.services.tasks.Tasks mService;
    private Exception mLastError = null;



    GTaskSyncer(MainActivity activity) {
        this.activity = activity;
        mService = activity.mService;
    }

    public List<TaskList> getAllTaskList() throws IOException
    {
        List<TaskList> result = new ArrayList<TaskList>();

        TaskLists taskLists = mService.tasklists().list().execute();

        for (TaskList taskList : taskLists.getItems()) {

                result.add(taskList);
        }

        return result;

    }


    public TaskList createList() throws IOException
    {

        TaskList taskList = new TaskList();

        taskList =  activity.mService.tasklists().insert(taskList).execute();

        return taskList;
    }

    public Task createTask(String listId) throws IOException
    {

        Task task = new Task();

        task =   activity.mService.tasks().insert(listId, task).execute();

        return  task;
    }

    public Task getTask(String listId,String taskId) throws IOException
    {

        Task task =   activity.mService.tasks().get(listId, taskId).execute();

        return task;
    }

    public List<Task> getTaskList(String listId) throws IOException {


        List<Task> result = new ArrayList<Task>();

        List<Task> tasks = mService.tasks().list(listId).execute().getItems();

        if (tasks != null) {

            for (Task task : tasks) {

                result.add(task);
            }
        } else {

            Toast.makeText(activity, "No tasks.", Toast.LENGTH_SHORT).show();
        }

        return result;

    }

}

公共类GTaskSyncer
{
最后的主要活动；
最终com.google.api.services.tasks.tasks mService；
私有异常mLastError=null；
GTaskSyncer（主要活动）{
这个。活动=活动；
mService=activity.mService；
}
public List getAllTaskList（）引发IOException
{
列表结果=新建ArrayList（）；
TaskLists TaskLists=mService.TaskLists（）.list（）.execute（）；
对于（任务列表任务列表：taskLists.getItems（））{
结果.添加（任务列表）；
}
返回结果；
}
public TaskList createList（）引发IOException
{
TaskList TaskList=新任务列表（）；
taskList=activity.mService.tasklists（）.insert（taskList.execute（）；
返回任务列表；
}
公共任务createTask（字符串listId）引发IOException
{
任务=新任务（）；
task=activity.mService.tasks（）.insert（listId，task.execute（）；
返回任务；
}
公共任务getTask（String listId，String taskId）引发IOException
{
Task Task=activity.mService.tasks（）.get（listId，taskId.execute（）；
返回任务；
}
公共列表getTaskList（字符串listId）引发IOException{
列表结果=新建ArrayList（）；
List tasks=mService.tasks（）.List（listId.execute（）.getItems（）；
如果（任务！=null）{
for（任务：任务）{
结果。添加（任务）；
}
}否则{
Toast.makeText（活动，“无任务”，Toast.LENGTH_SHORT）.show（）；
}
返回结果；
}
}

我怎样才能测试这个呢？如何在调用方法时为其提供listId？

当您对

AsyncTask

调用execute（）而没有任何参数时，缺少的参数to execute（）将成为AsyncTask的

doInBackground（）方法中的空（varargs）数组

如果希望能够在
doInBackground（）
中使用参数，则必须通过
execute（）
传递一些参数。如果要确保索引不超过execute中传递的项列表，请迭代vararg arg数组，而不是直接索引到它中，而不检查其长度。
在没有任何参数的情况下对
AsyncTask
调用execute（）时，缺少的要执行的参数（）将变为空（varargs）AsyncTask的
doInBackground（）
方法中的数组

如果希望能够在
doInBackground（）
中使用参数，则必须通过
execute（）
传递一些参数。如果要确保索引不超过在execute中传递的项列表，请迭代vararg arg数组，而不是直接在其中索引，而不检查其长度。
首先检查调用Asynctask类时是否传递了值
ArrayIndexOutOfBoundException
发生，因为您没有传递但希望访问该异常

因此，在访问该参数之前，首先检查大小是否大于1
 首先检查调用Asynctask类时是否传递了一个值
ArrayIndexOutOfBoundException
发生，因为您没有传递但希望访问该异常

因此，在访问该参数之前，首先检查大小是否大于1

数组越界异常是由于以下原因引发的Java异常：
程序试图在某个位置访问某个元素的事实
这超出了数组限制，因此出现了单词“Out-bounds”
 result = gTaskSyncer.getTaskList(params[0].toString()); // In here Problem