Android无限级树状结构

通过对ListView简单的扩展、再封装，即可实现无限层级的树控件TreeView。

 package cn.asiontang.nleveltreelistview;

 import android.annotation.TargetApi;
 import android.content.Context;
 import android.os.Build;
 import android.util.AttributeSet;
 import android.view.View;
 import android.widget.AdapterView;
 import android.widget.ListAdapter;
 import android.widget.ListView;

 /**
  * 支持N(无限)层级的树列表结构
  *
  * <p>参考资料：</p>
  * <ul>
  * <li>
  * <a href="http://item.congci.com/item/android-wuxian-ji-shuzhuang-jiegou">Android无限级树状结构 -
  * Android
  * - 从此网</a>
  * </li>
  * </ul>
  *
  * @author AsionTang
  * @since 2016年6月1日 18:38:43
  */
 @SuppressWarnings("unused")
 public class NLevelTreeView extends ListView
 {
     private OnTreeNodeClickListener mOnTreeNodeClickListener;

     public NLevelTreeView(final Context context)
     {
         super(context);
         this.init();
     }

     public NLevelTreeView(final Context context, final AttributeSet attrs)
     {
         super(context, attrs);
         this.init();
     }

     public NLevelTreeView(final Context context, final AttributeSet attrs, final int defStyleAttr)
     {
         super(context, attrs, defStyleAttr);
         this.init();
     }

     @TargetApi(Build.VERSION_CODES.LOLLIPOP)
     public NLevelTreeView(final Context context, final AttributeSet attrs, final int defStyleAttr, final int defStyleRes)
     {
         super(context, attrs, defStyleAttr, defStyleRes);
         this.init();
     }

     private void init()
     {
     }

     public void setAdapter(final NLevelTreeNodeAdapter adapter)
     {
         super.setAdapter(adapter);

         //让 NLevelTreeNodeAdapter 处理 节点 收缩展开 动作
         super.setOnItemClickListener(adapter);

         //处理当 叶子节点 被点击后的事件 回调。
         adapter.setOuterOnItemClickListener(new OnItemClickListener()
         {
             @Override
             public void onItemClick(final AdapterView<?> parent, final View view, final int position, final long id)
             {
                 if (NLevelTreeView.this.mOnTreeNodeClickListener != null)
                 {
                     final NLevelTreeNode item = (NLevelTreeNode) parent.getItemAtPosition(position);
                     NLevelTreeView.this.mOnTreeNodeClickListener.onTreeNodeClick(item);
                 }
             }
         });
     }

     /**
      * 必须使用继承自 NLevelTreeNodeAdapter 的 适配器，否则会出现异常。
      */
     @Override
     public void setAdapter(final ListAdapter adapter)
     {
         if (adapter instanceof NLevelTreeNodeAdapter)
             this.setAdapter((NLevelTreeNodeAdapter) adapter);
         else
             throw new RuntimeException("For NLevelTreeView, use setAdapter(NLevelTreeNodeAdapter) instead of setAdapter(ListAdapter)");
     }

     /**
      * 不支持使用此回调方式
      */
     @Override
     @Deprecated
     public void setOnItemClickListener(final OnItemClickListener listener)
     {
         //实际的事件回调在setAdapter里设置，由 setOnTreeNodeClickListener 处理。
         //super.setOuterOnItemClickListener(listener);

         throw new RuntimeException("For NLevelTreeView, use setOnTreeNodeClickListener() instead of setOnItemClickListener()");
     }

     /**
      * 默认只支持叶子节点的Click事件
      */
     public void setOnTreeNodeClickListener(final OnTreeNodeClickListener listener)
     {
         this.mOnTreeNodeClickListener = listener;
     }

     /**
      * 默认只支持叶子节点的Click事件
      */
     public interface OnTreeNodeClickListener
     {
         /**
          * 默认只支持叶子节点的Click事件
          */
         void onTreeNodeClick(NLevelTreeNode node);
     }
 }

NLevelTreeView.java

 package cn.asiontang.nleveltreelistview;

 import android.content.Context;
 import android.view.View;
 import android.widget.AdapterView;

 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;

 /**
  * @author AsionTang
  * @since 2016年6月1日 18:38:43
  */
 @SuppressWarnings("unused")
 public abstract class NLevelTreeNodeAdapter extends BaseAdapterEx3<NLevelTreeNode> implements AdapterView.OnItemClickListener
 {
     private final Set<NLevelTreeNode> mExpandedNodeList = new HashSet<>();
     private AdapterView.OnItemClickListener mOuterOnItemClickListener;

     public NLevelTreeNodeAdapter(final Context context, final int itemLayoutResId)
     {
         super(context, itemLayoutResId);
     }

     public NLevelTreeNodeAdapter(final Context context, final int itemLayoutResId, final List<NLevelTreeNode> objects)
     {
         super(context, itemLayoutResId, objects);
     }

     @Override
     public void convertView(final ViewHolder viewHolder, final NLevelTreeNode item)
     {
         this.convertView(viewHolder, item, this.mExpandedNodeList.contains(item));
     }

     public abstract void convertView(final ViewHolder viewHolder, final NLevelTreeNode item, boolean isExpanded);

     @Override
     public void onItemClick(final AdapterView<?> parent, final View view, final int position, final long id)
     {
         final NLevelTreeNode item = getItem(position);
         if (this.mExpandedNodeList.contains(item))
         {
             //把展开的节点，收缩起来
             this.mExpandedNodeList.remove(item);

             final int nextPosition = position + 1;
             while (true)
             {
                 //说明已经删除到最后一个节点了。
                 if (nextPosition >= this.getOriginaItems().size())
                     break;

                 final NLevelTreeNode tmpNode = this.getOriginaItems().get(nextPosition);

                 //只删除比它自己级别深的节点（如它的子、孙、重孙节点）
                 if (tmpNode.getLevel() <= item.getLevel())
                     break;

                 this.getOriginaItems().remove(tmpNode);

                 //防止它的子孙节点也有可能是展开的，所有也要移除其状态。
                 this.mExpandedNodeList.remove(tmpNode);
             }
             this.refresh();
         }
         else
         {
             //没有子节点，则不允许展开
             if (item.getChilds().size() == 0)
             {
                 //默认只支持叶子节点的Click事件
                 if (this.mOuterOnItemClickListener != null)
                     this.mOuterOnItemClickListener.onItemClick(parent, view, position, id);
                 return;
             }

             //把收缩的节点，展开起来
             this.mExpandedNodeList.add(item);

             this.getOriginaItems().addAll(position + 1, item.getChilds());

             this.refresh();
         }
     }

     /**
      * 设置外围调用者真正需要的 项点击OnItemClickListener 事件 回调。
      */
     protected void setOuterOnItemClickListener(final AdapterView.OnItemClickListener listener)
     {
         this.mOuterOnItemClickListener = listener;
     }
 }

NLevelTreeNodeAdapter.java

 package cn.asiontang.nleveltreelistview;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * @author AsionTang
  * @since 2016年6月1日 18:38:43
  */
 @SuppressWarnings("unused")
 public class NLevelTreeNode
 {
     private final List<NLevelTreeNode> mChilds = new ArrayList<>();
     private CharSequence mId;
     private int mLevel = 0;
     private CharSequence mName;
     private NLevelTreeNode mParentNode;

     public NLevelTreeNode()
     {
     }

     public NLevelTreeNode(final NLevelTreeNode parentNode, final int level, final CharSequence id, final CharSequence name)
     {
         this.setParentNode(parentNode);
         this.setLevel(level);
         this.setID(id);
         this.setName(name);
     }

     public NLevelTreeNode(final int level, final CharSequence id, final CharSequence name)
     {
         this(null, level, id, name);
     }

     public NLevelTreeNode(final CharSequence id, final CharSequence name)
     {
         this(null, 0, id, name);
     }

     public NLevelTreeNode(final CharSequence name)
     {
         this(null, 0, name, name);
     }

     /**
      * 为此Node添加一个子节点
      */
     public NLevelTreeNode addChild(final NLevelTreeNode child)
     {
         if (!this.mChilds.contains(child))
         {
             this.mChilds.add(child);
             child.setParentNode(this);
         }
         return this;
     }

     /**
      * 设置此Node所属的所有子节点
      */
     public NLevelTreeNode addChilds(final List<NLevelTreeNode> childs)
     {
         for (final NLevelTreeNode child : childs)
             this.addChild(child);
         return this;
     }

     /**
      * 获取此Node指定位置的子节点
      */
     public NLevelTreeNode getChild(final int index)
     {
         return this.mChilds.get(index);
     }

     /**
      * 获取此Node所属的所有子节点
      */
     public List<NLevelTreeNode> getChilds()
     {
         return this.mChilds;
     }

     /**
      * 获取当前Node 唯一标识符（当此Node被点击时，可供区分被点击的是谁）
      */
     public CharSequence getID()
     {
         return this.mId;
     }

     /**
      * 设置当前Node 唯一标识符（当此Node被点击时，可供区分被点击的是谁）
      */
     public NLevelTreeNode setID(final CharSequence id)
     {
         this.mId = id;
         return this;
     }

     /**
      * 获取当前Node所属哪个层级；一般从0级（根节点）开始递增。
      */
     public int getLevel()
     {
         return this.mLevel;
     }

     /**
      * 设置当前Node所在的层级；一般从0级（根节点）开始递增。
      */
     public NLevelTreeNode setLevel(final int level)
     {
         this.mLevel = level;

         //必须立即更新子节点的级别，否则就乱套了。
         for (final NLevelTreeNode child : this.mChilds)
             child.setLevel(level + 1);
         return this;
     }

     /**
      * 获取当前Node 名字
      */
     public CharSequence getName()
     {
         return this.mName;
     }

     /**
      * 设置当前Node 名字
      */
     public NLevelTreeNode setName(final CharSequence name)
     {
         this.mName = name;
         return this;
     }

     /**
      * 获取 此Note 的父节点
      */
     public NLevelTreeNode getParentNode()
     {
         return this.mParentNode;
     }

     /**
      * 设置 此Note 的父节点
      */
     public NLevelTreeNode setParentNode(final NLevelTreeNode parentNode)
     {
         this.mParentNode = parentNode;
         if (parentNode != null)
         {
             parentNode.addChild(this);
             this.setLevel(parentNode.getLevel() + 1);
         }
         return this;
     }
 }

NLevelTreeNode.java

源码：

https://bitbucket.org/AsionTang/75.nleveltreeview/overview
https://github.com/asiontang/75.NLevelTreeView