基于Tree类对象的可编辑ListView实现：增删改及顶部可覆写项需求

Hey there, let's break down how to adapt your existing string-based ListView implementation to work with Tree objects, covering all your required features. I'll walk you through each part step by step.

1. First, Define Your Tree Class (if not already done) #

Assuming your Tree has some core properties, here's a sample implementation—adjust the fields to match your actual requirements:

public class Tree {
    private String treeName;
    private int matureHeight; // Example numeric property

    // Empty constructor for the top overwritable item
    public Tree() {}

    // Constructor for pre-populated Tree objects
    public Tree(String treeName, int matureHeight) {
        this.treeName = treeName;
        this.matureHeight = matureHeight;
    }

    // Getters & Setters
    public String getTreeName() { return treeName; }
    public void setTreeName(String treeName) { this.treeName = treeName; }
    public int getMatureHeight() { return matureHeight; }
    public void setMatureHeight(int matureHeight) { this.matureHeight = matureHeight; }
}

2. Custom ListView Adapter for Tree Objects #

We'll create a TreeAdapter to handle rendering editable Tree items. Each item will have input fields to edit the Tree's properties:

public class TreeAdapter extends BaseAdapter {
    private Context context;
    private ArrayList<Tree> treeList;
    private OnTreeEditedListener editedListener;

    public interface OnTreeEditedListener {
        void onTreeEdited(int position, Tree updatedTree);
    }

    public TreeAdapter(Context context, ArrayList<Tree> treeList, OnTreeEditedListener listener) {
        this.context = context;
        this.treeList = treeList;
        this.editedListener = listener;
    }

    @Override
    public int getCount() {
        return treeList.size();
    }

    @Override
    public Object getItem(int position) {
        return treeList.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ViewHolder holder;
        Tree currentTree = treeList.get(position);

        if (convertView == null) {
            convertView = LayoutInflater.from(context).inflate(R.layout.item_tree, parent, false);
            holder = new ViewHolder();
            holder.etTreeName = convertView.findViewById(R.id.et_tree_name);
            holder.npHeight = convertView.findViewById(R.id.np_mature_height);
            convertView.setTag(holder);
        } else {
            holder = (ViewHolder) convertView.getTag();
        }

        // Populate fields with current Tree data
        holder.etTreeName.setText(currentTree.getTreeName() != null ? currentTree.getTreeName() : "");
        holder.npHeight.setValue(currentTree.getMatureHeight());

        // Handle text changes for Tree name
        holder.etTreeName.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                currentTree.setTreeName(s.toString().trim());
                editedListener.onTreeEdited(position, currentTree);
            }

            @Override
            public void afterTextChanged(Editable s) {}
        });

        // Handle height changes
        holder.npHeight.setOnValueChangedListener((picker, oldVal, newVal) -> {
            currentTree.setMatureHeight(newVal);
            editedListener.onTreeEdited(position, currentTree);
        });

        return convertView;
    }

    private static class ViewHolder {
        EditText etTreeName;
        NumberPicker npHeight;
    }
}

Note: Create the corresponding layout item_tree.xml with your input fields (EditText, NumberPicker, etc.) to match the ViewHolder.

3. Main Activity/Fragment Logic (Including start() Method) #

This is where we'll tie everything together: initialize the ListView, handle adding/removing Tree objects, and manage the top overwritable item.

public class TreeListActivity extends AppCompatActivity implements TreeAdapter.OnTreeEditedListener {
    private ListView treeListView;
    private ArrayList<Tree> treeDataList;
    private TreeAdapter treeAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_tree_list);
        start(); // Call your required start method
    }

    public void start() {
        // Initialize data list with a blank Tree as the top overwritable item
        treeDataList = new ArrayList<>();
        treeDataList.add(new Tree());

        // Set up ListView and Adapter
        treeListView = findViewById(R.id.list_view_trees);
        treeAdapter = new TreeAdapter(this, treeDataList, this);
        treeListView.setAdapter(treeAdapter);

        // Handle delete key press for selected items
        treeListView.setOnItemClickListener((parent, view, position, id) -> {
            // Keep track of selected position (or use treeListView.getSelectedItemPosition())
        });

        // Listen for hardware delete key
        this.setOnKeyListener((v, keyCode, event) -> {
            if (keyCode == KeyEvent.KEYCODE_DEL && event.getAction() == KeyEvent.ACTION_DOWN) {
                int selectedPos = treeListView.getSelectedItemPosition();
                // Don't delete the top overwritable item
                if (selectedPos != 0 && selectedPos != ListView.INVALID_POSITION) {
                    treeDataList.remove(selectedPos);
                    treeAdapter.notifyDataSetChanged();
                    return true;
                }
            }
            return false;
        });
    }

    @Override
    public void onTreeEdited(int position, Tree updatedTree) {
        // Logic for top overwritable item: if it's the first item and has valid data
        if (position == 0 && isValidTree(updatedTree)) {
            // Add the filled Tree to the list (after the top item)
            treeDataList.add(1, new Tree(updatedTree.getTreeName(), updatedTree.getMatureHeight()));
            // Replace the top item with a new blank Tree
            treeDataList.set(0, new Tree());
            treeAdapter.notifyDataSetChanged();
            // Scroll back to top to show the new blank item
            treeListView.smoothScrollToPosition(0);
        }
    }

    // Helper method to check if a Tree has valid data (adjust criteria as needed)
    private boolean isValidTree(Tree tree) {
        return tree.getTreeName() != null && !tree.getTreeName().isEmpty() && tree.getMatureHeight() > 0;
    }
}

Key Feature Breakdown #

• Edit Tree Objects: The adapter binds input fields directly to Tree properties, updating the object in real-time as the user edits.
• Add New Tree: When the top overwritable item is filled with valid data, it's copied to the list, and a new blank Tree is placed at the top.
• Delete Tree: Pressing the delete key removes the selected item (we skip deleting the top blank item to preserve the add functionality).
• Top Overwritable Item: The onTreeEdited callback triggers the add logic only when the top item has valid data, ensuring we don't add empty Trees.

Notes for Adjustment #

• Modify the isValidTree method to match your validation rules for a "completed" Tree object.
• Adjust the Tree class properties and adapter layout to fit your actual Tree data structure.
• If you're using RecyclerView instead of ListView, the core logic remains the same—you'll just swap the adapter to a RecyclerView.Adapter.

内容的提问来源于stack exchange，提问作者swaffelay