如何独立于android/java中属于同一组的嵌套JSON对象检索数据？（正文中更清晰/详细）

我有一个非常常见的场景，但我一直在试图找出如何在同一个json响应中从某些json对象检索数据，但返回的项目大小不同。 为了减少混淆，下面是我的json响应：

{
    "totalResults": 5,
    "meetings": [
        {
            "id": "754e6670-2376-4eb2-b5f6-ea63ca7c2669",
            "dateStart": "2019-11-28T15:25:36.000Z",
            "dateEnd": "2019-11-28T23:00:36.000Z",
            "visitors": [
                {
                    "visitId": "34608af6-bbe4-439c-b472-500790385f60",
                    "firstName": "Lord",
                    "lastName": "Wilkins",
                    "email": "  lwilkins@df.dj",
                },
                {
                    "visitId": "fe61e1f0-34f1-4701-b806-45395980acfb",
                    "firstName": "cg",
                    "lastName": "cg",
                    "email": "cg@gg.hg",
                },
                {
                    "visitId": "226eed33-b2ca-4406-b085-8534c2f87c69",
                    "firstName": "ar",
                    "lastName": "fg",
                    "email": "ar@gg.hh",
                }
            ]
        },
        {
            "id": "cf6934c1-3800-4b79-9d0f-570934097d26",
            "dateStart": "2019-11-30T00:00:06.000Z",
            "dateEnd": "2019-11-30T02:00:06.000Z",
            "visitors": [
                {
                    "visitId": "03a01b91-f307-4a04-ae7a-71a5e3e183c5",
                    "firstName": "ar",
                    "lastName": "fg",
                    "email": "ar@gg.hh",
                }
            ]
        },
        {
            "id": "a46130c3-5b80-419e-8c57-e17428d4b735",
            "dateStart": "2019-11-28T13:00:09.000Z",
            "dateEnd": "2019-11-29T02:45:09.000Z",
            "visitors": [
                {
                    "visitId": "5068a774-1cf3-45e2-af65-b98ab4dfbff2",
                    "firstName": "dot",
                    "lastName": "mn",
                    "email": "dtmn@gg.gh",
                }
            ]
        }
    ]
}

如果有人感兴趣，这是我的模型课：

现在，我正在尝试检索开始日期和结束日期，并将其放在名字和姓氏以及电子邮件的顶部，如下所示：

" Nov 28, 2:00pm - 6:00 pm 
  lord wilkins
  lwilkins@df.dj

  Nov 28, 2:00pm - 6:00 pm 
  cg cg
  cg@gg.hg"

请注意，我是如何重复适用于分组在一起的条目的相同日期的。，我想实现这一点，但目前我只能检索名字和姓氏以及电子邮件，而不能检索基于我如何安排代码的日期。每次我试图修改代码以包含会议开始和结束日期时，它都会崩溃，或者由于大小原因出现索引越界异常，或者出现空指针异常。该问题发生在适配器中。 以下是我的适配器代码供参考：

public class UpcomingGuestListAdapter extends RecyclerView.Adapter<BaseViewHolder>  {

    private Context context;
    private UpcomingGuestListAdapter.Callback mCallback;
    private List<UpcomingGuestsList.Visitor> mUpcomingGuestListResponseList;
    private List<UpcomingGuestsList.Meeting> mUpcomingGuestListResponseMeetingList;

    public class MyViewHolder extends BaseViewHolder {
        public TextView name, email, arrivalDate;


        public MyViewHolder(@NonNull View itemView) {
            super(itemView);
            Timber.d("viewholder butterknife bind");
            name = itemView.findViewById(R.id.upcoming_guest_name);
            email = itemView.findViewById(R.id.upcoming_guest_email);
            arrivalDate = itemView.findViewById(R.id.arrival_date);
            ButterKnife.bind(this, itemView);
        }

        @Override
        protected void clear() {

        }
        public void onBind(int position) {
            super.onBind(position);
            final UpcomingGuestsList.Visitor guest = mUpcomingGuestListResponseList.get(position);
            final UpcomingGuestsList.Meeting meeting = mUpcomingGuestListResponseMeetingList.get(position);

            String guestWholeName = guest.firstName + " "+ guest.lastName;
            if( guest.getFirstName() != null && guest.getLastName() != null) {
                name.setText(guestWholeName);
            }



            if (guest.getEmail() != null) {
                email.setText(guest.getEmail());
            } else {
                email.setText("");
            }

            String meetingDate = meeting.dateStart + "-"+ meeting.dateEnd;
            if( meeting.getDateStart() != null && meeting.getDateEnd() != null) {
                arrivalDate.setText(meetingDate);
            }
            itemView.setOnClickListener(v -> {
                if(mCallback != null) {
                    mCallback.onItemClick( guest.getFirstName(), guest.getLastName(), guest.getEmail());
                }
            });

        }

    }

    @NonNull
    @Override
    public BaseViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.item_upcoming_guest, parent, false);

        return new UpcomingGuestListAdapter.MyViewHolder(itemView);
    }

    public interface Callback {
        void onItemClick(String guestFirstName, String guestLastName,String guestEmail);

    }

    @Override
    public long getItemId(int position) {
        Timber.d("item id for eventlist adapter : %s",position);
        return position;
    }

    public void addItems(@NonNull List<UpcomingGuestsList.Visitor> repoList) {

        mUpcomingGuestListResponseList.addAll(repoList);
         notifyDataSetChanged();
    }

    public void addMeetingItems(@NonNull List<UpcomingGuestsList.Meeting> meetingList) {
        mUpcomingGuestListResponseMeetingList.addAll(meetingList);
        notifyDataSetChanged();
    }
    @Override
    public void onBindViewHolder(BaseViewHolder holder, final int position) {
        holder.onBind(position);

    }

    public UpcomingGuestListAdapter(Context context, List<UpcomingGuestsList.Visitor> visitorGuestList, List<UpcomingGuestsList.Meeting> meetingList) {
        Timber.d("SearchGuestListAdapter constructor");
        this.context = context;
        this.mUpcomingGuestListResponseList = visitorGuestList;
        this.mUpcomingGuestListResponseMeetingList = meetingList;


    }

    @Override
    public int getItemCount() {

        return (mUpcomingGuestListResponseList  != null)?mUpcomingGuestListResponseList.size():0;
    }

    public void setCallback(UpcomingGuestListAdapter.Callback callback) {
        mCallback = callback;
    }

}

公共类UpcomingGuestListAdapter扩展了RecyclerView.Adapter{
私人语境；
私有UpcomingGuestListAdapter.Callback；
私有列表mupcomingguestlistresselist；
私有列表mUpcomingGuestListResponseMeetingList；
公共类MyViewHolder扩展了BaseViewHolder{
公共文本视图名称、电子邮件、到达日期；
公共MyViewHolder（@NonNull View itemView）{
超级（项目视图）；
Timber.d（“视窗夹butterknife bind”）；
name=itemView.findviewbyd（R.id.uncoming\u guest\u name）；
email=itemView.findviewbyd（R.id.comming\u guest\u email）；
arrivalDate=itemView.findViewById（R.id.arrival\U日期）；
ButterKnife.bind（这个，itemView）；
}
@凌驾
受保护的空清除（）{
}
公共void onBind（内部位置）{
super.onBind（位置）；
最终UpComingGuestList.Visitor guest=mUpcomingGuestListResponseList.get（位置）；
最终UpComingGuestList.Meeting Meeting=mUpcomingGuestListResponseMeetingList.get（位置）；
字符串guestWholeName=guest.firstName+“”+guest.lastName；
if（guest.getFirstName（）！=null&&guest.getLastName（）！=null）{
name.setText（guestWholeName）；
}
if（guest.getEmail（）！=null）{
email.setText（guest.getEmail（））；
}否则{
email.setText（“”）；
}
字符串meetingDate=meeting.dateStart+“-”+meeting.dateEnd；
if（meeting.getDateStart（）！=null&&meeting.getDateEnd（）！=null）{
arrivalDate.setText（会议日期）；
}
itemView.setOnClickListener（v->{
如果（mCallback！=null）{
mCallback.onItemClick（guest.getFirstName（），guest.getLastName（），guest.getEmail（））；
}
});
}
}
@非空
@凌驾
public BaseViewHolder onCreateViewHolder（视图组父级，int-viewType）{
View itemView=LayoutInflater.from（parent.getContext（））
.充气（R.layout.item\u即将到来的客人、家长、假）；
返回新的UpcomingGuestListAdapter.MyViewHolder（itemView）；
}
公共接口回调{
void onItemClick（字符串guestFirstName、字符串guestLastName、字符串guestmail）；
}
@凌驾
公共长getItemId（int位置）{
d（“事件列表适配器的项目id:%s”，位置）；
返回位置；
}
公共无效附加项（@NonNull List repoList）{
mUpcomingGuestListResponseList.addAll（repoList）；
notifyDataSetChanged（）；
}
public void addMeetingItems（@NonNull List meetingList）{
mUpcomingGuestListResponseMeetingList.addAll（会议列表）；
notifyDataSetChanged（）；
}
@凌驾
公共无效onBindViewHolder（BaseViewHolder，最终int位置）{
支架。onBind（位置）；
}
公共UpcomingGuestListAdapter（上下文上下文、列表访问者GuestList、列表会议列表）{
Timber.d（“SearchGuestListaAdapter构造函数”）；
this.context=上下文；
this.mUpcomingGuestListResponseList=访问者访客列表；
this.mUpcomingGuestListResponseMeetingList=会议列表；
}
@凌驾
public int getItemCount（）{
返回（mupcominguestlistResponseList！=null）？mupcominguestlistResponseList.size（）：0；
}
public void setCallback（UpcomingGuestListAdapter.Callback）{
mCallback=回调；
}
}

下面是活动中的代码，它从中获取数据：

   @Override
    public void updateUpcomingGuestList(List<UpcomingGuestsList.Visitor> guestList,List<UpcomingGuestsList.Meeting> meetingList) {

        mUpcomingGuestAdapter.addItems(guestList);
        mUpcomingGuestAdapter.addMeetingItems(meetingList);
        mUpcomingGuestAdapter.notifyDataSetChanged();
    }

@覆盖
public void updateUpcomingGuestList（列表来宾列表、列表会议列表）{
mUpcomingGuestAdapter.addItems（宾客列表）；
添加会议项目（会议列表）；
mUpcomingGuestAdapter.notifyDataSetChanged（）；
}

在同一活动中，以下是我在创建时设置适配器的方式：

   guestList = new ArrayList<>();
        mUpcomingGuestAdapter = new UpcomingGuestListAdapter(this, guestList, meetingList);
        mUpcomingGuestAdapter.setCallback(this);
        mLayoutManager.setOrientation(LinearLayoutManager.VERTICAL);
        mRecyclerView.setLayoutManager(mLayoutManager);
        mRecyclerView.setItemAnimator(new DefaultItemAnimator());
        mRecyclerView.setAdapter(mUpcomingGuestAdapter);
        mPresenter.onViewPrepared();

guestList=newarraylist（）；
mUpcomingGuestAdapter=新的UpcomingGuestListAdapter（这个，guestList，meetingList）；
设置回调（this）；
mLayoutManager.setOrientation（LinearLayoutManager.VERTICAL）；
mRecyclerView.setLayoutManager（mllayoutmanager）；
setItemAnimator（新的DefaultItemAnimator（））；
mRecyclerView.setAdapter（mUpcomingGuestAdapter）；
mPresenter.onViewPrepared（）；

在我检索json数据的地方准备了ViewOn的代码：

 @Override
    public void onViewPrepared() {
        getCompositeDisposable().add(getDataManager()
                .getUpcomingGuestListApiCall(AppPreferencesHelper.getInstance().getCurrentUserId())
                .subscribeOn(getSchedulerProvider().io())
                .observeOn(getSchedulerProvider().ui())
                .subscribe(response -> {
                    int sizercount = 0;
                    for (int i = 0; i <response.totalResults; i++) {
                            Objects.requireNonNull(getMvpView()).updateUpcomingGuestList(response.meetings.get(i).getVisitors(),response.getMeetings());

                            sizercount++;
                    }

                    totalGuests = sizercount;

                    Timber.d("total results value is : from upcomingguests %s",response.totalResults);
                    getDataManager().getUpcomingGuestsList();
                    AppPreferencesHelper.getInstance().setTotalUpcomingGuestCount(sizercount);

                }, throwable -> {
                    if (!isViewAttached()) {
                        return;
                    }

                    // handle the error here

                    if (throwable instanceof ANError) {
                        ANError anError = (ANError) throwable;
                        Timber.d("it is ERROR in displaylocation in Registervisitorpresenter:%s", anError.getErrorDetail());

                        handleApiError(anError);
                    }
                }));
    }

@覆盖
public void onViewPrepared（）{
getCompositeDisposable（）.add（getDataManager（））
.GetUpComingGuestListCall（AppPreferencesHelper.getInstance（）.getCurrentUserId（））
.subscribeOn（getSchedulerProvider（）.io（））
.observeOn（getSchedulerProvider（）.ui（））
.订阅（响应->{
int sizercou
public class UpcomingGuest {


    private String visitId;

    private String firstName;

    private String lastName;

    private String email;

    private Object phone;

    private String status;

    private String meetingId;

    private String meetingDateStart;

    private String meetingDateEnd;

    public UpcomingGuest(UpcomingGuestsList.Visitor visitor, UpcomingGuestsList.Meeting meeting){

        this.visitId = visitor.getVisitId();
        this.firstName = visitor.getFirstName();
        this.lastName = visitor.getLastName();
        this.email = visitor.getEmail();
        this.phone = visitor.getPhone();
        this.status = visitor.getStatus();
        this.meetingId = meeting.getId();
        this.meetingDateStart = meeting.getDateStart();
        this.meetingDateEnd = meeting.getDateEnd();

    }

    public String getVisitId() {
        return visitId;
    }

    public void setVisitId(String visitId) {
        this.visitId = visitId;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Object getPhone() {
        return phone;
    }

    public void setPhone(Object phone) {
        this.phone = phone;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getMeetingId() {
        return meetingId;
    }

    public void setMeetingId(String meetingId) {
        this.meetingId = meetingId;
    }

    public String getMeetingDateStart() {
        return meetingDateStart;
    }

    public void setMeetingDateStart(String meetingDateStart) {
        this.meetingDateStart = meetingDateStart;
    }

    public String getMeetingDateEnd() {
        return meetingDateEnd;
    }

    public void setMeetingDateEnd(String meetingDateEnd) {
        this.meetingDateEnd = meetingDateEnd;
    }


}


.subscribe(response -> {
                    int sizercount = 0;
                    for (UpcomingGuestsList.Meeting meeting: response.meetings) {
                        for(UpcomingGuestsList.Visitor visitor: meeting.visitors){
                            upcomingGuests.add(new UpcomingGuest(visitor,meeting));
                        }
                    }

                    // send upcomingGuests results to view


                }

private List<UpcomingGuest> mUpcomingGuestList;

.subscribe(response -> {
        ArrayList<UpcomingGuest> upcomingGuests = new ArrayList<>();

        //sort meetings by date
        List<UpcomingGuestsList.Meeting> meetings = response.meetings;
        Collections.sort(meetings, new Comparator<UpcomingGuestsList.Meeting>() {
            @Override
            public int compare(UpcomingGuestsList.Meeting meeting, UpcomingGuestsList.Meeting t1) {
                return meeting.getDateStart().compareTo(t1.getDateStart());
            }
        });

        for (UpcomingGuestsList.Meeting meeting: meetings) {
            //sort visitors by last name
            List<UpcomingGuestsList.Visitor> visitors = meeting.visitors;
            Collections.sort(visitors, new Comparator<UpcomingGuestsList.Visitor>() {
                @Override
                public int compare(UpcomingGuestsList.Visitor visitor, UpcomingGuestsList.Visitor t1) {
                    return visitor.getLastName().compareTo(t1.getLastName());
                }
            });

            for(UpcomingGuestsList.Visitor visitor: visitors){

                upcomingGuests.add(new UpcomingGuest(visitor,meeting));
            }
        }

        // send upcomingGuests results to view


}