码迷,mamicode.com
首页 > 移动开发 > 详细

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

时间:2015-01-30 15:17:30      阅读:284      评论:0      收藏:0      [点我收藏+]

标签:

转载请标明出处: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.   
  9.         mDatas.add(new FileBean(7, 4, "面向对象"));  
  10.         mDatas.add(new FileBean(8, 4, "非面向对象"));  
  11.   
  12.         mDatas.add(new FileBean(9, 7, "C++"));  
  13.         mDatas.add(new FileBean(10, 7, "JAVA"));  
  14.         mDatas.add(new FileBean(11, 7, "Javascript"));  
  15.         mDatas.add(new FileBean(12, 8, "C"));  


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

 

那么我们如何确定呢?

看下Bean:

 

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


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

 

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

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

 

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


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

 

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

那么看一眼我们的Adapter

 

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


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


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

 

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

3、TreeListViewAdapter

代码不是很长,直接完整的贴出:

 

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


首先我们的类继承自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.     {  
  14.         List<Node> result = new ArrayList<Node>();  
  15.         //将用户数据转化为List<Node>以及设置Node间关系  
  16.         List<Node> nodes = convetData2Node(datas);  
  17.         //拿到根节点  
  18.         List<Node> rootNodes = getRootNodes(nodes);  
  19.         //排序  
  20.         for (Node node : rootNodes)  
  21.         {  
  22.             addNode(result, node, defaultExpandLevel, 1);  
  23.         }  
  24.         return result;  
  25.     }  


拿到用户传入的数据,转化为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.   
  11.         for (Node node : nodes)  
  12.         {  
  13.             // 如果为跟节点,或者上层目录为展开状态  
  14.             if (node.isRoot() || node.isParentExpand())  
  15.             {  
  16.                 setNodeIcon(node);  
  17.                 result.add(node);  
  18.             }  
  19.         }  
  20.         return result;  
  21.     }  


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


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

 

getRootNodes 这个简单,获得根节点

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

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

 

5、注解的类

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

TreeNodeId

 

[java] view plaincopy技术分享技术分享
 
  1. package com.zhy.tree.bean;  
  2.   
  3. import java.lang.annotation.ElementType;  
  4. import java.lang.annotation.Retention;  
  5. import java.lang.annotation.RetentionPolicy;  
  6. import java.lang.annotation.Target;  
  7.   
  8. @Target(ElementType.FIELD)  
  9. @Retention(RetentionPolicy.RUNTIME)  
  10. public @interface TreeNodeId  
  11. {  
  12. }  

 

 

TreeNodePid

 

[java] view plaincopy技术分享技术分享
 
  1. package com.zhy.tree.bean;  
  2.   
  3. import java.lang.annotation.ElementType;  
  4. import java.lang.annotation.Retention;  
  5. import java.lang.annotation.RetentionPolicy;  
  6. import java.lang.annotation.Target;  
  7.   
  8. @Target(ElementType.FIELD)  
  9. @Retention(RetentionPolicy.RUNTIME)  
  10. public @interface TreeNodePid  
  11. {  
  12.   
  13. }  

TreeNodeLabel

 

 

[java] view plaincopy技术分享技术分享
 
  1. package com.zhy.tree.bean;  
  2.   
  3. import java.lang.annotation.ElementType;  
  4. import java.lang.annotation.Retention;  
  5. import java.lang.annotation.RetentionPolicy;  
  6. import java.lang.annotation.Target;  
  7.   
  8. @Target(ElementType.FIELD)  
  9. @Retention(RetentionPolicy.RUNTIME)  
  10. public @interface TreeNodeLabel  
  11. {  
  12.   
  13. }  



 

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版)

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

标签:

原文地址:http://www.cnblogs.com/dongweiq/p/4261977.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!