Android 打造任意层级树形控件 考验你的数据结构和设计

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/40212367，本文出自：【张鸿洋的博客】

1、概述

大家在项目中或多或少的可能会见到，偶尔有的项目需要在APP上显示个树形控件，比如展示一个机构组织，最上面是boss，然后各种部门，各种小boss，最后各种小罗罗；整体是一个树形结构；遇到这样的情况，大家可能回去百度，因为层次多嘛，可能更容易想到ExpandableListView ， 因为这玩意层级比Listview多，但是ExpandableListView实现目前只支持两级，当然也有人改造成多级的；但是从我个人角度去看，首先我不喜欢ExpandableListView ，数据集的组织比较复杂。所以今天带大家使用ListView来打造一个树形展示效果。ListView应该是大家再熟悉不过的控件了，并且数据集也就是个List<T> 。

本篇博客目标实现，只要是符合树形结构的数据可以轻松的通过我们的代码，实现树形效果，有多轻松，文末就知道了~~

好了，既然是要展现树形结构，那么数据上肯定就是树形的一个依赖，也就是说，你的每条记录，至少有个字段指向它的父节点；类似（id , pId, others ....）

2、原理分析

先看看我们的效果图：

我们支持任意层级，包括item的布局依然让用户自己的去控制，我们的demo的Item布局很简单，一个图标+文本~~

原理就是，树形不树形，其实不就是多个缩进么，只要能够判断每个item属于树的第几层（术语貌似叫高度），设置合适的缩进即可。

当然了，原理说起来简单，还得控制每一层间关系，添加展开缩回等，以及有了缩进还要能显示在正确的位置，不过没关系，我会带着大家一步一步实现的。

3、用法

由于整体比较长，我决定首先带大家看一下用法，就是如果学完了这篇博客，我们需要树形控件，我们需要花多少精力去完成~~

现在需求来了：我现在需要展示一个文件管理系统的树形结构：

数据是这样的：

[html] view plaincopy

  1. //id , pid , label , 其他属性
  2. mDatas.add(new FileBean(1, 0, "文件管理系统"));
  3. mDatas.add(new FileBean(2, 1, "游戏"));
  4. mDatas.add(new FileBean(3, 1, "文档"));
  5. mDatas.add(new FileBean(4, 1, "程序"));
  6. mDatas.add(new FileBean(5, 2, "war3"));
  7. mDatas.add(new FileBean(6, 2, "刀塔传奇"));
  8. mDatas.add(new FileBean(7, 4, "面向对象"));
  9. mDatas.add(new FileBean(8, 4, "非面向对象"));
  10. mDatas.add(new FileBean(9, 7, "C++"));
  11. mDatas.add(new FileBean(10, 7, "JAVA"));
  12. mDatas.add(new FileBean(11, 7, "Javascript"));
  13. mDatas.add(new FileBean(12, 8, "C"));

当然了，bean可以有很多属性，我们提供你动态的设置树节点上的显示、以及不约束id, pid 的命名，你可以起任意丧心病狂的属性名称；

那么我们如何确定呢？

看下Bean:

[java] view plaincopy

  1. package com.zhy.bean;
  2. import com.zhy.tree.bean.TreeNodeId;
  3. import com.zhy.tree.bean.TreeNodeLabel;
  4. import com.zhy.tree.bean.TreeNodePid;
  5. public class FileBean
  6. {
  7. @TreeNodeId
  8. private int _id;
  9. @TreeNodePid
  10. private int parentId;
  11. @TreeNodeLabel
  12. private String name;
  13. private long length;
  14. private String desc;
  15. public FileBean(int _id, int parentId, String name)
  16. {
  17. super();
  18. this._id = _id;
  19. this.parentId = parentId;
  20. this.name = name;
  21. }
  22. }

现在，不用说，应该也知道我们通过注解来确定的。

下面看我们如何将这数据转化为树

布局文件就一个listview，就补贴了，直接看Activity

[java] view plaincopy

  1. package com.zhy.tree_view;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import android.app.Activity;
  5. import android.os.Bundle;
  6. import android.widget.ListView;
  7. import com.zhy.bean.FileBean;
  8. import com.zhy.tree.bean.TreeListViewAdapter;
  9. public class MainActivity extends Activity
  10. {
  11. private List<FileBean> mDatas = new ArrayList<FileBean>();
  12. private ListView mTree;
  13. private TreeListViewAdapter mAdapter;
  14. @Override
  15. protected void onCreate(Bundle savedInstanceState)
  16. {
  17. super.onCreate(savedInstanceState);
  18. setContentView(R.layout.activity_main);
  19. initDatas();
  20. mTree = (ListView) findViewById(R.id.id_tree);
  21. try
  22. {
  23. mAdapter = new SimpleTreeAdapter<FileBean>(mTree, this, mDatas, 10);
  24. mTree.setAdapter(mAdapter);
  25. } catch (IllegalAccessException e)
  26. {
  27. e.printStackTrace();
  28. }
  29. }
  30. private void initDatas()
  31. {
  32. // id , pid , label , 其他属性
  33. mDatas.add(new FileBean(1, 0, "文件管理系统"));
  34. mDatas.add(new FileBean(2, 1, "游戏"));
  35. mDatas.add(new FileBean(3, 1, "文档"));
  36. mDatas.add(new FileBean(4, 1, "程序"));
  37. mDatas.add(new FileBean(5, 2, "war3"));
  38. mDatas.add(new FileBean(6, 2, "刀塔传奇"));
  39. mDatas.add(new FileBean(7, 4, "面向对象"));
  40. mDatas.add(new FileBean(8, 4, "非面向对象"));
  41. mDatas.add(new FileBean(9, 7, "C++"));
  42. mDatas.add(new FileBean(10, 7, "JAVA"));
  43. mDatas.add(new FileBean(11, 7, "Javascript"));
  44. mDatas.add(new FileBean(12, 8, "C"));
  45. }
  46. }

Activity里面并没有什么特殊的代码，拿到listview，传入mData，当中初始化了一个Adapter；

看来我们的核心代码都在我们的Adapter里面：

那么看一眼我们的Adapter

[java] view plaincopy

  1. package com.zhy.tree_view;
  2. import java.util.List;
  3. import android.content.Context;
  4. import android.view.View;
  5. import android.view.ViewGroup;
  6. import android.widget.ImageView;
  7. import android.widget.ListView;
  8. import android.widget.TextView;
  9. import com.zhy.tree.bean.Node;
  10. import com.zhy.tree.bean.TreeListViewAdapter;
  11. public class SimpleTreeAdapter<T> extends TreeListViewAdapter<T>
  12. {
  13. public SimpleTreeAdapter(ListView mTree, Context context, List<T> datas,
  14. int defaultExpandLevel) throws IllegalArgumentException,
  15. IllegalAccessException
  16. {
  17. super(mTree, context, datas, defaultExpandLevel);
  18. }
  19. @Override
  20. public View getConvertView(Node node , int position, View convertView, ViewGroup parent)
  21. {
  22. ViewHolder viewHolder = null;
  23. if (convertView == null)
  24. {
  25. convertView = mInflater.inflate(R.layout.list_item, parent, false);
  26. viewHolder = new ViewHolder();
  27. viewHolder.icon = (ImageView) convertView
  28. .findViewById(R.id.id_treenode_icon);
  29. viewHolder.label = (TextView) convertView
  30. .findViewById(R.id.id_treenode_label);
  31. convertView.setTag(viewHolder);
  32. } else
  33. {
  34. viewHolder = (ViewHolder) convertView.getTag();
  35. }
  36. if (node.getIcon() == -1)
  37. {
  38. viewHolder.icon.setVisibility(View.INVISIBLE);
  39. } else
  40. {
  41. viewHolder.icon.setVisibility(View.VISIBLE);
  42. viewHolder.icon.setImageResource(node.getIcon());
  43. }
  44. viewHolder.label.setText(node.getName());
  45. return convertView;
  46. }
  47. private final class ViewHolder
  48. {
  49. ImageView icon;
  50. TextView label;
  51. }
  52. }

我们的SimpleTreeAdapter继承了我们的TreeListViewAdapter ； 除此之外，代码上只需要复写getConvertView ， 且getConvetView其实和我们平时的getView写法一致；

公布出getConvertView 的目的是，让用户自己去决定Item的展示效果。其他的代码，我已经打包成jar了，用的时候导入即可。这样就完成了我们的树形控件。

也就是说用我们的树形控件，只需要将传统继承BaseAdapter改为我们的TreeListViewAdapter ，然后去实现getConvertView 就好了。

那么现在的效果是：

默认就全打开了，因为我们也支持动态设置打开的层级，方面使用者使用。

用起来是不是很随意，加几个注解，ListView的Adapater换个类继承下~~好了，下面开始带大家一起从无到有的实现~

4、实现

1、思路

我们的思路是这样的，我们显示时，需要很多属性，我们需要知道当前节点是否是父节点，当前的层级，他的孩子节点等等；但是用户的数据集是不固定的，最多只能给出类似id，pId 这样的属性。也就是说，用户给的bean并不适合我们用于控制显示，于是我们准备这样做：

1、在用户的Bean中提取出必要的几个元素 id , pId , 以及显示的文本（通过注解+反射）；然后组装成我们的真正显示时的Node；即List<Bean> -> List<Node>

2、显示的并非是全部的Node，比如某些节点的父节点是关闭状态，我们需要进行过滤；即List<Node> ->过滤后的List<Node>

3、显示时，比如点击父节点，它的子节点会跟随其后显示，我们内部是个List，也就是说，这个List的顺序也是很关键的；当然排序我们可以放为步骤一；

最后将过滤后的Node进行显示，设置左内边距即可。

说了这么多，首先看一眼我们封装后的Node

2、Node

[java] view plaincopy

  1. package com.zhy.tree.bean;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import org.w3c.dom.NamedNodeMap;
  5. import android.util.Log;
  6. public class Node
  7. {
  8. private int id;
  9. /**
  10. * 根节点pId为0
  11. */
  12. private int pId = 0;
  13. private String name;
  14. /**
  15. * 当前的级别
  16. */
  17. private int level;
  18. /**
  19. * 是否展开
  20. */
  21. private boolean isExpand = false;
  22. private int icon;
  23. /**
  24. * 下一级的子Node
  25. */
  26. private List<Node> children = new ArrayList<Node>();
  27. /**
  28. * 父Node
  29. */
  30. private Node parent;
  31. public Node()
  32. {
  33. }
  34. public Node(int id, int pId, String name)
  35. {
  36. super();
  37. this.id = id;
  38. this.pId = pId;
  39. this.name = name;
  40. }
  41. public int getIcon()
  42. {
  43. return icon;
  44. }
  45. public void setIcon(int icon)
  46. {
  47. this.icon = icon;
  48. }
  49. public int getId()
  50. {
  51. return id;
  52. }
  53. public void setId(int id)
  54. {
  55. this.id = id;
  56. }
  57. public int getpId()
  58. {
  59. return pId;
  60. }
  61. public void setpId(int pId)
  62. {
  63. this.pId = pId;
  64. }
  65. public String getName()
  66. {
  67. return name;
  68. }
  69. public void setName(String name)
  70. {
  71. this.name = name;
  72. }
  73. public void setLevel(int level)
  74. {
  75. this.level = level;
  76. }
  77. public boolean isExpand()
  78. {
  79. return isExpand;
  80. }
  81. public List<Node> getChildren()
  82. {
  83. return children;
  84. }
  85. public void setChildren(List<Node> children)
  86. {
  87. this.children = children;
  88. }
  89. public Node getParent()
  90. {
  91. return parent;
  92. }
  93. public void setParent(Node parent)
  94. {
  95. this.parent = parent;
  96. }
  97. /**
  98. * 是否为跟节点
  99. *
  100. * @return
  101. */
  102. public boolean isRoot()
  103. {
  104. return parent == null;
  105. }
  106. /**
  107. * 判断父节点是否展开
  108. *
  109. * @return
  110. */
  111. public boolean isParentExpand()
  112. {
  113. if (parent == null)
  114. return false;
  115. return parent.isExpand();
  116. }
  117. /**
  118. * 是否是叶子界点
  119. *
  120. * @return
  121. */
  122. public boolean isLeaf()
  123. {
  124. return children.size() == 0;
  125. }
  126. /**
  127. * 获取level
  128. */
  129. public int getLevel()
  130. {
  131. return parent == null ? 0 : parent.getLevel() + 1;
  132. }
  133. /**
  134. * 设置展开
  135. *
  136. * @param isExpand
  137. */
  138. public void setExpand(boolean isExpand)
  139. {
  140. this.isExpand = isExpand;
  141. if (!isExpand)
  142. {
  143. for (Node node : children)
  144. {
  145. node.setExpand(isExpand);
  146. }
  147. }
  148. }
  149. }

包含了树节点一些常见的属性，一些常见的方法；对于getLevel，setExpand这些方法，大家可以好好看看~

有了Node，刚才的用法中，出现的就是我们Adapter所继承的超类：TreeListViewAdapter；核心代码都在里面，我们准备去一探究竟：

3、TreeListViewAdapter

代码不是很长，直接完整的贴出：

[java] view plaincopy

  1. package com.zhy.tree.bean;
  2. import java.util.List;
  3. import android.content.Context;
  4. import android.view.LayoutInflater;
  5. import android.view.View;
  6. import android.view.ViewGroup;
  7. import android.widget.AdapterView;
  8. import android.widget.AdapterView.OnItemClickListener;
  9. import android.widget.BaseAdapter;
  10. import android.widget.ListView;
  11. public abstract class TreeListViewAdapter<T> extends BaseAdapter
  12. {
  13. protected Context mContext;
  14. /**
  15. * 存储所有可见的Node
  16. */
  17. protected List<Node> mNodes;
  18. protected LayoutInflater mInflater;
  19. /**
  20. * 存储所有的Node
  21. */
  22. protected List<Node> mAllNodes;
  23. /**
  24. * 点击的回调接口
  25. */
  26. private OnTreeNodeClickListener onTreeNodeClickListener;
  27. public interface OnTreeNodeClickListener
  28. {
  29. void onClick(Node node, int position);
  30. }
  31. public void setOnTreeNodeClickListener(
  32. OnTreeNodeClickListener onTreeNodeClickListener)
  33. {
  34. this.onTreeNodeClickListener = onTreeNodeClickListener;
  35. }
  36. /**
  37. *
  38. * @param mTree
  39. * @param context
  40. * @param datas
  41. * @param defaultExpandLevel
  42. *            默认展开几级树
  43. * @throws IllegalArgumentException
  44. * @throws IllegalAccessException
  45. */
  46. public TreeListViewAdapter(ListView mTree, Context context, List<T> datas,
  47. int defaultExpandLevel) throws IllegalArgumentException,
  48. IllegalAccessException
  49. {
  50. mContext = context;
  51. /**
  52. * 对所有的Node进行排序
  53. */
  54. mAllNodes = TreeHelper.getSortedNodes(datas, defaultExpandLevel);
  55. /**
  56. * 过滤出可见的Node
  57. */
  58. mNodes = TreeHelper.filterVisibleNode(mAllNodes);
  59. mInflater = LayoutInflater.from(context);
  60. /**
  61. * 设置节点点击时，可以展开以及关闭；并且将ItemClick事件继续往外公布
  62. */
  63. mTree.setOnItemClickListener(new OnItemClickListener()
  64. {
  65. @Override
  66. public void onItemClick(AdapterView<?> parent, View view,
  67. int position, long id)
  68. {
  69. expandOrCollapse(position);
  70. if (onTreeNodeClickListener != null)
  71. {
  72. onTreeNodeClickListener.onClick(mNodes.get(position),
  73. position);
  74. }
  75. }
  76. });
  77. }
  78. /**
  79. * 相应ListView的点击事件 展开或关闭某节点
  80. *
  81. * @param position
  82. */
  83. public void expandOrCollapse(int position)
  84. {
  85. Node n = mNodes.get(position);
  86. if (n != null)// 排除传入参数错误异常
  87. {
  88. if (!n.isLeaf())
  89. {
  90. n.setExpand(!n.isExpand());
  91. mNodes = TreeHelper.filterVisibleNode(mAllNodes);
  92. notifyDataSetChanged();// 刷新视图
  93. }
  94. }
  95. }
  96. @Override
  97. public int getCount()
  98. {
  99. return mNodes.size();
  100. }
  101. @Override
  102. public Object getItem(int position)
  103. {
  104. return mNodes.get(position);
  105. }
  106. @Override
  107. public long getItemId(int position)
  108. {
  109. return position;
  110. }
  111. @Override
  112. public View getView(int position, View convertView, ViewGroup parent)
  113. {
  114. Node node = mNodes.get(position);
  115. convertView = getConvertView(node, position, convertView, parent);
  116. // 设置内边距
  117. convertView.setPadding(node.getLevel() * 30, 3, 3, 3);
  118. return convertView;
  119. }
  120. public abstract View getConvertView(Node node, int position,
  121. View convertView, ViewGroup parent);
  122. }

首先我们的类继承自BaseAdapter，然后我们对应的数据集是，过滤出的可见的Node；

我们的构造方法默认接收4个参数：listview,context,mdatas,以及默认展开的级数：0只显示根节点；

可以在构造方法中看到：对用户传入的数据集做了排序，和过滤的操作；一会再看这些方法，这些方法我们使用了一个TreeHelper进行了封装。

注：如果你觉得你的Item布局十分复杂，且布局会展示Bean的其他数据，那么为了方便，你可以让Node中包含一个泛型T ， 每个Node携带与之对于的Bean的所有数据；

可以看到我们还直接为Item设置了点击事件，因为我们树，默认就有点击父节点展开与关闭；但是为了让用户依然可用点击监听，我们自定义了一个点击的回调供用户使用；

当用户点击时，默认调用expandOrCollapse方法，将当然节点重置展开标志，然后重新过滤出可见的Node，最后notifyDataSetChanged即可；

其他的方法都是BaseAdapter默认的一些方法了。

下面我们看下TreeHelper中的一些方法：

4、TreeHelper

首先看TreeListViewAdapter构造方法中用到的两个方法：

[java] view plaincopy

  1. /**
  2. * 传入我们的普通bean，转化为我们排序后的Node
  3. * @param datas
  4. * @param defaultExpandLevel
  5. * @return
  6. * @throws IllegalArgumentException
  7. * @throws IllegalAccessException
  8. */
  9. public static <T> List<Node> getSortedNodes(List<T> datas,
  10. int defaultExpandLevel) throws IllegalArgumentException,
  11. IllegalAccessException
  12. {
  13. List<Node> result = new ArrayList<Node>();
  14. //将用户数据转化为List<Node>以及设置Node间关系
  15. List<Node> nodes = convetData2Node(datas);
  16. //拿到根节点
  17. List<Node> rootNodes = getRootNodes(nodes);
  18. //排序
  19. for (Node node : rootNodes)
  20. {
  21. addNode(result, node, defaultExpandLevel, 1);
  22. }
  23. return result;
  24. }

拿到用户传入的数据，转化为List<Node>以及设置Node间关系，然后根节点，从根往下遍历进行排序；

接下来看：filterVisibleNode

[java] view plaincopy

  1. /**
  2. * 过滤出所有可见的Node
  3. *
  4. * @param nodes
  5. * @return
  6. */
  7. public static List<Node> filterVisibleNode(List<Node> nodes)
  8. {
  9. List<Node> result = new ArrayList<Node>();
  10. for (Node node : nodes)
  11. {
  12. // 如果为跟节点，或者上层目录为展开状态
  13. if (node.isRoot() || node.isParentExpand())
  14. {
  15. setNodeIcon(node);
  16. result.add(node);
  17. }
  18. }
  19. return result;
  20. }

过滤Node的代码很简单，遍历所有的Node，只要是根节点或者父节点是展开状态就添加返回；

最后看看这两个方法用到的别的一些私有方法：

[java] view plaincopy

  1. /**
  2. * 将我们的数据转化为树的节点
  3. *
  4. * @param datas
  5. * @return
  6. * @throws NoSuchFieldException
  7. * @throws IllegalAccessException
  8. * @throws IllegalArgumentException
  9. */
  10. private static <T> List<Node> convetData2Node(List<T> datas)
  11. throws IllegalArgumentException, IllegalAccessException
  12. {
  13. List<Node> nodes = new ArrayList<Node>();
  14. Node node = null;
  15. for (T t : datas)
  16. {
  17. int id = -1;
  18. int pId = -1;
  19. String label = null;
  20. Class<? extends Object> clazz = t.getClass();
  21. Field[] declaredFields = clazz.getDeclaredFields();
  22. for (Field f : declaredFields)
  23. {
  24. if (f.getAnnotation(TreeNodeId.class) != null)
  25. {
  26. f.setAccessible(true);
  27. id = f.getInt(t);
  28. }
  29. if (f.getAnnotation(TreeNodePid.class) != null)
  30. {
  31. f.setAccessible(true);
  32. pId = f.getInt(t);
  33. }
  34. if (f.getAnnotation(TreeNodeLabel.class) != null)
  35. {
  36. f.setAccessible(true);
  37. label = (String) f.get(t);
  38. }
  39. if (id != -1 && pId != -1 && label != null)
  40. {
  41. break;
  42. }
  43. }
  44. node = new Node(id, pId, label);
  45. nodes.add(node);
  46. }
  47. /**
  48. * 设置Node间，父子关系;让每两个节点都比较一次，即可设置其中的关系
  49. */
  50. for (int i = 0; i < nodes.size(); i++)
  51. {
  52. Node n = nodes.get(i);
  53. for (int j = i + 1; j < nodes.size(); j++)
  54. {
  55. Node m = nodes.get(j);
  56. if (m.getpId() == n.getId())
  57. {
  58. n.getChildren().add(m);
  59. m.setParent(n);
  60. } else if (m.getId() == n.getpId())
  61. {
  62. m.getChildren().add(n);
  63. n.setParent(m);
  64. }
  65. }
  66. }
  67. // 设置图片
  68. for (Node n : nodes)
  69. {
  70. setNodeIcon(n);
  71. }
  72. return nodes;
  73. }
  74. private static List<Node> getRootNodes(List<Node> nodes)
  75. {
  76. List<Node> root = new ArrayList<Node>();
  77. for (Node node : nodes)
  78. {
  79. if (node.isRoot())
  80. root.add(node);
  81. }
  82. return root;
  83. }
  84. /**
  85. * 把一个节点上的所有的内容都挂上去
  86. */
  87. private static void addNode(List<Node> nodes, Node node,
  88. int defaultExpandLeval, int currentLevel)
  89. {
  90. nodes.add(node);
  91. if (defaultExpandLeval >= currentLevel)
  92. {
  93. node.setExpand(true);
  94. }
  95. if (node.isLeaf())
  96. return;
  97. for (int i = 0; i < node.getChildren().size(); i++)
  98. {
  99. addNode(nodes, node.getChildren().get(i), defaultExpandLeval,
  100. currentLevel + 1);
  101. }
  102. }
  103. /**
  104. * 设置节点的图标
  105. *
  106. * @param node
  107. */
  108. private static void setNodeIcon(Node node)
  109. {
  110. if (node.getChildren().size() > 0 && node.isExpand())
  111. {
  112. node.setIcon(R.drawable.tree_ex);
  113. } else if (node.getChildren().size() > 0 && !node.isExpand())
  114. {
  115. node.setIcon(R.drawable.tree_ec);
  116. } else
  117. node.setIcon(-1);
  118. }

convetData2Node即遍历用户传入的Bean，转化为Node，其中Id，pId，label通过注解加反射获取；然后设置Node间关系；

getRootNodes 这个简单，获得根节点

addNode ：通过递归的方式，把一个节点上的所有的子节点等都按顺序放入；

setNodeIcon ：设置图标，这里标明，我们的jar还依赖两个小图标，即两个三角形；如果你觉得树不需要这样的图标，可以去掉；

5、注解的类

最后就是我们的3个注解类了，没撒用，就启到一个标识的作用

TreeNodeId

[java] view plaincopy

  1. package com.zhy.tree.bean;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6. @Target(ElementType.FIELD)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface TreeNodeId
  9. {
  10. }

TreeNodePid

[java] view plaincopy

  1. package com.zhy.tree.bean;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6. @Target(ElementType.FIELD)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface TreeNodePid
  9. {
  10. }

TreeNodeLabel

[java] view plaincopy

  1. package com.zhy.tree.bean;
  2. import java.lang.annotation.ElementType;
  3. import java.lang.annotation.Retention;
  4. import java.lang.annotation.RetentionPolicy;
  5. import java.lang.annotation.Target;
  6. @Target(ElementType.FIELD)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface TreeNodeLabel
  9. {
  10. }

5、最后的展望

基于上面的例子，我们还有很多地方可以改善，下面我提一下：

1、Item的布局依赖很多Bean的属性，在Node中使用泛型存储与之对应的Bean，这样在getConvertView中就可以通过Node获取到原本的Bean数据了；

2、关于自定义或者不要三角图标；可以让TreeListViewAdapter公布出设置图标的方法，Node全部使用TreeListViewAdapter中设置的图标；关于不显示，直接getConverView里面不管就行了；

3、我们通过注解得到的Id ,pId , label ； 如果嫌慢，可以通过回调的方式进行获取；我们遍历的时候，去通过Adapter中定义类似：abstract int getId(T t) ；将t作为参数，让用户返回id ，类似还有 pid ，label ；这样循环的代码需要从ViewHelper提取到Adapter构造方法中；

4、关于设置包含复选框，选择了多个Node，不要保存position完事，去保存Node中的Id即原Bean的主键；然后在getConvertView中对Id进行对比，防止错乱；

5、关于注解，目前注解只启到了标识的左右；其实还能干很多事，比如默认我们任务用户的id , pid是整形，但是有可能是别的类型；我们可以通过在注解中设置方法来确定，例如：

[java] view plaincopy

  1. @Target(ElementType.FIELD)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface TreeNodeId
  4. {
  5. Class type() ;
  6. }

[java] view plaincopy

  1. @TreeNodeId(type = Integer.class)
  2. private int _id;

当然了，如果你的需求没有上述修改的需要，就不需要折腾了~~

到此，我们整个博客就结束了~~设计中如果存在不足，大家可以自己去改善；希望大家通过本博客学习到的不仅是一个例子如何实现，更多的是如何设计；当然鄙人能力有限，请大家自行去其糟粕；

源码点击下载（已经打成jar）

源码点击下载（未打成jar版）

时间： 2024-11-05 13:50:37

Android 打造任意层级树形控件 考验你的数据结构和设计的相关文章

Android 打造任意层级树形控件 考验你的数据结构和设计

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/40212367,本文出自:[张鸿洋的博客] 1.概述 大家在项目中或多或少的可能会见到,偶尔有的项目需要在APP上显示个树形控件,比如展示一个机构组织,最上面是boss,然后各种部门,各种小boss,最后各种小罗罗:整体是一个树形结构:遇到这样的情况,大家可能回去百度,因为层次多嘛,可能更容易想到ExpandableListView , 因为这玩意层级比Listview多,但是E

Android 打造随意层级树形控件 考验你的数据结构和设计

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/40212367,本文出自:[张鸿洋的博客] 1.概述 大家在项目中或多或少的可能会见到,偶尔有的项目须要在APP上显示个树形控件,比方展示一个机构组织,最上面是boss.然后各种部门.各种小boss,最后各种小罗罗.总体是一个树形结构.遇到这种情况,大家可能回去百度.由于层次多嘛,可能更easy想到ExpandableListView , 由于这玩意层级比Listview多.可是

Android打造万能自定义阴影控件

目录介绍 01.阴影效果有哪些实现方式 02.实现阴影效果Api 03.设置阴影需要注意哪些 04.常见Shape实现阴影效果 05.自定义阴影效果控件 06.如何使用该阴影控件 07.在recyclerView中使用注意点 01.阴影效果有哪些实现方式 阴影效果有哪些实现方式 第一种:使用CardView,但是不能设置阴影颜色 第二种:采用shape叠加,存在后期UI效果不便优化 第三种:UI切图 第四种:自定义View 否定上面前两种方案原因分析? 第一个方案的CardView渐变色和阴影效

js树形控件—zTree使用总结(转载)

0 zTree简介 树形控件的使用是应用开发过程中必不可少的.zTree 是一个依靠 jQuery 实现的多功能 “树插件”.优异的性能.灵活的配置.多种功能的组合是 zTree 最大优点. 0.0 zTree的特点 最新版的zTree将核心代码按照功能进行了分割,不需要的代码可以不用加载,如普通使用只需要加载核心的jquery.ztree.core-3.5.js,需要使用勾选功能加载jquery.ztree.excheck-3.5.min.js,需要使用编辑功能加载jquery.ztree.e

共有21款 jQuery 树形控件开源软件，第1页

JQuery Tree 插件 zTree zTree 是利用 JQuery 的核心代码,实现一套能完成大部分常用功能的 Tree 插件 兼容 IE.FireFox.Chrome 等浏览器 在一个页面内可同时生成多个 Tree 实例 支持 JSON 数据 支持一次性静态生成 和 Ajax 异步加载 两种方式 支持多种事件响应及反馈 支持 Tree...更多zTree信息 最近更新: [每日一博]Ztree+PHP 无限极节点递归查找节点 发布于 1年前 jQuery的Tree控件 jstree j

基于Bootstrap的JQuery TreeView树形控件，数据支持json字符串、list集合（MVC5）

BZ第一次自己写博客,心情好激动!!BZ也是小菜,本文如果有什么不对的地方,希望大神们多多指教,也希望和我一样的小菜多多学习.BZ在这里谢过各位. BZ最近看了很多博友的有关TreeView的博客,发现很多都是WebForm.JQuery的.因为BZ使用的是MVC的原因,所以决定写一写关于MVC和Bootstrap的TreeView. PS:基于Bootstrap的JQuery TreeView树形控件,JQuery版本为2.1.1(下载网上的基于Bootstrap的JQuery TreeVie

Qt树形控件QTreeView使用1——节点的添加删除操作 复选框的设置

QtreeView是ui中最常用的控件,Qt中QTreeWidget比QTreeView更简单,但没有QTreeView那么灵活(QTreeWidget封装的和MFC的CTreeCtrl很类似,没有mvc的特点). 1. QStandardItemModel在QTreeView中的使用 使用QTreeView的对应模型是QStandardItemModel,这个是Qt对应ui界面最有用的模型,它可以用于树形控件.列表控件.表格控件等等和条目有关的控件.QStandardItemModel用于列表

树形控件QTreeWidget

1 import sys 2 from PyQt5.QtCore import Qt 3 from PyQt5.QtWidgets import QApplication, QWidget, QTreeWidget, QTreeWidgetItem, QLabel, QHBoxLayout 4 5 6 class Demo(QWidget): 7 def __init__(self): 8 super(Demo, self).__init__() 9 self.resize(500, 300)

win32 sdk树形控件的项拖拽实现

本课中,我们将学习如何使用树型视图控件.另外还要学习如何在树型视图中完成拖-拉动作,以及如何使用图象列表. 理论: 树型视图是一种特别的窗口,我们可以使用它一目了然地表示某种层次关系.譬如象在资源管理器中左边窗口中的就是树型视图.您可以调用CreateWindowEx来创建树型视图,传递一个类名""SysTreeView32"",或者您也可以把它放到一个对话框中去.不要忘了在您的代码中加入InitCommonControls函数. 树型视图有几种特有的风格.下面是几