android RecycleView实现多级树形列表
本文实例为大家分享了android RecycleView实现多级树形列表的具体代码，供大家参考，具体内容如下
实现多级树状列表：
1. Node.java
public class Node<T, B> implements Serializable {
/**
* 传入的实体对象
*/
public B bean;
/**
* 设置开启的图片
*/
public int iconExpand = -1;
/**
* 设置关闭的图片
*/
public int iconNoExpand = -1;
private T id;
/**
* 根节点pId为0
*/
private T pId;
private String name;
/**
* 当前的级别
*/
private int level;
/**
* 是否展开
*/
private boolean isExpand = false;
private int icon = -1;
/**
* 下一级的子Node
*/
private List<Node> children = new ArrayList<>();
/**
* 父Node
*/
private Node parent;
/**
* 是否被checked选中
*/
private boolean isChecked;
/**
* 是否为新添加的
*/
public boolean isNewAdd = true;
/**
* 单选标记
*/
public boolean isSingle;
/**
* 支部code
*/
public String braCode;
public Node(T id, T pId, String name) {
super();
this.id = id;
this.pId = pId;
this.name = name;
}
public Node(T id, T pId, String name, B bean) {
super();
this.id = id;
this.pId = pId;
this.name = name;
this.bean = bean;
}
public String getBraCode() {
return braCode;
}
public void setBraCode(String braCode) {
this.braCode = braCode;
}
public boolean isSingle() {
return isSingle;
}
public void setSingle(boolean single) {
isSingle = single;
}
public boolean isChecked() {
return isChecked;
}
public void setChecked(boolean isChecked) {
this.isChecked = isChecked;
}
public Node() {
}
public int getIcon() {
return icon;
}
public void setIcon(int icon) {
this.icon = icon;
}
public T getId() {
return id;
}
public void setId(T id) {
this.id = id;
}
public T getpId() {
return pId;
}
public void setpId(T pId) {
this.pId = pId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setLevel(int level) {
this.level = level;
}
public boolean isExpand() {
return isExpand;
}
public List<Node> getChildren() {
return children;
}
public void setChildren(List<Node> children) {
this.children = children;
}
public Node getParent() {
return parent;
}
public void setParent(Node parent) {
this.parent = parent;
}
/**
* 是否为跟节点
*
* @return
*/
public boolean isRoot() {
return parent == null;
}
/**
* 判断父节点是否展开
*
* @return
*/
public boolean isParentExpand() {
if (parent == null){
return false;
}
return parent.isExpand();
}
/**
* 是否是叶子界点
*
* @return
*/
public boolean isLeaf() {
return children.size() == 0;
}
/**
* 获取level
*/
public int getLevel() {
return parent == null ? 0 : parent.getLevel() + 1;
}
/**
* 设置展开
*
* @param isExpand
*/
public void setExpand(boolean isExpand) {
this.isExpand = isExpand;
if (!isExpand) {
for (Node node : children) {
node.setExpand(false);
}
}
}
}
2. OnTreeNodeClickListener.java
public interface OnTreeNodeClickListener {
/**
* 点击事件方法
* @param node 节点
* @param position 条目位置
*/
void onClick(Node node, int position);
}
3. TreeHelper.java
public class TreeHelper {
/**
* 传入node 返回排序后的Node
*
* @param datas 传入数据
* @param defaultExpandLevel 默认展开等级
* @return
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
public static List<Node> getSortedNodes(List<Node> datas, int defaultExpandLevel) {
List<Node> result = new ArrayList<Node>();
// 设置Node间父子关系
List<Node> nodes = convetData2Node(datas);
// 拿到根节点
List<Node> rootNodes = getRootNodes(nodes);
// 排序以及设置Node间关系
for (Node node : rootNodes) {
addNode(result, node, defaultExpandLevel, 1);
}
return result;
}
/**
* 过滤出所有可见的Node
*
* @param nodes
* @return
*/
public static List<Node> filterVisibleNode(List<Node> nodes) {
List<Node> result = new ArrayList<Node>();
for (Node node : nodes) {
// 如果为跟节点，或者上层目录为展开状态
if (node.isRoot() || node.isParentExpand()) {
setNodeIcon(node);
result.add(node);
}
}
return result;
}
/**
* 设置Node间，父子关系;让每两个节点都比较一次，即可设置其中的关系
*/
private static List<Node> convetData2Node(List<Node> nodes) {
for (int i = 0; i < nodes.size(); i++) {
Node n = nodes.get(i);
for (int j = i + 1; j < nodes.size(); j++) {
Node m = nodes.get(j);
//判断id是String，Integer
if (m.getpId() instanceof String) {
if (m.getpId().equals(n.getId())) {
n.getChildren().add(m);
m.setParent(n);
} else if (m.getId().equals(n.getpId())) {
m.getChildren().add(n);
n.setParent(m);
}
} else if(m.getpId() instanceof Integer) {
//这里就是修改的地方，因为这是Integer类，节点的地址是不一样的，所以不能直接使用==比较，要用equals()进行值的比较
if (m.getpId().equals(n.getId())) {
n.getChildren().add(m);
m.setParent(n);
} else if (m.getId().equals(n.getpId())) {
m.getChildren().add(n);
n.setParent(m);
}
}
}
}
return nodes;
}
/**
* 获取所有根节点
*
* @param nodes
* @return
*/
private static List<Node> getRootNodes(List<Node> nodes) {
List<Node> root = new ArrayList<Node>();
for (Node node : nodes) {
if (node.isRoot()) {
root.add(node);
}
}
return root;
}
/**
* 把一个节点上的所有的内容都挂上去
*/
private static <T, B> void addNode(List<Node> nodes, Node<T, B> node,
int defaultExpandLeval, int currentLevel) {
nodes.add(node);
//判断添加新节点的时候，保持以前的状态不变
if (node.isNewAdd && defaultExpandLeval >= currentLevel) {
node.setExpand(true);
}
if (node.isLeaf()) {
//判断是子节点
return;
}
for (int i = 0; i < node.getChildren().size(); i++) {
addNode(nodes, node.getChildren().get(i), defaultExpandLeval,
currentLevel + 1);
}
}
/**
* 设置节点的图标
*
* @param node
*/
private static void setNodeIcon(Node node) {
if (node.getChildren().size() > 0 && node.isExpand()) {
node.setIcon(node.iconExpand);
} else if (node.getChildren().size() > 0 && !node.isExpand()) {
node.setIcon(node.iconNoExpand);
} else {
node.setIcon(-1);
}
}
}
4. TreeRecyclerAdapter.java -----RecycleView形式的树形列表适配器
public abstract class TreeRecyclerAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
protected Context mContext;
/**
* 存储所有可见的Node
*/
protected List<Node> mNodes = new ArrayList<>();
protected LayoutInflater mInflater;
/**
* 存储所有的Node
*/
protected List<Node> mAllNodes = new ArrayList<>();
/**
* 点击的回调接口
*/
private OnTreeNodeClickListener onTreeNodeClickListener;
/**
* 默认不展开
*/
private int defaultExpandLevel = 0;
/**
* 展开与关闭的图片
*/
private int iconExpand = -1, iconNoExpand = -1;
/**
* 当前被点击的位置
*/
private int layoutPosition = -1;
public void setOnTreeNodeClickListener(OnTreeNodeClickListener onTreeNodeClickListener) {
this.onTreeNodeClickListener = onTreeNodeClickListener;
}
public TreeRecyclerAdapter(RecyclerView mTree, Context context, List<Node> datas,
int defaultExpandLevel, int iconExpand, int iconNoExpand) {
this.iconExpand = iconExpand;
this.iconNoExpand = iconNoExpand;
for (Node node : datas) {
node.getChildren().clear();
node.iconExpand = iconExpand;
node.iconNoExpand = iconNoExpand;
}
this.defaultExpandLevel = defaultExpandLevel;
mContext = context;
/**
* 对所有的Node进行排序
*/
mAllNodes = TreeHelper.getSortedNodes(datas, defaultExpandLevel);
/**
* 过滤出可见的Node
*/
mNodes = TreeHelper.filterVisibleNode(mAllNodes);
mInflater = LayoutInflater.from(context);
}
/**
* @param mTree
* @param context
* @param datas
* @param defaultExpandLevel 默认展开几级树
*/
public TreeRecyclerAdapter(RecyclerView mTree, Context context, List<Node> datas,
int defaultExpandLevel) {
this(mTree, context, datas, defaultExpandLevel, -1, -1);
}
@Override
public void onBindViewHolder(final RecyclerView.ViewHolder holder, final int position) {
Node node = mNodes.get(position);
// convertView = getConvertView(node, position, convertView, parent);
// 设置内边距
int padding = DisplayUtil.dp2px(mContext,5);
holder.itemView.setPadding(DisplayUtil.dp2px(mContext,(node.getLevel()+1) * 15),
padding,padding,padding);
//然后设置单选，修改如下
/**
* 设置节点点击时，可以展开以及关闭,将事件继续往外公布
*/
holder.itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//获取当前点击的位置
layoutPosition = holder.getLayoutPosition();
expandOrCollapse(position);
if (onTreeNodeClickListener != null) {
onTreeNodeClickListener.onClick(mNodes.get(position),
position);
}
}
});
if(position == layoutPosition){
node.setSingle(true);
}else {
node.setSingle(false);
}
onBindViewHolder(node, holder, position);
}
@Override
public int getItemCount() {
return mNodes.size();
}
/**
* 清除掉之前数据并刷新 重新添加
*
* @param mlists
* @param defaultExpandLevel 默认展开几级列表
*/
public void addDataAll(List<Node> mlists, int defaultExpandLevel) {
mAllNodes.clear();
addData(-1, mlists, defaultExpandLevel);
}
/**
* 在指定位置添加数据并刷新 可指定刷新后显示层级
*
* @param index
* @param mlists
* @param defaultExpandLevel 默认展开几级列表
*/
public void addData(int index, List<Node> mlists, int defaultExpandLevel) {
this.defaultExpandLevel = defaultExpandLevel;
notifyData(index, mlists);
}
/**
* 在指定位置添加数据并刷新
*
* @param index
* @param mlists
*/
public void addData(int index, List<Node> mlists) {
notifyData(index, mlists);
}
/**
* 添加数据并刷新
*
* @param mlists
*/
public void addData(List<Node> mlists) {
addData(mlists, defaultExpandLevel);
}
/**
* 添加数据并刷新 可指定刷新后显示层级
*
* @param mlists
* @param defaultExpandLevel
*/
public void addData(List<Node> mlists, int defaultExpandLevel) {
this.defaultExpandLevel = defaultExpandLevel;
notifyData(-1, mlists);
}
/**
* 添加数据并刷新
*
* @param node
*/
public void addData(Node node) {
addData(node, defaultExpandLevel);
}
/**
* 添加数据并刷新 可指定刷新后显示层级
*
* @param node
* @param defaultExpandLevel
*/
public void addData(Node node, int defaultExpandLevel) {
List<Node> nodes = new ArrayList<>();
nodes.add(node);
this.defaultExpandLevel = defaultExpandLevel;
notifyData(-1, nodes);
}
/**
* 刷新数据
*
* @param index
* @param mListNodes
*/
private void notifyData(int index, List<Node> mListNodes) {
for (int i = 0; i < mListNodes.size(); i++) {
Node node = mListNodes.get(i);
node.getChildren().clear();
node.iconExpand = iconExpand;
node.iconNoExpand = iconNoExpand;
}
for (int i = 0; i < mAllNodes.size(); i++) {
Node node = mAllNodes.get(i);
node.getChildren().clear();
node.isNewAdd = false;
}
if (index != -1) {
mAllNodes.addAll(index, mListNodes);
} else {
mAllNodes.addAll(mListNodes);
}
/**
* 对所有的Node进行排序
*/
mAllNodes = TreeHelper.getSortedNodes(mAllNodes, defaultExpandLevel);
/**
* 过滤出可见的Node
*/
mNodes = TreeHelper.filterVisibleNode(mAllNodes);
//刷新数据
notifyDataSetChanged();
}
/**
* 获取排序后所有节点
*
* @return
*/
public List<Node> getAllNodes() {
if (mAllNodes == null){
mAllNodes = new ArrayList<Node>();
}
return mAllNodes;
}
/**
* 相应ListView的点击事件 展开或关闭某节点
*
* @param position
*/
public void expandOrCollapse(int position) {
Node n = mNodes.get(position);
if (n != null) {
// 排除传入参数错误异常
if (!n.isLeaf()) {
n.setExpand(!n.isExpand());
mNodes = TreeHelper.filterVisibleNode(mAllNodes);
notifyDataSetChanged();// 刷新视图
}
}
}
/**
* 设置多选
*
* @param node
* @param checked
*/
protected void setChecked(final Node node, boolean checked) {
node.setChecked(checked);
setChildChecked(node, checked);
if (node.getParent() != null){
setNodeParentChecked(node.getParent(), checked);
}
notifyDataSetChanged();
}
/**
* 设置是否选中
*
* @param node
* @param checked
*/
public <T, B> void setChildChecked(Node<T, B> node, boolean checked) {
if (!node.isLeaf()) {
node.setChecked(checked);
for (Node childrenNode : node.getChildren()) {
setChildChecked(childrenNode, checked);
}
} else {
node.setChecked(checked);
}
}
private void setNodeParentChecked(Node node, boolean checked) {
if (checked) {
node.setChecked(checked);
if (node.getParent() != null){
setNodeParentChecked(node.getParent(), checked);
}
} else {
List<Node> childrens = node.getChildren();
boolean isChecked = false;
for (Node children : childrens) {
if (children.isChecked()) {
isChecked = true;
}
}
//如果所有自节点都没有被选中 父节点也不选中
if (!isChecked) {
node.setChecked(checked);
}
if (node.getParent() != null){
setNodeParentChecked(node.getParent(), checked);
}
}
}
public abstract void onBindViewHolder(Node node, RecyclerView.ViewHolder holder, final int position);
//===================在这里添加修改选中位置的方法=====================
/**
* 设置选中位置
* @param selectedPosition
*/
public void setSelectedPosition(int selectedPosition) {
this.layoutPosition = selectedPosition;
}
}
5. 自定义样式：
TypeTreeRecyclerAdapter.java
public class TypeTreeRecyclerAdapter extends TreeRecyclerAdapter {
private static final String TAG = "TypeTreeRecyclerAdapter";
private boolean isSingle;
public TypeTreeRecyclerAdapter(RecyclerView mTree, Context context, List<Node> datas, int defaultExpandLevel, int iconExpand, int iconNoExpand,boolean isSingle) {
super(mTree, context, datas, defaultExpandLevel, iconExpand, iconNoExpand);
this.isSingle = isSingle;
}
public TypeTreeRecyclerAdapter(RecyclerView mTree, Context context, List<Node> datas, int defaultExpandLevel) {
super(mTree, context, datas, defaultExpandLevel);
}
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
return new MyHoder(View.inflate(mContext, R.layout.tree_list_item,null));
}
@Override
public void onBindViewHolder(final Node node, RecyclerView.ViewHolder holder, int position) {
final MyHoder viewHolder = (MyHoder) holder;
//todo do something
viewHolder.cb.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// setChecked(node,viewHolder.cb.isChecked());
setChildChecked(node,viewHolder.cb.isChecked());
listener.onItemClick(position);
}
});
viewHolder.cb.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
if (isSingle) {
if (b) { //如果checkbox的状态是选中的，那么除了被选中的那条数据，其他Node节点的checkbox状态都为false
for (int i = 0; i < mAllNodes.size(); i++) {
if (((Node) mAllNodes.get(i)).getId().equals(node.getId())) {
Log.e(TAG,"note="+mAllNodes.get(i).getName());
((Node) mAllNodes.get(i)).setChecked(b);
} else {
// Log.e(TAG,"1111 note="+mAllNodes.get(i).getName());
((Node) mAllNodes.get(i)).setChecked(false);
}
}
} else {//如果checkbox的状态是选中的，所有Node节点checkbox状态都为false
for (int i = 0; i < mAllNodes.size(); i++) {
if (((Node) mAllNodes.get(i)).getId().equals(node.getId())) {
((Node) mAllNodes.get(i)).setChecked(b);
}
}
}
} else { 如果checkbox是多选的，对应node节点的checkbox状态视用户的操作而定
for (int i = 0; i < mAllNodes.size(); i++) {
if (((Node) mAllNodes.get(i)).getId().equals(node.getId()))
((Node) mAllNodes.get(i)).setChecked(b);
}
}
}
});
if (node.isChecked()){
viewHolder.cb.setChecked(true);
}else {
viewHolder.cb.setChecked(false);
}
if (node.getIcon() == -1) {
viewHolder.icon.setVisibility(View.INVISIBLE);
} else {
viewHolder.icon.setVisibility(View.VISIBLE);
viewHolder.icon.setImageResource(node.getIcon());
}
viewHolder.label.setText(node.getName());
}
public interface onAItemClickListener{
void onItemClick(int position);
}
private onAItemClickListener listener;
public void setOnItemClickListener (onAItemClickListener onItemClickListener) {
listener = onItemClickListener;
}
class MyHoder extends RecyclerView.ViewHolder{
public CheckBox cb;
public TextView label;
public ImageView icon;
public MyHoder(View itemView) {
super(itemView);
cb = (CheckBox) itemView.findViewById(R.id.cb_select_tree);
label = (TextView) itemView.findViewById(R.id.id_treenode_label);
icon = (ImageView) itemView.findViewById(R.id.icon);
}
}
}
6. tree_list_item.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center_vertical">
<ImageView
android:id="@+id/icon"
android:layout_width="16dp"
android:layout_height="16dp"
android:scaleType="centerCrop"/>
<CheckBox
android:id="@+id/cb_select_tree"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="10dp"
android:layout_marginRight="10dp"
android:focusable="false"
/>
<TextView
android:id="@+id/id_treenode_label"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:singleLine="true"
android:ellipsize="marquee"
android:textColor="#000"
android:textSize="14sp"/>
</LinearLayout>
7. 页面：
public class OfficeTypeDialog extends Dialog implements View.OnClickListener {
private static final String TAG = "OfficeTypeDialog";
private Context mContext;
private RecyclerView rv_typeTree;
private TypeTreeRecyclerAdapter typeTreeRecyclerAdapter;
private TypeTreeBean selectedBean;
private Button btn_confirm,btn_cancel;
private String source;
private String orgId;
public OfficeTypeDialog(@NonNull Context context) {
super(context);
mContext = context;
}
public OfficeTypeDialog(@NonNull Context context, int themeResId) {
super(context, themeResId);
mContext = context;
}
public OfficeTypeDialog(@NonNull Context context, int themeResId,String source) {
super(context, themeResId);
mContext = context;
this.source = source;
}
public OfficeTypeDialog(@NonNull Context context, int themeResId,String source,String orgId) {
super(context, themeResId);
mContext = context;
this.source = source;
this.orgId = orgId;
}
protected OfficeTypeDialog(@NonNull Context context, boolean cancelable, @Nullable OnCancelListener cancelListener) {
super(context, cancelable, cancelListener);
mContext = context;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.dialog_office_type);
getWindow().setGravity(Gravity.CENTER); //显示在
WindowManager m = getWindow().getWindowManager();
Display d = m.getDefaultDisplay();
WindowManager.LayoutParams p = getWindow().getAttributes();
p.width = d.getWidth()/5*4; //设置dialog的宽度为当前手机屏幕的宽度
p.height = d.getHeight()/5*4;
getWindow().setAttributes(p);
rv_typeTree = findViewById(R.id.rv_typeTree);
btn_confirm = findViewById(R.id.btn_confirm);
btn_cancel = findViewById(R.id.btn_cancel);
btn_confirm.setOnClickListener(this);
btn_cancel.setOnClickListener(this);
getOfficeType();
}
List<Node> mDatas = new ArrayList<>();
private List<TypeTreeBean> typeTreeBeans = new ArrayList<>();
private void getOfficeType() {
String url = "";
if (source.equals("officeType")) {
url = WebApi.OFFICE_TYPE;
} else if(source.equals("area")) {
url = WebApi.OFFICE_AREA;
} else if(source.equals("nmpa")) {
url = WebApi.OFFICE_NMPA;
} else if(source.equals("nmpaUser")) {
if (orgId != null) {
url = WebApi.OFFICE_NMPA_USER+"?orgId="+orgId;
}
}
OkHttpUtil.get(TAG, url, new StringCallback() {
@Override
public void onError(Call call, Exception e, int id) {
Log.e(TAG,"getOfficeType e="+e);
}
@Override
public void onResponse(String response, int id) {
Log.e(TAG,"getOfficeType response="+response);
try {
JSONObject object = new JSONObject(response);
if (object.getInt("code") == 200) {
JSONArray array = object.getJSONArray("data");
Gson gson = new Gson();
for (int i = 0;i<array.length();i++) {
TypeTreeBean typeTreeBean = gson.fromJson(array.get(i).toString(), TypeTreeBean.class);
typeTreeBeans.add(typeTreeBean);
}
for (int j=0;j<typeTreeBeans.size();j++) {
TypeTreeBean typeTreeBean = typeTreeBeans.get(j);
mDatas.add(new Node(typeTreeBean.getId(),0,typeTreeBean.getName(),typeTreeBean));
if (typeTreeBean.getChildren() != null && typeTreeBean.getChildren().size() != 0) {
List<TypeTreeBean> typeTreeBeans1 = typeTreeBean.getChildren();
for (int j1 = 0;j1<typeTreeBeans1.size();j1++) {
TypeTreeBean typeTreeBean1 = typeTreeBeans1.get(j1);
mDatas.add(new Node(typeTreeBean1.getId(),typeTreeBean.getId(),typeTreeBean1.getName(),typeTreeBean1));
if (typeTreeBean1.getChildren() != null && typeTreeBean1.getChildren().size() != 0) {
List<TypeTreeBean> typeTreeBeans2 = typeTreeBean1.getChildren();
for (int j2 = 0;j2<typeTreeBeans2.size();j2++) {
TypeTreeBean typeTreeBean2 = typeTreeBeans2.get(j2);
mDatas.add(new Node(typeTreeBean2.getId(),typeTreeBean1.getId(),typeTreeBean2.getName(),typeTreeBean2));
if (typeTreeBean2.getChildren() != null && typeTreeBean2.getChildren().size() != 0) {
List<TypeTreeBean> typeTreeBeans3 = typeTreeBean2.getChildren();
for (int j3 = 0;j3<typeTreeBeans3.size();j3++) {
TypeTreeBean typeTreeBean3 = typeTreeBeans3.get(j3);
mDatas.add(new Node(typeTreeBean3.getId(),typeTreeBean2.getId(),typeTreeBean3.getName(),typeTreeBean3));
if (typeTreeBean3.getChildren() != null && typeTreeBean3.getChildren().size() != 0) {
List<TypeTreeBean> typeTreeBeans4 = typeTreeBean3.getChildren();
for (int j4 = 0;j4<typeTreeBeans4.size();j4++) {
TypeTreeBean typeTreeBean4 = typeTreeBeans4.get(j4);
mDatas.add(new Node(typeTreeBean4.getId(),typeTreeBean3.getId(),typeTreeBean4.getName(),typeTreeBean4));
}
}
}
}
}
}
}
}
}
initTypeList();
}
} catch (JSONException e) {
e.printStackTrace();
}
}
});
}
private void initTypeList() {
rv_typeTree.setLayoutManager(new LinearLayoutManager(mContext));
typeTreeRecyclerAdapter = new TypeTreeRecyclerAdapter(rv_typeTree, mContext,
mDatas, 1,R.drawable.tree_expand,R.drawable.tree_econpand, true);
rv_typeTree.setAdapter(typeTreeRecyclerAdapter);
typeTreeRecyclerAdapter.setOnItemClickListener(new TypeTreeRecyclerAdapter.onAItemClickListener() {
@Override
public void onItemClick(int position) {
Log.e(TAG,"position="+position);
updatePosition(position);
clickShow();
}
});
}
/**
* 更新选择窗
*
* @param selectedPosition 选中位置
*/
public void updatePosition(int selectedPosition) {
if (typeTreeRecyclerAdapter != null) {
typeTreeRecyclerAdapter.setSelectedPosition(selectedPosition);
typeTreeRecyclerAdapter.notifyDataSetChanged();
}
}
/**
* 显示选中数据
*/
public void clickShow(){
// StringBuilder sb = new StringBuilder();
List<TypeTreeBean> typeTreeBeanList = new ArrayList<>();
final List<Node> allNodes = typeTreeRecyclerAdapter.getAllNodes();
for (int i = 0; i < allNodes.size(); i++) {
if (allNodes.get(i).isChecked()){
// sb.append(allNodes.get(i).getName()+",");
typeTreeBeanList.add((TypeTreeBean) allNodes.get(i).bean);
}
}
// String strNodesName = sb.toString();
if (typeTreeBeanList != null && typeTreeBeanList.size() != 0) {
Log.e(TAG,"bean="+typeTreeBeanList.get(0).getName());
selectedBean = typeTreeBeanList.get(0);
}
}
/**
* 设置确定取消按钮的回调
*/
public OnClickBottomListener onClickBottomListener;
public void setOnClickBottomListener(OnClickBottomListener onClickBottomListener) {
this.onClickBottomListener = onClickBottomListener;
}
public interface OnClickBottomListener{
/**
* 点击确定按钮事件
*/
public void onPositiveClick(TypeTreeBean typeBean);
/**
* 点击取消按钮事件
*/
public void onNegtiveClick();
}
@Override
public void onClick(View view) {
switch (view.getId()) {
case R.id.btn_confirm:
if ( onClickBottomListener!= null) {
onClickBottomListener.onPositiveClick(selectedBean);
}
break;
case R.id.btn_cancel:
if ( onClickBottomListener!= null) {
onClickBottomListener.onNegtiveClick();
}
break;
}
}
}
8. 调用dialog
OfficeTypeDialog typeDialog = new OfficeTypeDialog(mContext,R.style.Dialog,"officeType");
typeDialog.setOnClickBottomListener(new OfficeTypeDialog.OnClickBottomListener() {
@Override
public void onPositiveClick(TypeTreeBean typeBean) {
tv_officeType.setText(typeBean.getName());
officeType = typeBean;
typeDialog.dismiss();
}
@Override
public void onNegtiveClick() {
typeDialog.dismiss();
}
});
typeDialog.show();
9. 效果图
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。
以上是 android RecycleView实现多级树形列表 的全部内容， 来源链接： utcz.com/p/243610.html
