list分组填充数据

如何将数据分组填充。

将下面的"李健康","张健全"添加到第一组，将"杨无灾","张无难"添加到第二组

    private List<BaseNode> getEntity1() {
        String [] secondNodeList1 =new String[] {"一组","二组","三组","四组","五组","六组"};
        String [][] FirstNode1 = new String[][]{{"李健康","张健全"},{"杨无灾","张无难"},
                {"杨定云","陈定雨"},{"曾阿牛","普阿猫"},{"赵贵人","高才人"},
                {"何必","任性"}};
        List<BaseNode> list = new ArrayList<>();
        for (int i = 0; i < secondNodeList1.length; i++) {
            List<BaseNode> secondNodeList = new ArrayList<>();
            for (int n = 0; n <= FirstNode1[n].length; n++) {
                SecondNode seNode = new SecondNode(secondNodeList, ""+FirstNode1[0][0]);
                secondNodeList.add(seNode);
            }
            FirstNode entity = new FirstNode(secondNodeList, secondNodeList1[i]);
            list.add(entity);
        }
        return list;
    }

FirstNode 类

public class FirstNode  extends BaseExpandNode {
    private List<BaseNode> childNode;
    private String title;

    public FirstNode(List<BaseNode> childNode, String title) {
        this.childNode = childNode;
        this.title = title;

        setExpanded(false);
    }

    public String getTitle() {
        return title;
    }


    @Nullable
    @Override
    public List<BaseNode> getChildNode() {
        return childNode;
    }
}

SecondNode 类

public class SecondNode extends BaseExpandNode {

    private List<BaseNode> childNode;
    private String title;

    public SecondNode(List<BaseNode> childNode, String title) {
        this.childNode = childNode;
        this.title = title;

        setExpanded(false);
    }

    public String getTitle() {
        return title;
    }

    @Nullable
    @Override
    public List<BaseNode> getChildNode() {
        return childNode;
    }
}

private List<BaseNode> getEntity1() {
    String[] secondNodeList1 = new String[] {"一组", "二组", "三组", "四组", "五组", "六组"};
    String[][] firstNode1 = new String[][]{{"李健康", "张健全"}, {"杨无灾", "张无难"},
            {"杨定云", "陈定雨"}, {"曾阿牛", "普阿猫"}, {"赵贵人", "高才人"}, {"何必", "任性"}};
    List<BaseNode> list = new ArrayList<>();
    for (int i = 0; i < secondNodeList1.length; i++) {
        List<BaseNode> secondNodeList = new ArrayList<>();
        for (int j = 0; j < firstNode1.length; j++) {
            // 如果当前数据需要添加到当前组中
            if (secondNodeList1[i].equals("一组") && (firstNode1[j][0].equals("李健康") || firstNode1[j][0].equals("张健全"))
                    || secondNodeList1[i].equals("二组") && (firstNode1[j][0].equals("杨无灾") || firstNode1[j][0].equals("张无难"))) {
                SecondNode seNode = new SecondNode(null, firstNode1[j][0]);
                secondNodeList.add(seNode);
            }
        }
        FirstNode entity = new FirstNode(secondNodeList, secondNodeList1[i]);
        list.add(entity);
    }
    return list;
}

for (int n = 0; n <= FirstNode1[n].length; n++) {
                SecondNode seNode = new SecondNode(secondNodeList, ""+FirstNode1[0][0]);
                secondNodeList.add(seNode);
            }

首先这一块不对吧
二维数组要用两层for循环遍历，最后是FirstNode1[i][j]

for (int i = 0; i<= FirstNode1.length;i++){
            for(int j = 0; j<= FirstNode1[i].length; j++){
                SecondNode seNode = new SecondNode(secondNodeList, ""+FirstNode1[i][j]);
                secondNodeList.add(seNode);
            }
        }

你需要新建一个实体，属性为：分组名称、姓名列表 。然后循环分组姓名，根据索引匹配分组包含的小组名称列表就可以了。其实实体结构类似一个树形菜单

• 这篇博客也许可以解决你的问题👉 ：list通过里面对象的某个属性分组、分组求和、去重

public class BaseNode{
        private String name;

        public BaseNode(){}

        public BaseNode(String name){
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    public class BaseExpandNode extends BaseNode{
        private List<BaseNode> childNode;
        private String title;
        private Boolean expanded;

        public void setExpanded(Boolean expanded){
            this.expanded = expanded;
        }

        public String getTitle() {
            return title;
        }

        public List<BaseNode> getChildNode() {
            return childNode;
        }

        public BaseExpandNode(List<BaseNode> childNode, String title) {
            this.childNode = childNode;
            this.title = title;
            setExpanded(false);
        }

        public BaseExpandNode(){};

        @Override
        public String toString() {
            return String.format("%s[%s]", getTitle(), String.join(",", childNode.stream().map(BaseNode::getName).collect(Collectors.toList())));
        }
    }

    public class FirstNode extends BaseExpandNode {

        public FirstNode(List<BaseNode> childNode, String title) {
            super(childNode, title);
        }


    }

    public class SecondNode extends BaseExpandNode {

        public SecondNode(List<BaseNode> childNode, String title) {
            super(childNode, title);
        }

    }


    public List<BaseNode> getEntity() {
        String [] secondNodeList1 =new String[] {"一组","二组","三组","四组","五组","六组"};
        String [][] FirstNode1 = new String[][]{{"李健康","张健全"},{"杨无灾","张无难"},
                {"杨定云","陈定雨"},{"曾阿牛","普阿猫"},{"赵贵人","高才人"},
                {"何必","任性"}};
        List<BaseNode> list = new ArrayList<>();
        for (int i = 0; i < secondNodeList1.length; i++) {
            List<BaseNode> secondNodeList = new ArrayList<>();
            for (int n = 0; n < FirstNode1[i].length; n++) {
                secondNodeList.add(new BaseNode(FirstNode1[i][n]));
            }
            FirstNode entity = new FirstNode(secondNodeList, secondNodeList1[i]);
            list.add(entity);
        }
        return list;
    }

    public ServiceImpl(){};

    public static void main(String[] args) {
        System.out.println(new ServiceImpl().getEntity());
    }

题主直接运行就可以，您的采纳就是对我最大的动力

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
根据题目要求，我们需要将数据分成两组，每组内部再分成多个子项，用来展示在RecyclerView中（通过BaseQuickAdapter和BaseMultiItemQuickAdapter）。因此我们需要进行数据转换，将原始数据转换成适用于RecyclerView的数据源。

下面是实现方式。

Step1. 存储原始数据

private String[][] firstNodeArray = new String[][]{{"李健康","张健全"},{"杨无灾","张无难"},
            {"杨定云","陈定雨"},{"曾阿牛","普阿猫"},{"赵贵人","高才人"},
            {"何必","任性"}};

Step2. 构造展示数据源

private ArrayList<BaseNode> generateData() {
        ArrayList<BaseNode> res = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            ArrayList<BaseNode> secondNodes = new ArrayList<>();
            for (int j = 0; j < 2; j++) {
                SecondNode secondNode = new SecondNode(firstNodeArray[i*2+j][0]);
                for (int k = 1; k < firstNodeArray[i*2+j].length; k++) {
                    ThirdNode thirdNode = new ThirdNode(firstNodeArray[i*2+j][k]);
                    secondNode.addSubNode(thirdNode);
                }
                secondNodes.add(secondNode);
            }
            FirstNode firstNode = new FirstNode(secondNodes, "分组" + (i+1));
            res.add(firstNode);
        }
        return res;
    }

第一层逻辑是遍历分组，第二层逻辑是遍历分组内的子项，第三层逻辑是遍历每个子项内部的数据。并把每个数据添加到对应的子节点下。最后，将所有数据添加到res(结果集)。

Step3. 创建展示数据的实体（BaseNode的子类）

public class FirstNode extends BaseNode {
    private String title;
    private ArrayList<BaseNode> subNodeList;

    public FirstNode(ArrayList<BaseNode> subNodes, String title) {
        super(subNodes);
        subNodeList = subNodes;
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    @Override
    public int getItemType() {
        return 0;
    }

    public ArrayList<BaseNode> getSubNodeList() {
        return subNodeList;
    }
}

public class SecondNode extends BaseNode {
    private String title;

    public SecondNode(String title) {
        super();
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    @Override
    public int getItemType() {
        return 1;
    }
}

public class ThirdNode extends BaseNode {
    private String title;

    public ThirdNode(String title) {
        super();
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    @Override
    public int getItemType() {
        return 2;
    }
}

Step4. 在Adapter内部重写getItemType方法，根据“节点类型”返回不同的布局。

public class MyAdapter extends BaseNodeAdapter {
    private static final int LEVEL_0 = 0;
    private static final int LEVEL_1 = 1;
    private static final int LEVEL_2 = 2;

    public MyAdapter() {
        super();
        addItemType(LEVEL_0, R.layout.item_first_node);
        addItemType(LEVEL_1, R.layout.item_second_node);
        addItemType(LEVEL_2, R.layout.item_third_node);
    }

    @Override
    protected int getItemType(List<? extends BaseNode> data, int position) {
        BaseNode node = data.get(position);
        if (node instanceof FirstNode) {
            return LEVEL_0;
        } else if (node instanceof SecondNode) {
            return LEVEL_1;
        } else if (node instanceof ThirdNode) {
            return LEVEL_2;
        }
        return -1;
    }

    @Override
    protected void convert(@NotNull BaseViewHolder holder, BaseNode entity) {
        switch (holder.getItemViewType()) {
            case LEVEL_0:
                setLevel0(holder, ((FirstNode) entity));
                break;
            case LEVEL_1:
                setLevel1(holder, ((SecondNode) entity));
                break;
            case LEVEL_2:
                setLevel2(holder, ((ThirdNode) entity));
                break;
        }
    }

    private void setLevel0(BaseViewHolder holder, FirstNode entity) {
        holder.setText(R.id.tv_title, entity.getTitle());
    }

    private void setLevel1(BaseViewHolder holder, SecondNode entity) {
        holder.setText(R.id.tv_title, entity.getTitle());
    }

    private void setLevel2(BaseViewHolder holder, ThirdNode entity) {
        holder.setText(R.id.tv_title, entity.getTitle());
    }
}

如果我的回答解决了您的问题，请采纳！