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);
    }
}

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;
    }
}

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;
    }
}

源码：

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