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

31. private int icon;

32. /**

33. * 下一级的子Node

34. */

35. private List children = new ArrayList();

36. /**

37. * 父Node

38. */

39. private Node parent;

40. public Node()

41. {

42. }

43. public Node(int id, int pId, String name)

44. {

45. super();

46. this.id = id;

47. this.pId = pId;

48. this.name = name;

49. }

50. public int getIcon()

51. {

52. return icon;

53. }

54. public void setIcon(int icon)

55. {

56. this.icon = icon;

57. }

58. public int getId()

59. {

60. return id;

61. }

62. public void setId(int id)

63. {

64. this.id = id;

65. }

66. public int getpId()

67. {

68. return pId;

69. }

70. public void setpId(int pId)

71. {

72. this.pId = pId;

73. }

74. public String getName()

75. {

76. return name;

77. }

78. public void setName(String name)

79. {

80. this.name = name;

81. }

82. public void setLevel(int level)

83. {

84. this.level = level;

85. }

86. public boolean isExpand()

87. {

88. return isExpand;

89. }

90. public List getChildren()

91. {

92. return children;

93. }

94. public void setChildren(List children)

95. {

96. this.children = children;

97. }

98. public Node getParent()

99. {

100. return parent;

101. }

102. public void setParent(Node parent)

103. {

104. this.parent = parent;

105. }

106. /**

107. * 是否为跟节点

108. *

109. * @return

110. */

111. public boolean isRoot()

112. {

113. return parent == null;

114. }

115. /**

116. * 判断父节点是否展开

117. *

118. * @return

119. */

120. public boolean isParentExpand()

121. {

122. if (parent == null)

123. return false;

124. return parent.isExpand();

125. }

126. /**

127. * 是否是叶子界点

128. *

129. * @return

130. */

131. public boolean isLeaf()

132. {

133. return children.size() == 0;

134. }

135. /**

136. * 获取level

137. */

138. public int getLevel()

139. {

140. return parent == null ? 0 : parent.getLevel() + 1;

141. }

142. /**

143. * 设置展开

144. *

145. * @param isExpand

146. */

147. public void setExpand(boolean isExpand)

148. {

149. this.isExpand = isExpand;

150. if (!isExpand)

151. {

152. for (Node node : children)

153. {

154. node.setExpand(isExpand);

155. }

156. }

157. }

158. }

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

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

3、TreeListViewAdapter

---

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

[java]  view plain copy

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 extends BaseAdapter

12. {

13. protected Context mContext;

14. /**

15. * 存储所有可见的Node

16. */

17. protected List mNodes;

18. protected LayoutInflater mInflater;

19. /**

20. * 存储所有的Node

21. */

22. protected List 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 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 plain copy

1. /**

2. * 传入我们的普通bean，转化为我们排序后的Node

3. * @param datas

4. * @param defaultExpandLevel

5. * @return

6. * @throws IllegalArgumentException

7. * @throws IllegalAccessException

8. */

9. public static  List getSortedNodes(List datas,

10. int defaultExpandLevel) throws IllegalArgumentException,

11. IllegalAccessException

12. {

13. List result = new ArrayList();

14. //将用户数据转化为List以及设置Node间关系

15. List nodes = convetData2Node(datas);

16. //拿到根节点

17. List rootNodes = getRootNodes(nodes);

18. //排序

19. for (Node node : rootNodes)

20. {

21. addNode(result, node, defaultExpandLevel, 1);

22. }

23. return result;

24. }

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

接下来看：filterVisibleNode

[java]  view plain copy

1. /**

2. * 过滤出所有可见的Node

3. *

4. * @param nodes

5. * @return

6. */

7. public static List filterVisibleNode(List nodes)

8. {

9. List result = new ArrayList();

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 plain copy

1. /**

2. * 将我们的数据转化为树的节点

3. *

4. * @param datas

5. * @return

6. * @throws NoSuchFieldException

7. * @throws IllegalAccessException

8. * @throws IllegalArgumentException

9. */

10. private static  List convetData2Node(List datas)

11. throws IllegalArgumentException, IllegalAccessException

12. {

13. List nodes = new ArrayList();

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)

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）

最后我还整理了很多Android中高级的PDF技术文档。以及一些大厂面试真题解析文档。需要的朋友都可以点击GitHub直接获取方式

Android高级架构师之路很漫长，一起共勉吧！

{

65. m.getChildren().add(n);

66. n.setParent(m);

67. }

68. }

69. }

70. // 设置图片

71. for (Node n : nodes)

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-SHBgkaIE-1711043890923)]
[外链图片转存中…(img-guNNfH9b-1711043890924)]
[外链图片转存中…(img-gYYUWQx4-1711043890924)]
[外链图片转存中…(img-Jd9b3NFG-1711043890925)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）
[外链图片转存中…(img-4gzeH7vF-1711043890926)]

最后我还整理了很多Android中高级的PDF技术文档。以及一些大厂面试真题解析文档。需要的朋友都可以点击GitHub直接获取方式

[外链图片转存中…(img-vXtxK05C-1711043890927)]

Android高级架构师之路很漫长，一起共勉吧！