备案控制台
开发者社区 开发与运维 文章 正文

android多级树形列表

2022-01-18 284
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： android多级树形列表

我们开发app过程中，经常会碰到需要 多级列表展示的效果。而android原生sdk中根本没有3级 4级甚至更多级别的列表控件。

所以我们就要自己去实现一个类似treeListView 的控件，下面这个是我项目中的一个效果图，可支持多级列表扩展。

image.png

android中有ExpandListView控件，但是这个控件只支持两级列表。对于多级列表如果重写这个不是很好用。

实现这种列表 思想就是递归，构造一个子父级的关系。

话不多说 代码中体会

Activity

package com.example.customtreeviewdemo;
import java.util.ArrayList;
import java.util.List;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;
import com.example.customtreeviewdemo.bean.MyNodeBean;
import com.example.customtreeviewdemo.tree.Node;
import com.example.customtreeviewdemo.tree.TreeListViewAdapter.OnTreeNodeClickListener;
public class MainActivity extends Activity {
  private ListView treeLv;
  private Button checkSwitchBtn;
  private MyTreeListViewAdapter<MyNodeBean> adapter;
  private List<MyNodeBean> mDatas = new ArrayList<MyNodeBean>();
  //标记是显示Checkbox还是隐藏
  private boolean isHide = true;
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    initDatas();
    treeLv = (ListView) this.findViewById(R.id.tree_lv);
    checkSwitchBtn = (Button)this.findViewById(R.id.check_switch_btn);
    checkSwitchBtn.setOnClickListener(new OnClickListener(){
      @Override
      public void onClick(View v) {
        if(isHide){
          isHide = false;
        }else{
          isHide = true;
        }
        adapter.updateView(isHide);
      }
    });
    try {
      adapter = new MyTreeListViewAdapter<MyNodeBean>(treeLv, this,
          mDatas, 10, isHide);
      adapter.setOnTreeNodeClickListener(new OnTreeNodeClickListener() {
        @Override
        public void onClick(Node node, int position) {
          if (node.isLeaf()) {
            Toast.makeText(getApplicationContext(), node.getName(),
                Toast.LENGTH_SHORT).show();
          }
        }
        @Override
        public void onCheckChange(Node node, int position,
            List<Node> checkedNodes) {
          StringBuffer sb = new StringBuffer();
          for (Node n : checkedNodes) {
            int pos = n.getId() - 1;
            sb.append(mDatas.get(pos).getName()).append("---")
                .append(pos + 1).append(";");
          }
          Toast.makeText(getApplicationContext(), sb.toString(),
              Toast.LENGTH_SHORT).show();
        }
      });
    } catch (IllegalArgumentException e) {
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    }
    treeLv.setAdapter(adapter);
  }
  private void initDatas() {
    mDatas.add(new MyNodeBean(1, 0, "中国古代"));
    mDatas.add(new MyNodeBean(2, 1, "唐朝"));
    mDatas.add(new MyNodeBean(3, 1, "宋朝"));
    mDatas.add(new MyNodeBean(4, 1, "明朝"));
    mDatas.add(new MyNodeBean(5, 2, "李世民"));
    mDatas.add(new MyNodeBean(6, 2, "李白"));
    mDatas.add(new MyNodeBean(7, 3, "赵匡胤"));
    mDatas.add(new MyNodeBean(8, 3, "苏轼"));
    mDatas.add(new MyNodeBean(9, 4, "朱元璋"));
    mDatas.add(new MyNodeBean(10, 4, "唐伯虎"));
    mDatas.add(new MyNodeBean(11, 4, "文征明"));
    mDatas.add(new MyNodeBean(12, 7, "赵建立"));
    mDatas.add(new MyNodeBean(13, 8, "苏东东"));
    mDatas.add(new MyNodeBean(14, 10, "秋香"));
  }
}

Adapter

这个adapter是继承了自己的定义的一个TreeListViewAdapter，核心实现都是在TreeListViewAdapter这个里面

package com.example.customtreeviewdemo;
import java.util.List;
import android.content.Context;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import com.example.customtreeviewdemo.tree.Node;
import com.example.customtreeviewdemo.tree.TreeListViewAdapter;
public class MyTreeListViewAdapter<T> extends TreeListViewAdapter<T> {
  public MyTreeListViewAdapter(ListView mTree, Context context,
      List<T> datas, int defaultExpandLevel,boolean isHide)
      throws IllegalArgumentException, IllegalAccessException {
    super(mTree, context, datas, defaultExpandLevel,isHide);
  }
  @SuppressWarnings("unchecked")
  @Override
  public View getConvertView(Node node, int position, View convertView,
      ViewGroup parent) {
    ViewHolder viewHolder = null;
    if (convertView == null)
    {
      convertView = mInflater.inflate(R.layout.list_item, parent, false);
      viewHolder = new ViewHolder();
      viewHolder.icon = (ImageView) convertView
          .findViewById(R.id.id_treenode_icon);
      viewHolder.label = (TextView) convertView
          .findViewById(R.id.id_treenode_name);
      viewHolder.checkBox = (CheckBox)convertView.findViewById(R.id.id_treeNode_check);
      convertView.setTag(viewHolder);
    } else
    {
      viewHolder = (ViewHolder) convertView.getTag();
    }
    if (node.getIcon() == -1)
    {
      viewHolder.icon.setVisibility(View.INVISIBLE);
    } else
    {
      viewHolder.icon.setVisibility(View.VISIBLE);
      viewHolder.icon.setImageResource(node.getIcon());
    }
    if(node.isHideChecked()){
      viewHolder.checkBox.setVisibility(View.GONE);
    }else{
      viewHolder.checkBox.setVisibility(View.VISIBLE);
      setCheckBoxBg(viewHolder.checkBox,node.isChecked());
    }
    viewHolder.label.setText(node.getName());
    return convertView;
  }
  private final class ViewHolder
  {
    ImageView icon;
    TextView label;
    CheckBox checkBox;
  }
  /**
   * checkbox是否显示
   * @param cb
   * @param isChecked
   */
  private void setCheckBoxBg(CheckBox cb,boolean isChecked){
    if(isChecked){
      cb.setBackgroundResource(R.drawable.check_box_bg_check);
    }else{
      cb.setBackgroundResource(R.drawable.check_box_bg);
    }
  }
}

自定义TreeListViewAdapter  这个是整个树形结构的一个适配器，这里面主要是实现对Node节点的操作 点击，选中改变 更新等

package com.example.customtreeviewdemo.tree;
import java.util.ArrayList;
import java.util.List;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.BaseAdapter;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.ListView;
import android.widget.RelativeLayout;
/**
 * tree适配器
 * @param <T>
 */
public abstract class TreeListViewAdapter<T> extends BaseAdapter {
  protected Context mContext;
  /**
   * 存储所有可见的Node
   */
  protected List<Node> mNodes;
  protected LayoutInflater mInflater;
  /**
   * 存储所有的Node
   */
  protected List<Node> mAllNodes;
  /**
   * 点击的回调接口
   */
  private OnTreeNodeClickListener onTreeNodeClickListener;
  public interface OnTreeNodeClickListener {
    /**
     * 处理node click事件
     * @param node
     * @param position
     */
    void onClick(Node node, int position);
    /**
     * 处理checkbox选择改变事件
     * @param node
     * @param position
     * @param checkedNodes
     */
    void onCheckChange(Node node, int position,List<Node> checkedNodes);
  }
  public void setOnTreeNodeClickListener(
      OnTreeNodeClickListener onTreeNodeClickListener) {
    this.onTreeNodeClickListener = onTreeNodeClickListener;
  }
  /**
   * 
   * @param mTree
   * @param context
   * @param datas
   * @param defaultExpandLevel
   *            默认展开几级树
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   */
  public TreeListViewAdapter(ListView mTree, Context context, List<T> datas,
      int defaultExpandLevel, boolean isHide)
      throws IllegalArgumentException, IllegalAccessException {
    mContext = context;
    /**
     * 对所有的Node进行排序
     */
    mAllNodes = TreeHelper
        .getSortedNodes(datas, defaultExpandLevel, isHide);
    /**
     * 过滤出可见的Node
     */
    mNodes = TreeHelper.filterVisibleNode(mAllNodes);
    mInflater = LayoutInflater.from(context);
    /**
     * 设置节点点击时，可以展开以及关闭；并且将ItemClick事件继续往外公布
     */
    mTree.setOnItemClickListener(new OnItemClickListener() {
      @Override
      public void onItemClick(AdapterView<?> parent, View view,
          int position, long id) {
        expandOrCollapse(position);
        if (onTreeNodeClickListener != null) {
          onTreeNodeClickListener.onClick(mNodes.get(position),
              position);
        }
      }
    });
  }
  /**
   * 相应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();// 刷新视图
      }
    }
  }
  @Override
  public int getCount() {
    return mNodes.size();
  }
  @Override
  public Object getItem(int position) {
    return mNodes.get(position);
  }
  @Override
  public long getItemId(int position) {
    return position;
  }
  @Override
  public View getView(final int position, View convertView, ViewGroup parent) {
    final Node node = mNodes.get(position);
    convertView = getConvertView(node, position, convertView, parent);
    // 设置内边距
    convertView.setPadding(node.getLevel() * 30, 3, 3, 3);
    if (!node.isHideChecked()) {
      //获取各个节点所在的父布局
      RelativeLayout myView = (RelativeLayout) convertView;
      //父布局下的CheckBox
      CheckBox cb = (CheckBox) myView.getChildAt(1);
      cb.setOnCheckedChangeListener(new OnCheckedChangeListener(){
        @Override
        public void onCheckedChanged(CompoundButton buttonView,
            boolean isChecked) {
          TreeHelper.setNodeChecked(node, isChecked);
          List<Node> checkedNodes = new ArrayList<Node>();
          for(Node n:mAllNodes){
            if(n.isChecked()){
              checkedNodes.add(n);
            }
          }
          onTreeNodeClickListener.onCheckChange(node,position,checkedNodes);
          TreeListViewAdapter.this.notifyDataSetChanged();
        }
      });
    }
    return convertView;
  }
  public abstract View getConvertView(Node node, int position,
      View convertView, ViewGroup parent);
  /**
   * 更新
   * @param isHide
   */
  public void updateView(boolean isHide){
    for(Node node:mAllNodes){
      node.setHideChecked(isHide);
    }
    this.notifyDataSetChanged();
  }
}

node 模型类

package com.example.customtreeviewdemo.bean;
public class MyNodeBean {
  /**
   * 节点Id
   */
  private int id;
  /**
   * 节点父id
   */
  private int pId;
  /**
   * 节点name
   */
  private String name;
  /**
   * 
   */
  private String desc;
  /**
   * 节点名字长度
   */
  private long length;
  public MyNodeBean(int id, int pId, String name) {
    super();
    this.id = id;
    this.pId = pId;
    this.name = name;
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public int getPid() {
    return pId;
  }
  public void setPid(int pId) {
    this.pId = pId;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getDesc() {
    return desc;
  }
  public void setDesc(String desc) {
    this.desc = desc;
  }
  public long getLength() {
    return length;
  }
  public void setLength(long length) {
    this.length = length;
  }
}

TreeHelper这个也是核心操作类，主要功能是将业务数据和节点数据进行匹配

package com.example.customtreeviewdemo.tree;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import com.example.customtreeviewdemo.R;
public class TreeHelper {
  /**
   * 根据所有节点获取可见节点
   * 
   * @param allNodes
   * @return
   */
  public static List<Node> filterVisibleNode(List<Node> allNodes) {
    List<Node> visibleNodes = new ArrayList<Node>();
    for (Node node : allNodes) {
      // 如果为根节点，或者上层目录为展开状态
      if (node.isRoot() || node.isParentExpand()) {
        setNodeIcon(node);
        visibleNodes.add(node);
      }
    }
    return visibleNodes;
  }
  /**
   * 获取排序的所有节点
   * 
   * @param datas
   * @param defaultExpandLevel
   * @return
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   */
  public static <T> List<Node> getSortedNodes(List<T> datas,
      int defaultExpandLevel, boolean isHide)
      throws IllegalAccessException, IllegalArgumentException {
    List<Node> sortedNodes = new ArrayList<Node>();
    // 将用户数据转化为List<Node>
    List<Node> nodes = convertData2Nodes(datas, isHide);
    // 拿到根节点
    List<Node> rootNodes = getRootNodes(nodes);
    // 排序以及设置Node间关系
    for (Node node : rootNodes) {
      addNode(sortedNodes, node, defaultExpandLevel, 1);
    }
    return sortedNodes;
  }
  /**
   * 把一个节点上的所有的内容都挂上去
   */
  private static void addNode(List<Node> nodes, Node node,
      int defaultExpandLeval, int currentLevel) {
    nodes.add(node);
    if (defaultExpandLeval >= currentLevel) {
      node.setExpand(true);
    }
    if (node.isLeaf())
      return;
    for (int i = 0; i < node.getChildrenNodes().size(); i++) {
      addNode(nodes, node.getChildrenNodes().get(i), defaultExpandLeval,
          currentLevel + 1);
    }
  }
  /**
   * 获取所有的根节点
   * 
   * @param nodes
   * @return
   */
  public static List<Node> getRootNodes(List<Node> nodes) {
    List<Node> rootNodes = new ArrayList<Node>();
    for (Node node : nodes) {
      if (node.isRoot()) {
        rootNodes.add(node);
      }
    }
    return rootNodes;
  }
  /**
   * 将泛型datas转换为node
   * 
   * @param datas
   * @return
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   */
  public static <T> List<Node> convertData2Nodes(List<T> datas, boolean isHide)
      throws IllegalAccessException, IllegalArgumentException {
    List<Node> nodes = new ArrayList<Node>();
    Node node = null;
    for (T t : datas) {
      int id = -1;
      int pId = -1;
      String name = null;
      Class<? extends Object> clazz = t.getClass();
      Field[] declaredFields = clazz.getDeclaredFields();
      /**
       * 与MyNodeBean实体一一对应
       */
      for (Field f : declaredFields) {
        if ("id".equals(f.getName())) {
          f.setAccessible(true);
          id = f.getInt(t);
        }
        if ("pId".equals(f.getName())) {
          f.setAccessible(true);
          pId = f.getInt(t);
        }
        if ("name".equals(f.getName())) {
          f.setAccessible(true);
          name = (String) f.get(t);
        }
        if ("desc".equals(f.getName())) {
          continue;
        }
        if ("length".equals(f.getName())) {
          continue;
        }
        if (id == -1 && pId == -1 && name == null) {
          break;
        }
      }
      node = new Node(id, pId, name);
      node.setHideChecked(isHide);
      nodes.add(node);
    }
    /**
     * 比较nodes中的所有节点，分别添加children和parent
     */
    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);
        if (n.getId() == m.getpId()) {
          n.getChildrenNodes().add(m);
          m.setParent(n);
        } else if (n.getpId() == m.getId()) {
          n.setParent(m);
          m.getChildrenNodes().add(n);
        }
      }
    }
    for (Node n : nodes) {
      setNodeIcon(n);
    }
    return nodes;
  }
  /**
   * 设置打开，关闭icon
   * 
   * @param node
   */
  public static void setNodeIcon(Node node) {
    if (node.getChildrenNodes().size() > 0 && node.isExpand()) {
      node.setIcon(R.drawable.tree_expand);
    } else if (node.getChildrenNodes().size() > 0 && !node.isExpand()) {
      node.setIcon(R.drawable.tree_econpand);
    } else
      node.setIcon(-1);
  }
  public static void setNodeChecked(Node node, boolean isChecked) {
    // 自己设置是否选择
    node.setChecked(isChecked);
    /**
     * 非叶子节点,子节点处理
     */
    setChildrenNodeChecked(node, isChecked);
    /** 父节点处理 */
    setParentNodeChecked(node);
  }
  /**
   * 非叶子节点,子节点处理
   */
  private static void setChildrenNodeChecked(Node node, boolean isChecked) {
    node.setChecked(isChecked);
    if (!node.isLeaf()) {
      for (Node n : node.getChildrenNodes()) {
        // 所有子节点设置是否选择
        setChildrenNodeChecked(n, isChecked);
      }
    }
  }
  /**
   * 设置父节点选择
   * 
   * @param node
   */
  private static void setParentNodeChecked(Node node) {
    /** 非根节点 */
    if (!node.isRoot()) {
      Node rootNode = node.getParent();
      boolean isAllChecked = true;
      for (Node n : rootNode.getChildrenNodes()) {
        if (!n.isChecked()) {
          isAllChecked = false;
          break;
        }
      }
      if (isAllChecked) {
        rootNode.setChecked(true);
      } else {
        rootNode.setChecked(false);
      }
      setParentNodeChecked(rootNode);
    }
  }
}


文章标签：
Android开发
开发工具
关键词：
Android列表
Android树形
再见孙悟空_
目录
相关文章
热烈的马
|
5月前
|
XML Java Android开发
Android Studio App开发中改造已有的控件实战（包括自定义支付宝月份选择器、给翻页栏添加新属性、不滚动的列表视图 附源码）
Android Studio App开发中改造已有的控件实战（包括自定义支付宝月份选择器、给翻页栏添加新属性、不滚动的列表视图 附源码）
热烈的马
54 1
热烈的马
|
5月前
|
XML Java Android开发
Android Studio App开发之捕获屏幕的变更事件实战（包括竖屏与横屏切换，回到桌面与切换到任务列表）
Android Studio App开发之捕获屏幕的变更事件实战（包括竖屏与横屏切换，回到桌面与切换到任务列表）
热烈的马
45 0
热烈的马
|
5月前
|
XML Java Android开发
Android Studio App入门之列表视图ListView的讲解及实战（附源码 超详细必看）
Android Studio App入门之列表视图ListView的讲解及实战（附源码 超详细必看）
热烈的马
96 0
mrq4nk6ni2neg
|
1月前
|
存储 缓存 Android开发
构建高效的Android应用：采用RecyclerView优化列表显示
【4月更文挑战第2天】 在移动开发领域，列表显示是最常见的用户界面组件之一。对于Android平台而言，RecyclerView因其高效、灵活的特点而备受开发者青睐。本文将深入探讨如何利用RecyclerView在Android应用中实现流畅的列表滚动，以及通过各种优化策略来提升性能和用户体验。我们将从基本概念出发，逐步展开如何自定义适配器、视图持有者，以及利用布局管理器来实现复杂的列表布局。此外，还将讨论如何通过异步加载、缓存机制和动态数据更新来进一步优化性能。
mrq4nk6ni2neg
14 1
热烈的马
|
5月前
|
XML Java Android开发
Android Studio App开发之列表类视图中基本适配器BaseAdapter的使用及实战（附源码 超详细）
Android Studio App开发之列表类视图中基本适配器BaseAdapter的使用及实战（附源码 超详细）
热烈的马
54 0
路宇
|
9月前
|
Android开发
Android 根据时间的升序或降序把数据列表进行排序
Android 根据时间的升序或降序把数据列表进行排序
路宇
94 0
二流小码农
|
10月前
|
XML Java 数据处理
Android：RecyclerView封装，打造列表极简加载
此库的封装，除了刷新加载库使用了SmartRefreshLayout，其他的都是自己从0到1的开发，目前，自己已经在项目中使用，暂时没有出现任何问题，当然了，后续，也会不断的对其进行优化，增加一些其他的功能，希望有需要的小伙伴，长期关注。
二流小码农
241 0
唐子玄
|
12月前
|
Android开发
全网最优雅安卓列表项可见性检测
全网最优雅安卓列表项可见性检测
唐子玄
120 0
岁月不待人-祥
|
12月前
|
Android开发
Bug日志（四）——Android 防止多次点击（另解决多个列表子项点击）
在用户使用 应用的时候，经常会出现点击过快且多次点击同一控件的情况， 一方面这是因为应用或手机当前有些卡顿，网络卡啥的 另一方面也可能是由于很多应用并没有设置按钮点击时的 selector 或者其它按钮响应方式(例如点击按钮时按钮放大，常见于游戏)，导致用户误认为没有点击到当前按钮。（比如使用selector再点击后更换背景颜色，图片等等）
岁月不待人-祥
127 0
无影万事通
|
12月前
|
Android开发
无影产品动态｜Android客户端5.0.0版本发布，资源列表更清晰，交互触感更真实
一文读懂核心升级点
无影万事通
354 0

热门文章

最新文章

  • 1
    提升Android应用性能的实用技巧
  • 2
    我的Android之路(持续更新总结~)
  • 3
    Android实现自定义进度条(源码+解析)
  • 4
    安卓适配性策略：确保应用在不同设备上的兼容性
  • 5
    构建高效Android应用：探究Kotlin与Java的性能差异
  • 6
    安卓安全性指南：保护用户数据免受恶意攻击
  • 7
    Android系统 文件访问权限笔记
  • 8
    安卓多线程和并发处理：提高应用效率
  • 9
    安卓UI/UX设计原则：打造引人入胜的用户体验
  • 10
    构建高效Android应用：从优化用户体验到提升性能
  • 1
    【Android平板编程】远程Ubuntu服务器code-server编程写代码
    64
  • 2
    android 使用GSON 序列化对象出现字段被优化问题解决方案
    20
  • 3
    构建高效安卓应用：探究Kotlin与Java的性能对比
    100
  • 4
    构建高效安卓应用：探究Kotlin与Java的性能差异
    22
  • 5
    ADB 下载、安装及使用教程：让你更好地管理 Android 设备
    583
  • 6
    构建高效的安卓应用：探究Kotlin与Java的性能差异
    21
  • 7
    构建高效Android应用：探究Kotlin与Java的性能差异
    55
  • 8
    构建高效Android应用：探究Kotlin与Java的性能差异
    44
  • 9
    构建高效Android应用：探究Kotlin多线程编程
    51
  • 10
    构建高效Android应用：Kotlin协程的实践指南
    26

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）