android多级列表

于 2016-11-16 11:33:51 发布
阅读量3.3k 收藏 5
点赞数 5
分类专栏： Android 文章标签： android 多级列表


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

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


           


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

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

话不多说 代码中体会

Activity


[java]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.example.customtreeviewdemo;  
  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.view.View;  
  9. import android.view.View.OnClickListener;  
  10. import android.widget.Button;  
  11. import android.widget.ListView;  
  12. import android.widget.Toast;  
  13.   
  14. import com.example.customtreeviewdemo.bean.MyNodeBean;  
  15. import com.example.customtreeviewdemo.tree.Node;  
  16. import com.example.customtreeviewdemo.tree.TreeListViewAdapter.OnTreeNodeClickListener;  
  17.   
  18. public class MainActivity extends Activity {  
  19.   
  20.     private ListView treeLv;  
  21.     private Button checkSwitchBtn;  
  22.     private MyTreeListViewAdapter<MyNodeBean> adapter;  
  23.     private List<MyNodeBean> mDatas = new ArrayList<MyNodeBean>();  
  24.     //标记是显示Checkbox还是隐藏  
  25.     private boolean isHide = true;  
  26.   
  27.     @Override  
  28.     protected void onCreate(Bundle savedInstanceState) {  
  29.         super.onCreate(savedInstanceState);  
  30.         setContentView(R.layout.activity_main);  
  31.   
  32.         initDatas();  
  33.         treeLv = (ListView) this.findViewById(R.id.tree_lv);  
  34.         checkSwitchBtn = (Button)this.findViewById(R.id.check_switch_btn);  
  35.           
  36.         checkSwitchBtn.setOnClickListener(new OnClickListener(){  
  37.   
  38.             @Override  
  39.             public void onClick(View v) {  
  40.                 if(isHide){  
  41.                     isHide = false;  
  42.                 }else{  
  43.                     isHide = true;  
  44.                 }  
  45.                   
  46.                 adapter.updateView(isHide);  
  47.             }  
  48.               
  49.         });  
  50.         try {  
  51.             adapter = new MyTreeListViewAdapter<MyNodeBean>(treeLv, this,  
  52.                     mDatas, 10, isHide);  
  53.   
  54.             adapter.setOnTreeNodeClickListener(new OnTreeNodeClickListener() {  
  55.                 @Override  
  56.                 public void onClick(Node node, int position) {  
  57.                     if (node.isLeaf()) {  
  58.                         Toast.makeText(getApplicationContext(), node.getName(),  
  59.                                 Toast.LENGTH_SHORT).show();  
  60.                     }  
  61.                 }  
  62.   
  63.                 @Override  
  64.                 public void onCheckChange(Node node, int position,  
  65.                         List<Node> checkedNodes) {  
  66.   
  67.                     StringBuffer sb = new StringBuffer();  
  68.                     for (Node n : checkedNodes) {  
  69.                         int pos = n.getId() - 1;  
  70.                         sb.append(mDatas.get(pos).getName()).append("---")  
  71.                                 .append(pos + 1).append(";");  
  72.   
  73.                     }  
  74.   
  75.                     Toast.makeText(getApplicationContext(), sb.toString(),  
  76.                             Toast.LENGTH_SHORT).show();  
  77.                 }  
  78.   
  79.             });  
  80.         } catch (IllegalArgumentException e) {  
  81.             e.printStackTrace();  
  82.         } catch (IllegalAccessException e) {  
  83.             e.printStackTrace();  
  84.         }  
  85.         treeLv.setAdapter(adapter);  
  86.   
  87.     }  
  88.   
  89.     private void initDatas() {  
  90.         mDatas.add(new MyNodeBean(1, 0, "中国古代"));  
  91.         mDatas.add(new MyNodeBean(2, 1, "唐朝"));  
  92.         mDatas.add(new MyNodeBean(3, 1, "宋朝"));  
  93.         mDatas.add(new MyNodeBean(4, 1, "明朝"));  
  94.         mDatas.add(new MyNodeBean(5, 2, "李世民"));  
  95.         mDatas.add(new MyNodeBean(6, 2, "李白"));  
  96.   
  97.         mDatas.add(new MyNodeBean(7, 3, "赵匡胤"));  
  98.         mDatas.add(new MyNodeBean(8, 3, "苏轼"));  
  99.   
  100.         mDatas.add(new MyNodeBean(9, 4, "朱元璋"));  
  101.         mDatas.add(new MyNodeBean(10, 4, "唐伯虎"));  
  102.         mDatas.add(new MyNodeBean(11, 4, "文征明"));  
  103.         mDatas.add(new MyNodeBean(12, 7, "赵建立"));  
  104.         mDatas.add(new MyNodeBean(13, 8, "苏东东"));  
  105.         mDatas.add(new MyNodeBean(14, 10, "秋香"));  
  106.     }  
  107. }  


Adapter

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


[java]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.example.customtreeviewdemo;  
  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.CheckBox;  
  9. import android.widget.CompoundButton;  
  10. import android.widget.CompoundButton.OnCheckedChangeListener;  
  11. import android.widget.ImageView;  
  12. import android.widget.ListView;  
  13. import android.widget.TextView;  
  14.   
  15. import com.example.customtreeviewdemo.tree.Node;  
  16. import com.example.customtreeviewdemo.tree.TreeListViewAdapter;  
  17.   
  18. public class MyTreeListViewAdapter<T> extends TreeListViewAdapter<T> {  
  19.   
  20.     public MyTreeListViewAdapter(ListView mTree, Context context,  
  21.             List<T> datas, int defaultExpandLevel,boolean isHide)  
  22.             throws IllegalArgumentException, IllegalAccessException {  
  23.         super(mTree, context, datas, defaultExpandLevel,isHide);  
  24.     }  
  25.       
  26.     @SuppressWarnings("unchecked")  
  27.     @Override  
  28.     public View getConvertView(Node node, int position, View convertView,  
  29.             ViewGroup parent) {  
  30.         ViewHolder viewHolder = null;  
  31.         if (convertView == null)  
  32.         {  
  33.             convertView = mInflater.inflate(R.layout.list_item, parent, false);  
  34.             viewHolder = new ViewHolder();  
  35.             viewHolder.icon = (ImageView) convertView  
  36.                     .findViewById(R.id.id_treenode_icon);  
  37.             viewHolder.label = (TextView) convertView  
  38.                     .findViewById(R.id.id_treenode_name);  
  39.             viewHolder.checkBox = (CheckBox)convertView.findViewById(R.id.id_treeNode_check);  
  40.               
  41.             convertView.setTag(viewHolder);  
  42.   
  43.         } else  
  44.         {  
  45.             viewHolder = (ViewHolder) convertView.getTag();  
  46.         }  
  47.   
  48.         if (node.getIcon() == -1)  
  49.         {  
  50.             viewHolder.icon.setVisibility(View.INVISIBLE);  
  51.         } else  
  52.         {  
  53.             viewHolder.icon.setVisibility(View.VISIBLE);  
  54.             viewHolder.icon.setImageResource(node.getIcon());  
  55.         }  
  56.   
  57.         if(node.isHideChecked()){  
  58.             viewHolder.checkBox.setVisibility(View.GONE);  
  59.         }else{  
  60.             viewHolder.checkBox.setVisibility(View.VISIBLE);  
  61.             setCheckBoxBg(viewHolder.checkBox,node.isChecked());  
  62.         }  
  63.         viewHolder.label.setText(node.getName());  
  64.           
  65.           
  66.         return convertView;  
  67.     }  
  68.     private final class ViewHolder  
  69.     {  
  70.         ImageView icon;  
  71.         TextView label;  
  72.         CheckBox checkBox;  
  73.     }  
  74.       
  75.     /** 
  76.      * checkbox是否显示 
  77.      * @param cb 
  78.      * @param isChecked 
  79.      */  
  80.     private void setCheckBoxBg(CheckBox cb,boolean isChecked){  
  81.         if(isChecked){  
  82.             cb.setBackgroundResource(R.drawable.check_box_bg_check);  
  83.         }else{  
  84.             cb.setBackgroundResource(R.drawable.check_box_bg);  
  85.         }  
  86.     }  
  87. }  


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


[java]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.example.customtreeviewdemo.tree;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. import android.content.Context;  
  7. import android.view.LayoutInflater;  
  8. import android.view.View;  
  9. import android.view.ViewGroup;  
  10. import android.widget.AdapterView;  
  11. import android.widget.AdapterView.OnItemClickListener;  
  12. import android.widget.BaseAdapter;  
  13. import android.widget.CheckBox;  
  14. import android.widget.CompoundButton;  
  15. import android.widget.CompoundButton.OnCheckedChangeListener;  
  16. import android.widget.ListView;  
  17. import android.widget.RelativeLayout;  
  18.   
  19. /** 
  20.  * tree适配器 
  21.  * @param <T> 
  22.  */  
  23. public abstract class TreeListViewAdapter<T> extends BaseAdapter {  
  24.   
  25.     protected Context mContext;  
  26.     /** 
  27.      * 存储所有可见的Node 
  28.      */  
  29.     protected List<Node> mNodes;  
  30.     protected LayoutInflater mInflater;  
  31.     /** 
  32.      * 存储所有的Node 
  33.      */  
  34.     protected List<Node> mAllNodes;  
  35.   
  36.     /** 
  37.      * 点击的回调接口 
  38.      */  
  39.     private OnTreeNodeClickListener onTreeNodeClickListener;  
  40.   
  41.     public interface OnTreeNodeClickListener {  
  42.         /** 
  43.          * 处理node click事件 
  44.          * @param node 
  45.          * @param position 
  46.          */  
  47.         void onClick(Node node, int position);  
  48.         /** 
  49.          * 处理checkbox选择改变事件 
  50.          * @param node 
  51.          * @param position 
  52.          * @param checkedNodes 
  53.          */  
  54.         void onCheckChange(Node node, int position,List<Node> checkedNodes);  
  55.     }  
  56.   
  57.     public void setOnTreeNodeClickListener(  
  58.             OnTreeNodeClickListener onTreeNodeClickListener) {  
  59.         this.onTreeNodeClickListener = onTreeNodeClickListener;  
  60.     }  
  61.   
  62.     /** 
  63.      *  
  64.      * @param mTree 
  65.      * @param context 
  66.      * @param datas 
  67.      * @param defaultExpandLevel 
  68.      *            默认展开几级树 
  69.      * @throws IllegalArgumentException 
  70.      * @throws IllegalAccessException 
  71.      */  
  72.     public TreeListViewAdapter(ListView mTree, Context context, List<T> datas,  
  73.             int defaultExpandLevel, boolean isHide)  
  74.             throws IllegalArgumentException, IllegalAccessException {  
  75.         mContext = context;  
  76.         /** 
  77.          * 对所有的Node进行排序 
  78.          */  
  79.         mAllNodes = TreeHelper  
  80.                 .getSortedNodes(datas, defaultExpandLevel, isHide);  
  81.         /** 
  82.          * 过滤出可见的Node 
  83.          */  
  84.         mNodes = TreeHelper.filterVisibleNode(mAllNodes);  
  85.         mInflater = LayoutInflater.from(context);  
  86.   
  87.         /** 
  88.          * 设置节点点击时，可以展开以及关闭；并且将ItemClick事件继续往外公布 
  89.          */  
  90.         mTree.setOnItemClickListener(new OnItemClickListener() {  
  91.             @Override  
  92.             public void onItemClick(AdapterView<?> parent, View view,  
  93.                     int position, long id) {  
  94.                 expandOrCollapse(position);  
  95.   
  96.                 if (onTreeNodeClickListener != null) {  
  97.                     onTreeNodeClickListener.onClick(mNodes.get(position),  
  98.                             position);  
  99.                 }  
  100.             }  
  101.   
  102.         });  
  103.   
  104.     }  
  105.   
  106.     /** 
  107.      * 相应ListView的点击事件 展开或关闭某节点 
  108.      *  
  109.      * @param position 
  110.      */  
  111.     public void expandOrCollapse(int position) {  
  112.         Node n = mNodes.get(position);  
  113.   
  114.         if (n != null)// 排除传入参数错误异常  
  115.         {  
  116.             if (!n.isLeaf()) {  
  117.                 n.setExpand(!n.isExpand());  
  118.                 mNodes = TreeHelper.filterVisibleNode(mAllNodes);  
  119.                 notifyDataSetChanged();// 刷新视图  
  120.             }  
  121.         }  
  122.     }  
  123.   
  124.     @Override  
  125.     public int getCount() {  
  126.         return mNodes.size();  
  127.     }  
  128.   
  129.     @Override  
  130.     public Object getItem(int position) {  
  131.         return mNodes.get(position);  
  132.     }  
  133.   
  134.     @Override  
  135.     public long getItemId(int position) {  
  136.         return position;  
  137.     }  
  138.   
  139.     @Override  
  140.     public View getView(final int position, View convertView, ViewGroup parent) {  
  141.         final Node node = mNodes.get(position);  
  142.   
  143.         convertView = getConvertView(node, position, convertView, parent);  
  144.         // 设置内边距  
  145.         convertView.setPadding(node.getLevel() * 30, 3, 3, 3);  
  146.         if (!node.isHideChecked()) {  
  147.             //获取各个节点所在的父布局  
  148.             RelativeLayout myView = (RelativeLayout) convertView;  
  149.             //父布局下的CheckBox  
  150.             CheckBox cb = (CheckBox) myView.getChildAt(1);  
  151.             cb.setOnCheckedChangeListener(new OnCheckedChangeListener(){  
  152.   
  153.                 @Override  
  154.                 public void onCheckedChanged(CompoundButton buttonView,  
  155.                         boolean isChecked) {  
  156.                     TreeHelper.setNodeChecked(node, isChecked);  
  157.                     List<Node> checkedNodes = new ArrayList<Node>();  
  158.                     for(Node n:mAllNodes){  
  159.                         if(n.isChecked()){  
  160.                             checkedNodes.add(n);  
  161.                         }  
  162.                     }  
  163.                       
  164.                     onTreeNodeClickListener.onCheckChange(node,position,checkedNodes);  
  165.                     TreeListViewAdapter.this.notifyDataSetChanged();  
  166.                 }  
  167.                   
  168.             });  
  169.         }  
  170.   
  171.         return convertView;  
  172.     }  
  173.   
  174.     public abstract View getConvertView(Node node, int position,  
  175.             View convertView, ViewGroup parent);  
  176.   
  177.     /** 
  178.      * 更新 
  179.      * @param isHide 
  180.      */  
  181.     public void updateView(boolean isHide){  
  182.         for(Node node:mAllNodes){  
  183.             node.setHideChecked(isHide);  
  184.         }  
  185.           
  186.         this.notifyDataSetChanged();  
  187.     }  
  188.   
  189. }  


node 模型类

[java]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.example.customtreeviewdemo.bean;  
  2.   
  3. public class MyNodeBean {  
  4.     /** 
  5.      * 节点Id 
  6.      */  
  7.     private int id;  
  8.     /** 
  9.      * 节点父id 
  10.      */  
  11.     private int pId;  
  12.     /** 
  13.      * 节点name 
  14.      */  
  15.     private String name;  
  16.     /** 
  17.      *  
  18.      */  
  19.     private String desc;  
  20.     /** 
  21.      * 节点名字长度 
  22.      */  
  23.     private long length;  
  24.       
  25.       
  26.     public MyNodeBean(int id, int pId, String name) {  
  27.         super();  
  28.         this.id = id;  
  29.         this.pId = pId;  
  30.         this.name = name;  
  31.     }  
  32.       
  33.     public int getId() {  
  34.         return id;  
  35.     }  
  36.     public void setId(int id) {  
  37.         this.id = id;  
  38.     }  
  39.     public int getPid() {  
  40.         return pId;  
  41.     }  
  42.     public void setPid(int pId) {  
  43.         this.pId = pId;  
  44.     }  
  45.     public String getName() {  
  46.         return name;  
  47.     }  
  48.     public void setName(String name) {  
  49.         this.name = name;  
  50.     }  
  51.     public String getDesc() {  
  52.         return desc;  
  53.     }  
  54.     public void setDesc(String desc) {  
  55.         this.desc = desc;  
  56.     }  
  57.     public long getLength() {  
  58.         return length;  
  59.     }  
  60.     public void setLength(long length) {  
  61.         this.length = length;  
  62.     }  
  63.       
  64.       
  65. }  


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


[java]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.example.customtreeviewdemo.tree;  
  2.   
  3. import java.lang.reflect.Field;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6.   
  7. import com.example.customtreeviewdemo.R;  
  8.   
  9. public class TreeHelper {  
  10.   
  11.     /** 
  12.      * 根据所有节点获取可见节点 
  13.      *  
  14.      * @param allNodes 
  15.      * @return 
  16.      */  
  17.     public static List<Node> filterVisibleNode(List<Node> allNodes) {  
  18.         List<Node> visibleNodes = new ArrayList<Node>();  
  19.         for (Node node : allNodes) {  
  20.             // 如果为根节点，或者上层目录为展开状态  
  21.             if (node.isRoot() || node.isParentExpand()) {  
  22.                 setNodeIcon(node);  
  23.                 visibleNodes.add(node);  
  24.             }  
  25.         }  
  26.         return visibleNodes;  
  27.     }  
  28.   
  29.     /** 
  30.      * 获取排序的所有节点 
  31.      *  
  32.      * @param datas 
  33.      * @param defaultExpandLevel 
  34.      * @return 
  35.      * @throws IllegalArgumentException 
  36.      * @throws IllegalAccessException 
  37.      */  
  38.     public static <T> List<Node> getSortedNodes(List<T> datas,  
  39.             int defaultExpandLevel, boolean isHide)  
  40.             throws IllegalAccessException, IllegalArgumentException {  
  41.         List<Node> sortedNodes = new ArrayList<Node>();  
  42.         // 将用户数据转化为List<Node>  
  43.         List<Node> nodes = convertData2Nodes(datas, isHide);  
  44.         // 拿到根节点  
  45.         List<Node> rootNodes = getRootNodes(nodes);  
  46.         // 排序以及设置Node间关系  
  47.         for (Node node : rootNodes) {  
  48.             addNode(sortedNodes, node, defaultExpandLevel, 1);  
  49.         }  
  50.         return sortedNodes;  
  51.     }  
  52.   
  53.     /** 
  54.      * 把一个节点上的所有的内容都挂上去 
  55.      */  
  56.     private static void addNode(List<Node> nodes, Node node,  
  57.             int defaultExpandLeval, int currentLevel) {  
  58.   
  59.         nodes.add(node);  
  60.         if (defaultExpandLeval >= currentLevel) {  
  61.             node.setExpand(true);  
  62.         }  
  63.   
  64.         if (node.isLeaf())  
  65.             return;  
  66.         for (int i = 0; i < node.getChildrenNodes().size(); i++) {  
  67.             addNode(nodes, node.getChildrenNodes().get(i), defaultExpandLeval,  
  68.                     currentLevel + 1);  
  69.         }  
  70.     }  
  71.   
  72.     /** 
  73.      * 获取所有的根节点 
  74.      *  
  75.      * @param nodes 
  76.      * @return 
  77.      */  
  78.     public static List<Node> getRootNodes(List<Node> nodes) {  
  79.         List<Node> rootNodes = new ArrayList<Node>();  
  80.         for (Node node : nodes) {  
  81.             if (node.isRoot()) {  
  82.                 rootNodes.add(node);  
  83.             }  
  84.         }  
  85.   
  86.         return rootNodes;  
  87.     }  
  88.   
  89.     /** 
  90.      * 将泛型datas转换为node 
  91.      *  
  92.      * @param datas 
  93.      * @return 
  94.      * @throws IllegalArgumentException 
  95.      * @throws IllegalAccessException 
  96.      */  
  97.     public static <T> List<Node> convertData2Nodes(List<T> datas, boolean isHide)  
  98.             throws IllegalAccessException, IllegalArgumentException {  
  99.         List<Node> nodes = new ArrayList<Node>();  
  100.         Node node = null;  
  101.   
  102.         for (T t : datas) {  
  103.             int id = -1;  
  104.             int pId = -1;  
  105.             String name = null;  
  106.   
  107.             Class<? extends Object> clazz = t.getClass();  
  108.             Field[] declaredFields = clazz.getDeclaredFields();  
  109.             /** 
  110.              * 与MyNodeBean实体一一对应 
  111.              */  
  112.             for (Field f : declaredFields) {  
  113.                 if ("id".equals(f.getName())) {  
  114.                     f.setAccessible(true);  
  115.                     id = f.getInt(t);  
  116.                 }  
  117.   
  118.                 if ("pId".equals(f.getName())) {  
  119.                     f.setAccessible(true);  
  120.                     pId = f.getInt(t);  
  121.                 }  
  122.   
  123.                 if ("name".equals(f.getName())) {  
  124.                     f.setAccessible(true);  
  125.                     name = (String) f.get(t);  
  126.                 }  
  127.   
  128.                 if ("desc".equals(f.getName())) {  
  129.                     continue;  
  130.                 }  
  131.   
  132.                 if ("length".equals(f.getName())) {  
  133.                     continue;  
  134.                 }  
  135.   
  136.                 if (id == -1 && pId == -1 && name == null) {  
  137.                     break;  
  138.                 }  
  139.             }  
  140.   
  141.             node = new Node(id, pId, name);  
  142.             node.setHideChecked(isHide);  
  143.             nodes.add(node);  
  144.         }  
  145.   
  146.         /** 
  147.          * 比较nodes中的所有节点，分别添加children和parent 
  148.          */  
  149.         for (int i = 0; i < nodes.size(); i++) {  
  150.             Node n = nodes.get(i);  
  151.             for (int j = i + 1; j < nodes.size(); j++) {  
  152.                 Node m = nodes.get(j);  
  153.                 if (n.getId() == m.getpId()) {  
  154.                     n.getChildrenNodes().add(m);  
  155.                     m.setParent(n);  
  156.                 } else if (n.getpId() == m.getId()) {  
  157.                     n.setParent(m);  
  158.                     m.getChildrenNodes().add(n);  
  159.                 }  
  160.             }  
  161.         }  
  162.   
  163.         for (Node n : nodes) {  
  164.             setNodeIcon(n);  
  165.         }  
  166.         return nodes;  
  167.     }  
  168.   
  169.     /** 
  170.      * 设置打开，关闭icon 
  171.      *  
  172.      * @param node 
  173.      */  
  174.     public static void setNodeIcon(Node node) {  
  175.         if (node.getChildrenNodes().size() > 0 && node.isExpand()) {  
  176.             node.setIcon(R.drawable.tree_expand);  
  177.         } else if (node.getChildrenNodes().size() > 0 && !node.isExpand()) {  
  178.             node.setIcon(R.drawable.tree_econpand);  
  179.         } else  
  180.             node.setIcon(-1);  
  181.     }  
  182.   
  183.     public static void setNodeChecked(Node node, boolean isChecked) {  
  184.         // 自己设置是否选择  
  185.         node.setChecked(isChecked);  
  186.         /** 
  187.          * 非叶子节点,子节点处理 
  188.          */  
  189.         setChildrenNodeChecked(node, isChecked);  
  190.         /** 父节点处理 */  
  191.         setParentNodeChecked(node);  
  192.     }  
  193.   
  194.     /** 
  195.      * 非叶子节点,子节点处理 
  196.      */  
  197.     private static void setChildrenNodeChecked(Node node, boolean isChecked) {  
  198.         node.setChecked(isChecked);  
  199.         if (!node.isLeaf()) {  
  200.             for (Node n : node.getChildrenNodes()) {  
  201.                 // 所有子节点设置是否选择  
  202.                 setChildrenNodeChecked(n, isChecked);  
  203.             }  
  204.         }  
  205.     }  
  206.   
  207.     /** 
  208.      * 设置父节点选择 
  209.      *  
  210.      * @param node 
  211.      */  
  212.     private static void setParentNodeChecked(Node node) {  
  213.   
  214.         /** 非根节点 */  
  215.         if (!node.isRoot()) {  
  216.             Node rootNode = node.getParent();  
  217.             boolean isAllChecked = true;  
  218.             for (Node n : rootNode.getChildrenNodes()) {  
  219.                 if (!n.isChecked()) {  
  220.                     isAllChecked = false;  
  221.                     break;  
  222.                 }  
  223.             }  
  224.   
  225.             if (isAllChecked) {  
  226.                 rootNode.setChecked(true);  
  227.             } else {  
  228.                 rootNode.setChecked(false);  
  229.             }  
  230.             setParentNodeChecked(rootNode);  
  231.         }  
  232.     }  
  233.   
  234. }  


核心的代码就是这些，希望对大家有帮助。


转自：http://blog.csdn.net/shaoyezhangliwei/article/details/52275130

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值