Java Android DialogFragment从参数中获取空列表

我试图将所选项目的LinkedList传递给DialogFragment，然后如果用户按下delete按钮，则将此列表传递给在我的活动类中删除这些项目的方法。然而，我在DialogFragment中得到了空列表

我在调试器中多次检查所选项目的列表是否为空，但我从getArguments（）中得到了一个空项目。getSerializable（）

对话类

public class MyDialog extends AppCompatDialogFragment {
public static final String DIALOG_TAG = "Dialog window";
private MyDialogListener listener;
private DialogOption dialogOption;

public MyDialog(DialogOption dialogOption) {
    this.dialogOption = dialogOption;
}

@NonNull
@Override
public android.app.Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    LayoutInflater inflater = getActivity().getLayoutInflater();
    View view;

    switch (dialogOption) {
        case DIALOG_ADD:
            view = inflater.inflate(R.layout.dialog_addtheme, null);
            final EditText editTextThemeName = view.findViewById(R.id.editText_themeName);

            builder.setView(view)
                    .setTitle("Add Theme")
                    .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {
                        }
                    })
                    .setPositiveButton("Add", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {
                            String stringThemeName = editTextThemeName.getText().toString();
                            listener.addTheme(new Theme(stringThemeName));
                        }
                    });
            break;

        case DIALOG_DELETE:
            view = inflater.inflate(R.layout.dialog_deletetheme, null);

            builder.setView(view)
                    .setTitle("Delete themes")
                    .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {

                        }
                    })
                    .setPositiveButton("Delete", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {
                            LinkedList<Theme> toDelete = (LinkedList<Theme>) getArguments().getSerializable("To delete");
                            listener.removeThemes(toDelete);
                        }
                    });
            break;

        case DIALOG_EDIT:
    }
    return builder.create();
}

@Override
public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    listener = (MyDialogListener) context;
}

public interface MyDialogListener {
    void addTheme(Theme theme);

    void removeThemes(LinkedList<Theme> themes);
}

公共类MyDialog扩展了AppCompatDialogFragment{
公共静态最终字符串对话框\u TAG=“对话框窗口”；
私有MyDialogListener；
私人对话选项；
公共MyDialog（DialogOption）{
this.dialogOption=dialogOption；
}
@非空
@凌驾
public android.app.Dialog onCreateDialog（@Nullable Bundle savedInstanceState）{
AlertDialog.Builder=新建AlertDialog.Builder（getActivity（））；
LayoutFlater充气机=getActivity（）.GetLayoutFlater（）；
视图；
开关（对话框选项）{
案例对话框\u添加：
视图=充气机。充气（R.layout.dialog\u addtheme，null）；
final EditText editTextThemeName=view.findViewById（R.id.EditText\u themeName）；
builder.setView（视图）
.setTitle（“添加主题”）
.setNegativeButton（“取消”，新建DialogInterface.OnClickListener（））{
@凌驾
公共void onClick（DialogInterface，inti）{
}
})
.setPositiveButton（“添加”，新建DialogInterface.OnClickListener（）{
@凌驾
公共void onClick（DialogInterface，inti）{
字符串stringThemeName=editTextThemeName.getText（）.toString（）；
addTheme（新主题（stringThemeName））；
}
});
打破
案例对话框\u删除：
视图=充气机。充气（R.layout.dialog\u deletetheme，null）；
builder.setView（视图）
.setTitle（“删除主题”）
.setNegativeButton（“取消”，新建DialogInterface.OnClickListener（））{
@凌驾
公共void onClick（DialogInterface，inti）{
}
})
.setPositiveButton（“删除”，新建DialogInterface.OnClickListener（）{
@凌驾
公共void onClick（DialogInterface，inti）{
LinkedList toDelete=（LinkedList）getArguments（）.getSerializable（“删除”）；
听者。删除主题（toDelete）；
}
});
打破
案例对话框\u编辑：
}
返回builder.create（）；
}
@凌驾
public void onAttach（@NonNull上下文）{
super.onAttach（上下文）；
listener=（MyDialogListener）上下文；
}
公共接口MyDialogListener{
void addTheme（主题主题）；
无效删除主题（LinkedList主题）；
}

}

适配器类

public class ThemeListAdapter extends RecyclerView.Adapter<ThemeListAdapter.ThemeViewHolder> {
private LinkedList<Theme> themeList;
private LayoutInflater inflater;
private DictionaryActivity context;
private ActionMode actionMode;
private boolean multiSelect = false;
private LinkedList<Theme> selectedItems = new LinkedList<>();
private ArrayList<View> views = new ArrayList<>();
private MenuItem editItem;

public ThemeListAdapter(Context context, LinkedList<Theme> themeList) {
    this.themeList = themeList;
    this.context = (DictionaryActivity) context;
    inflater = LayoutInflater.from(context);
}

@NonNull
@Override
public ThemeViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    View itemView = inflater.inflate(R.layout.themelist_item, parent, false);
    return new ThemeViewHolder(itemView);
}

@Override
public void onBindViewHolder(@NonNull final ThemeViewHolder holder, final int position) {
    views.add(holder.itemView);
    holder.themeName.setText(themeList.get(position).getName());
    holder.wordsCount.setText(themeList.get(position).getWords().size() + " word(s)");
    holder.itemView.setOnLongClickListener(new View.OnLongClickListener() {
        @Override
        public boolean onLongClick(View view) {
            if (actionMode != null) {
                return false;
            }

            actionMode = context.startSupportActionMode(actionModeCallback);
            editItem = actionMode.getMenu().findItem(R.id.edit);
            selectItem(position, holder);

            return true;
        }
    });

    holder.itemView.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            if (multiSelect) {
                selectItem(position, holder);
            }
        }
    });

}

private ActionMode.Callback actionModeCallback = new ActionMode.Callback() {
    @Override
    public boolean onCreateActionMode(ActionMode mode, Menu menu) {
        mode.getMenuInflater().inflate(R.menu.longclick_toolbar_menu, menu);
        multiSelect = true;
        return true;
    }

    @Override
    public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
        return false;
    }

    @Override
    public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
        switch (item.getItemId()) {
            case R.id.delete:
                if (selectedItems.size() != 0) {
                    Bundle data = new Bundle();
                    data.putSerializable("To delete", selectedItems);
                    context.openDialog(DialogOption.DIALOG_DELETE, data);
                    mode.finish();
                }
                return true;
            case R.id.edit:
                context.openDialog(DialogOption.DIALOG_EDIT);
                mode.finish();
                return true;
            default:
                return false;
        }
    }

    @Override
    public void onDestroyActionMode(ActionMode mode) {
        actionMode = null;
        multiSelect = false;

        for (View view : views) {
            view.setBackgroundColor(Color.WHITE);
        }

        selectedItems.clear();
    }
};

private void selectItem(int position, ThemeViewHolder holder) {
    Theme item = themeList.get(position);

    if (selectedItems.contains(item)) {
        selectedItems.remove(item);
        holder.itemView.setBackgroundColor(Color.WHITE);
    } else {
        selectedItems.add(item);
        holder.itemView.setBackgroundColor(context.getResources().getColor(R.color.colorSelected));
    }

    if (selectedItems.size() > 1) {
        editItem.setVisible(false);
    } else {
        editItem.setVisible(true);
    }
}

@Override
public int getItemCount() {
    return themeList.size();
}

public static class ThemeViewHolder extends RecyclerView.ViewHolder {
    public TextView themeName;
    public TextView wordsCount;
    public View itemView;

    public ThemeViewHolder(View itemView) {
        super(itemView);
        this.itemView = itemView;
        themeName = itemView.findViewById(R.id.textView_themeName);
        wordsCount = itemView.findViewById(R.id.textView_wordsCount);
    }
}

public类ThemeListAdapter扩展了RecyclerView.Adapter{
私有链接列表主题列表；
私人充气机；
私人词典；活动语境；
私人行动模式；
私有布尔multiSelect=false；
private LinkedList selectedItems=新建LinkedList（）；
私有ArrayList视图=新建ArrayList（）；
私有菜单项编辑项；
公共主题列表适配器（上下文，链接列表主题列表）{
this.themeList=themeList；
this.context=（DictionaryActivity）上下文；
充气器=充气器。从（上下文）；
}
@非空
@凌驾
创建视图持有者上的公共ThemeViewHolder（@NonNull ViewGroup parent，int viewType）{
查看项目视图=充气机。充气（R.layout.themelist\u项目，父项，false）；
返回新的ThemeViewHolder（itemView）；
}
@凌驾
BindViewHolder上的公共无效（@NonNull final ThemeViewHolder holder，final int position）{
添加（holder.itemView）；
holder.themeName.setText（themeList.get（position.getName（））；
holder.wordscont.setText（themeList.get（position.getWords（）.size（）+“word（s）”）；
holder.itemView.setOnLongClickListener（新视图.OnLongClickListener（）{
@凌驾
仅长按公共布尔值（视图）{
if（actionMode！=null）{
返回false；
}
actionMode=context.startSupportActionMode（actionModeCallback）；
editItem=actionMode.getMenu（）.findItem（R.id.edit）；
选择项目（位置、支架）；
返回true；
}
});
holder.itemView.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图）{
如果（多选）{
选择项目（位置、支架）；
}
}
});
}
私有ActionMode.Callback actionModeCallback=新ActionMode.Callback（）{
@凌驾
公共布尔onCreateActionMode（ActionMode模式，菜单）{
mode.getMenuInflater（）.充气（R.menu.long单击工具栏菜单，菜单）；
multiSelect=true；
返回true；
}
@凌驾
公共布尔onPrepareActionMode（操作模式，菜单）{
返回false；
}
@凌驾
公共布尔值onActionItemClicked（ActionMode模式，菜单项）{
开关（item.getItemId（））{
案例R.id.delete：
如果（selectedItems.size（）！=0）{
Bundle data=新Bundle（）；
data.putSerializable（“要删除，请选择EditEMS”）；
context.openDialog（DialogOption.DIALOG\u DELETE，数据）；
mode.finish（）；
}
返回true；
案例R.id.edit：
context.openDialog（DialogOption.DIALOG\u EDIT）；
mode.finish（）；
返回true；
违约：
public class DictionaryActivity extends AppCompatActivity 
implements MyDialogListener {

private static final String THEMES_FILE = "themes.srl";
private LinkedList<Theme> themeList = new LinkedList<>();
private RecyclerView recyclerView;
private ThemeListAdapter adapter;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_dictionary);
    setTitle(R.string.activity_dictionary_title);
    loadThemes();
    checkNoThemesText();
    initToolBar();
    initRecyclerView();
    initFab();
}

private void checkNoThemesText() {
    TextView noThemeText = findViewById(R.id.textview_no_theme);

    if (themeList.size() == 0) {
        noThemeText.setVisibility(View.VISIBLE);
    } else {
        noThemeText.setVisibility(View.INVISIBLE);
    }
}

private void initToolBar() {
    Toolbar toolbar = findViewById(R.id.toolbar_activity_dictionary);
    setSupportActionBar(toolbar);
}

private void initRecyclerView() {
    recyclerView = findViewById(R.id.recyclerview_themes);
    adapter = new ThemeListAdapter(this, themeList);
    recyclerView.setAdapter(adapter);
    recyclerView.setLayoutManager(new LinearLayoutManager(this));
}

private void initFab() {
    FloatingActionButton fab = findViewById(R.id.fab);
    fab.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            openDialog(DialogOption.DIALOG_ADD);
        }
    });
}

void openDialog(DialogOption dialogOption) {
    MyDialog dialog = new MyDialog(dialogOption);
    dialog.show(getSupportFragmentManager(), DIALOG_TAG);
}

void openDialog(DialogOption dialogOption, Bundle data) {
    MyDialog dialog = new MyDialog(dialogOption);
    dialog.setArguments(data);
    dialog.show(getSupportFragmentManager(), DIALOG_TAG);
}

private void loadThemes() {
    try (FileInputStream fileInput = openFileInput(THEMES_FILE);
         ObjectInputStream objectInput = new ObjectInputStream(fileInput)) {
        themeList = (LinkedList<Theme>) objectInput.readObject();
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
}

private void saveThemes() {
    try (FileOutputStream fileOutput = openFileOutput(THEMES_FILE, Context.MODE_PRIVATE);
         ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutput)) {
        objectOutput.writeObject(themeList);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.dictionary_toolbar_menu, menu);
    return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.action_settings:
            Toast.makeText(DictionaryActivity.this, "Clicked", Toast.LENGTH_SHORT).show();
            break;
    }

    return true;
}

@Override
public void addTheme(Theme theme) {
    themeList.add(theme);
    adapter.notifyDataSetChanged();
    checkNoThemesText();
    saveThemes();
}

@Override
public void removeThemes(LinkedList<Theme> themes) {
    themeList.removeAll(themes);
    adapter.notifyDataSetChanged();
    checkNoThemesText();
    saveThemes();
}