Java 如何为此代码设置异步任务？

我的listblogs=parseJSONResponse（result）有问题，结果带红色下划线，如果我将鼠标悬停在上面，它会显示，我无法将parseJSONResponse JSONARRAY应用于JSONARRAY[]。有人知道这是为什么吗？这和params有关吗

class YourTask extends AsyncTask<JSONArray, String, ArrayList<Blogs> > {

    @Override
    protected ArrayList<Blogs> doInBackground(JSONArray... result) {
        listblogs.clear(); // here you clear the old data
        listblogs=parseJSONResponse(result);
        return listblogs;
    }

    @Override
    protected void onPostExecute(ArrayList<Blogs> blogs) {
        mAdapterDashBoard.setBloglist(listblogs);
    }
}



private void JsonRequestMethod() {
    final long start = SystemClock.elapsedRealtime();
            mVolleySingleton = VolleySingleton.getInstance();
            //intitalize Volley Singleton request key
            mRequestQueue = mVolleySingleton.getRequestQueue();
            //2 types of requests an Array request and an Object Request
            JsonArrayRequest request = new JsonArrayRequest(Request.Method.GET, URL_API, (String) null, new Response.Listener<JSONArray>() {
                @Override
                public void onResponse(JSONArray response) {
                    System.out.print(response);
                    listblogs = new YourTask().doInBackground();
                    listblogs.clear();
                             listblogs=parseJSONResponse(response);
                    try {
                        listblogs = new YourTask().execute().get();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (ExecutionException e) {
                        e.printStackTrace();
                    }

                    System.out.println(response);
                            Log.d("Testing", "Time elapsed: " + (SystemClock.elapsedRealtime() - start));
                    System.out.println("it worked!!!");
                }
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                }
            });
            mRequestQueue.add(request);
    }



private ArrayList<Blogs> parseJSONResponse(JSONArray response) {
    if (!response.equals("")) {
        try {
            StringBuilder data = new StringBuilder();
            for (int i = 0; i < response.length(); i++) {
                JSONObject currentQuestions = response.getJSONObject(i);
                String text = currentQuestions.getString("text");
                String points = currentQuestions.getString("points");
                String ID=currentQuestions.getString("id");
                String studentId = currentQuestions.getString("studentId");
                String DateCreated=currentQuestions.getString("created");
                long time=Long.parseLong(DateCreated.trim());
                data.append(text + "\n" + points + "\n");
                System.out.println(data);
                Blogs blogs = new Blogs();
                blogs.setId(ID);
                blogs.setMstudentId(studentId);
                blogs.setMtext(text);
                blogs.setPoints(points);
                //The dateCreated was off by 1 hour so 3600000 ms where added=1hour, (UPDATE)
                blogs.setDateCreated(getTimeAgo(time));
                System.out.println(time + "time");


                listblogs.add(blogs);


            }

        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    return listblogs;
}

class YourTask扩展了AsyncTask{
@凌驾
受保护的ArrayList doInBackground（JSONArray…结果）{
listblogs.clear（）；//在这里可以清除旧数据
listblogs=parseJSONResponse（结果）；
返回listblogs；
}
@凌驾
受保护的void onPostExecute（ArrayList博客）{
mAdapterDashBoard.setBloglist（listblogs）；
}
}
私有void JsonRequestMethod（）{
最终长启动=SystemClock.elapsedRealtime（）；
mVolleySingleton=VolleySingleton.getInstance（）；
//初始化截击单例请求键
mRequestQueue=mVolleySingleton.getRequestQueue（）；
//两种类型的请求—数组请求和对象请求
JsonArrayRequest=newJSONArrayRequest（request.Method.GET，URL_API，（String）null，new Response.Listener（）{
@凌驾
公共void onResponse（JSONArray响应）{
系统输出打印（响应）；
listblogs=newyourtask（）.doInBackground（）；
listblogs.clear（）；
listblogs=parseJSONResponse（response）；
试一试{
listblogs=newyourtask（）.execute（）.get（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}捕获（执行例外）{
e、 printStackTrace（）；
}
System.out.println（响应）；
Log.d（“测试”，“经过的时间：”+（SystemClock.elapsedRealtime（）-start））；
System.out.println（“成功了！！！”；
}
}，new Response.ErrorListener（）{
@凌驾
公共无效onErrorResponse（截击错误）{
}
});
mRequestQueue.add（请求）；
}
专用ArrayList parseJSONResponse（JSONArray响应）{
如果（！response.equals（“”）{
试一试{
StringBuilder数据=新的StringBuilder（）；
对于（int i=0；i

您可以在异步任务中运行以下任何代码：

public class YourTask extends AsyncTask<String, Void, ArrayList<Blogs> > {

    private static final String TAG = YourTask.class.getSimpleName();

    private JSONArray mResponse;
    private Activity mActivity;

    public YourTask(final Activity activity, final JSONArray response) {
        super();
        this.mActivity = activity;
        this.mResponse = response;
    }

    @Override
    protected ArrayList<Blogs>  doInBackground(String... params) {

        if (!mResponse.equals("")) {
               // Your Code
        }   
        return listblogs;

    }

    @Override
    protected void onPostExecute(final ArrayList<Blogs> blogs) {

            if (mActivity instanceOf YourActivity) {
                ((YourActivity) activity).finishTask(blogs);
            }
    }

    @Override
    protected void onCancelled() {}
}

public类YourTask扩展了AsyncTask{
private static final String TAG=YourTask.class.getSimpleName（）；
私人JSONArray mResponse；
私人活动能力；
公共任务（最终活动、最终JSONArray响应）{
超级（）；
这个。活动=活动；
this.mResponse=响应；
}
@凌驾
受保护的ArrayList doInBackground（字符串…参数）{
如果（！mResponse.equals（“”）{
//你的代码
}   
返回listblogs；
}
@凌驾
受保护的void onPostExecute（最终ArrayList日志）{
if（活动的MacActivity实例）{
（（YourActivity）活动）完成任务（blogs）；
}
}
@凌驾
受保护的void onCancelled（）{}
}

从活动中调用此任务，如：

AsyncTask<String, Void, JSONArray> task = new YourTask(this, response);
        task.executeContent();

AsyncTask task=newyourtask（这个，响应）；
task.executeContent（）；

---

基本上，只需将要解析的JSONArray发送到异步任务，并处理活动中den

finishTask

方法中的所有UI。这样做的好处是，您可以将任务提取到一个额外的文件中，而将活动留给您来处理控制视图的任务。

AsyncTask

public class MyAsyncTask extends AsyncTask<Void, Void, ArrayList> {
         JsonArray myJsonArray;
   @Override
    protected void onPreExecute() {
        super.onPreExecute();

            mVolleySingleton = VolleySingleton.getInstance();

            mRequestQueue = mVolleySingleton.getRequestQueue();

            listblogs.clear();

        }
        @Override
        protected ArrayList doInBackground(Void... params) {


            JsonArrayRequest request = new JsonArrayRequest(Request.Method.GET, URL_API, (String) null, new Response.Listener<JSONArray>() {
                @Override
                public void onResponse(JSONArray response) {

                    myJsonArray = response;

                }
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                }
            });
            mRequestQueue.add(request);
            return null;
        }

        @Override
        protected void onPostExecute(ArrayList arrayList) {
            super.onPostExecute(arrayList);

              ArrayList<Blogs> blogsArrayList = new ArrayList<>();
    try {
        StringBuilder data = new StringBuilder();
        for (int i = 0; i < myJsonArray.length(); i++) {
            JSONObject currentQuestions = myJsonArray.getJSONObject(i);
            String text = currentQuestions.getString("text");
            String points = currentQuestions.getString("points");
            String ID=currentQuestions.getString("id");
            String studentId = currentQuestions.getString("studentId");
            String DateCreated=currentQuestions.getString("created");
            long time=Long.parseLong(DateCreated.trim());
            data.append(text + "\n" + points + "\n");
            System.out.println(data);
            Blogs blogs = new Blogs();
            blogs.setId(ID);
            blogs.setMstudentId(studentId);
            blogs.setMtext(text);
            blogs.setPoints(points);
            //The dateCreated was off by 1 hour so 3600000 ms where added=1hour, (UPDATE)
            blogs.setDateCreated(getTimeAgo(time));
            System.out.println(time+"time");


            blogsArrayList.add(blogs);
            }
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return blogsArrayList;

    }

异步：

  listblogs = new MyAsyncTask().execute().get();

   ....
      } catch (JSONException e) {
            e.printStackTrace();
        }
        listblogs = blogsArrayList;
        return blogsArrayList;

        }
new MyAsyncTask().execute();

---

您好，您到底遇到了什么问题？您尝试了什么？为什么要在后台线程上解析它。是否真的有很多json，或者你只是简单地读到它应该在后台完成？换言之，这似乎是一个过早优化的案例。当我在SlidingTableOut中切换SlidingTab时，我经历了滞后，我查看了它并进行了堆转储，发现字符串占据了我heap的很大一部分，我也不断得到这些，我相信这是我在堆中的分配02-01 03:22:49.007 22066-22066/com.athena.athena D/dalvikvm:GC_FOR_ALLOC freed 189K，17%free 40212K/48140K，暂停18ms，总计18ms你的活动不应该使用弱引用吗？（

WeakReference

）