Android 可单选多选的任意层级树形控件

package com.example.keranbin.testdemo.treeHelp; import java.util.ArrayList;
import java.util.List; /**
* Created by keranbin on 2016/8/30.
*/
public class Node {
//id
private String id; //父辈id
private String pid = ""; //要在树形控件上展示的内容，比如说机构名称。
private String name; //树的层级
private int level; // 是否是展开的
private boolean isExpand = false; //是否是选择的
private boolean isChoose=false; //缩进图标
private int icon; //父亲节点
private Node parent; //儿子节点集合
private List<Node> children = new ArrayList<>(); public Node(String id, String pid, String name) {
this.id = id;
this.pid = pid;
this.name = name; } public String getId() {
return id;
} public void setId(String id) {
this.id = id;
} public String getPid() {
return pid;
} public void setPid(String pid) {
this.pid = pid;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} /**
* 得到当前节点的层级，如果当前节点没有父节点，则该节点
*是根节点，否则当前节点的层级为当前节点父节点的层级加1
* @return
*/
public int getLevel() {
return parent == null ? 0 : parent.getLevel() + 1;
} public void setLevel(int level) {
this.level = level;
} public boolean isExpand() {
return isExpand;
} /**
* 设置当前节点是否展开，如果是false，那么递归关闭当前节点的所有子节点
*
* @param expand
*/
public void setExpand(boolean expand) {
isExpand = expand;
if (!expand) {
for (Node node : children) {
node.setExpand(false);
}
}
} public boolean isChoose() {
return isChoose;
} public void setChoose(boolean choose) {
isChoose = choose;
} public int getIcon() {
return icon;
} public void setIcon(int icon) {
this.icon = icon;
} public Node getParent() {
return parent;
} public void setParent(Node parent) {
this.parent = parent;
} public List<Node> getChildren() {
return children;
} public void setChildren(List<Node> children) {
this.children = children;
} /**
* 是否是根节点
*/
public boolean isRoot() {
return parent == null;
} /**
* 是否是展开状态，
*/
public boolean isParentExpand() {
if (parent == null)
return false;
return parent.isExpand();
} /**
* 是否是叶子节点
*
* @return
*/
public boolean isLeft() {
return children.size() == 0;
}
}

package com.example.keranbin.business.ccsq.annotion; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; /**
* Created by keranbin on 2016/8/30.
*/ @Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeNodeId {
}

package com.example.keranbin.business.ccsq.annotion; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; /**
* Created by keranbin on 2016/8/30.
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeNodePid {
}

package com.example.keranbin.business.ccsq.annotion; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; /**
* Created by keranbin on 2016/8/30.
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TreeNodeLabel {
}

/**
* 将服务器端取回的数据转化成Node
* @param datas
* @return
* @throws IllegalAccessError
*/
public static <T> List<Node> convertDataToNodes(List<T> datas) throws IllegalAccessException {
List<Node> nodes = new ArrayList<>();
Node node = null;
for (T t : datas) {
String id = "";
String pid = "";
String label = null;
String type=null;
node = null;
Class c = t.getClass();
Field fields[] = c.getDeclaredFields(); for (Field field : fields) {
if (field.getAnnotation(TreeNodeId.class) != null) {
//设置访问权限，强制性的可以访问
field.setAccessible(true);
id= (String) field.get(t);
} if (field.getAnnotation(TreeNodePid.class) != null) {
//设置访问权限，强制性的可以访问
field.setAccessible(true);
pid= (String) field.get(t);
} if (field.getAnnotation(TreeNodeLabel.class) != null) {
//设置访问权限，强制性的可以访问
field.setAccessible(true);
label = (String) field.get(t);
}
node = new Node(id, pid, label,type);
nodes.add(node);
}

/**
* 循环对比两个Node,设置节点间关联关系
*/
for (int i = 0; i < nodes.size(); i++) {
Node n = nodes.get(i);
for (int j = i+1; j < nodes.size(); j++) {
Node m = nodes.get(j);
if (m.getId().equals( n.getPid())) {//m是n的父节点
m.getChildren().add(n);
n.setParent(m);
} else if (m.getPid().equals( n.getId())) {//n是m的父节点
n.getChildren().add(m);
m.setParent(n);
}
}
}

/**
* 为节点设置图标
* 逻辑：（1）如果当前节点有孩子节点并且处于展开状态，那么设置向下的图标
* （2）如果当前节点有孩子节点并且处于闭合状态，那么设置向右的图标
* （3）如果当前节点没有孩子节点，传参-1，到时候判断是-1，不设置图标
* @param n
*/
private static void setNodeIcon(Node n) {
if (n.getChildren().size() > 0 && n.isExpand()) {
n.setIcon(R.mipmap.tree_ex);
} else if (n.getChildren().size() > 0 && !n.isExpand()) {
n.setIcon(R.mipmap.tree_ec);
} else {
n.setIcon(-1);
}
}

**
* 得到排序后的Nodes
* @param datas
* @param <T>
* @return
*/
public static <T> List<Node> getSortedNodes(List<T> datas, int defaultExpandLevel) throws IllegalAccessException {
List<Node> result = new ArrayList<>();
List<Node> nodes = convertDataToNodes(datas);
//获取树的根节点
List<Node> rootNodes = getRootNodes(nodes); for (Node node : rootNodes) {
addNode(result, node, defaultExpandLevel, 1);
}
return result;
}

/**
* 从所有节点中过滤出根节点
* @param nodes
* @return
*/
private static List<Node> getRootNodes(List<Node> nodes) {
List<Node> root = new ArrayList<>();
for (Node node : nodes) {
if (node.isRoot()) {
root.add(node);
}
}
return root;
}

/**
* 把一个节点的所有孩子节点都放入result
* @param result
* @param node 当前节点
* @param defaultExpandLevel 默认初始化是展开几层
* @param currentLevel 当前节点层级
*/
private static void addNode(List<Node> result, Node node, int defaultExpandLevel, int currentLevel) {
result.add(node);
//如果默认展开层级大于或者当前节点层级，那么设置当前层级是展开的，否则设置是闭合的
if (defaultExpandLevel >= currentLevel){
node.setExpand(true);
} //如果当前节点已经是叶子节点，那么不需要做任何处理啦
if(node.isLeft()){
return; }else{
//如果当前节点不是叶子节点，递归循环遍历不断的添加子节点
for(int i=0;i<node.getChildren().size();i++){
addNode(result,node.getChildren().get(i),defaultExpandLevel,currentLevel+1);
}
}
}

/**
* 过滤出可见的节点
* @param nodes
* @return
*/
public static List<Node> filterVisibleNodes(List<Node> nodes){
List<Node> visibleNodes=new ArrayList<>();
for (Node node:nodes){
//如果当前节点是根节点或者当前节点的父节点是展开的
if (node.isRoot()||node.isParentExpand()){
setNodeIcon(node);
visibleNodes.add(node);
}
}
return visibleNodes;
}

package com.example.keranbin.business.help.treeHelp; import com.example.keranbin.business.R;
import com.example.keranbin.business.ccsq.annotion.TreeNodeId;
import com.example.keranbin.business.ccsq.annotion.TreeNodeLabel;
import com.example.keranbin.business.ccsq.annotion.TreeNodePid;
import com.example.keranbin.business.ccsq.annotion.TreeNodeType; import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List; /**
* Created by keranbin on 2016/8/30.
*/
public class TreeHelp {
/**
* 将服务器端取回的数据转化成Node
* @param datas
* @return
* @throws IllegalAccessError
*/
public static <T> List<Node> convertDataToNodes(List<T> datas) throws IllegalAccessException {
List<Node> nodes = new ArrayList<>();
Node node = null;
for (T t : datas) {
String id = "";
String pid = "";
String label = null;
node = null;
Class c = t.getClass();
Field fields[] = c.getDeclaredFields(); for (Field field : fields) {
if (field.getAnnotation(TreeNodeId.class) != null) {
//设置访问权限，强制性的可以访问
field.setAccessible(true);
id= (String) field.get(t);
} if (field.getAnnotation(TreeNodePid.class) != null) {
//设置访问权限，强制性的可以访问
field.setAccessible(true);
pid= (String) field.get(t);
} if (field.getAnnotation(TreeNodeLabel.class) != null) {
//设置访问权限，强制性的可以访问
field.setAccessible(true);
label = (String) field.get(t);
} } node = new Node(id, pid, label);
nodes.add(node);
} /**
* 循环对比两个Node,设置节点间关联关系
*/
for (int i = 0; i < nodes.size(); i++) {
Node n = nodes.get(i);
for (int j = i+1; j < nodes.size(); j++) {
Node m = nodes.get(j);
if (m.getId().equals( n.getPid())) {//m是n的父节点
m.getChildren().add(n);
n.setParent(m);
} else if (m.getPid().equals( n.getId())) {//n是m的父节点
n.getChildren().add(m);
m.setParent(n);
}
}
} /**
* 设置节点的图标
*/
for (Node n : nodes) {
setNodeIcon(n);
}
return nodes;
} /**
* 为节点设置图标
* 逻辑：（1）如果当前节点有孩子节点并且处于展开状态，那么设置向下的图标
* （2）如果当前节点有孩子节点病区处于闭合状态，那么设置向右的图标
* （3）如果当前节点没有孩子节点，传参-1，到时候判断是-1，不设置图标
* @param n
*/
private static void setNodeIcon(Node n) {
if (n.getChildren().size() > 0 && n.isExpand()) {
n.setIcon(R.mipmap.tree_ex);
} else if (n.getChildren().size() > 0 && !n.isExpand()) {
n.setIcon(R.mipmap.tree_ec);
} else {
n.setIcon(-1);
}
} /**
* 得到排序后的Nodes
* @param datas
* @param <T>
* @return
*/
public static <T> List<Node> getSortedNodes(List<T> datas, int defaultExpandLevel) throws IllegalAccessException {
List<Node> result = new ArrayList<>();
List<Node> nodes = convertDataToNodes(datas);
//获取树的根节点
List<Node> rootNodes = getRootNodes(nodes); for (Node node : rootNodes) {
addNode(result, node, defaultExpandLevel, 1);
}
return result;
} /**
* 从所有节点中过滤出根节点
* @param nodes
* @return
*/
private static List<Node> getRootNodes(List<Node> nodes) {
List<Node> root = new ArrayList<>();
for (Node node : nodes) {
if (node.isRoot()) {
root.add(node);
}
}
return root;
} /**
* 把一个节点的所有孩子节点都放入result
* @param result
* @param node 当前节点
* @param defaultExpandLevel 默认初始化是展开几层
* @param currentLevel 当前节点层级
*/
private static void addNode(List<Node> result, Node node, int defaultExpandLevel, int currentLevel) {
result.add(node);
//如果默认展开层级大于或者当前节点层级，那么设置当前层级是展开的，否则设置是闭合的
if (defaultExpandLevel >= currentLevel){
node.setExpand(true);
} //如果当前节点已经是叶子节点，那么不需要做任何处理啦
if(node.isLeft()){
return; }else{
//如果当前节点不是叶子节点，递归循环遍历不断的添加子节点
for(int i=0;i<node.getChildren().size();i++){
addNode(result,node.getChildren().get(i),defaultExpandLevel,currentLevel+1);
}
}
} /**
* 过滤出可见的节点
* @param nodes
* @return
*/
public static List<Node> filterVisibleNodes(List<Node> nodes){
List<Node> visibleNodes=new ArrayList<>();
for (Node node:nodes){
//如果当前节点是根节点或者当前节点的父节点是展开的
if (node.isRoot()||node.isParentExpand()){
setNodeIcon(node);
visibleNodes.add(node);
}
}
return visibleNodes;
}
}

package com.example.keranbin.testdemo.treeHelp; import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.ListView; import java.util.List; /**
* Created by keranbin on 2016/8/30.
*/
public abstract class TreeListViewAdapter<T> extends BaseAdapter implements AdapterView.OnItemClickListener {
protected Context context;
protected ListView listView;
protected List<Node> mAllNodes;
protected List<Node> mVisibleNodes;
protected LayoutInflater inflater; private OnTreeNodeClickListener onTreeNodeClickListener; public TreeListViewAdapter(Context context, ListView listView, List<T> datas, int defaultExpandLevel) throws IllegalAccessException {
this.context = context;
this.listView = listView;
mAllNodes = TreeHelp.getSortedNodes(datas,defaultExpandLevel);
mVisibleNodes = TreeHelp.filterVisibleNodes(mAllNodes);
inflater = LayoutInflater.from(context); listView.setOnItemClickListener(this);
} @Override
public int getCount() {
return mVisibleNodes.size();
} @Override
public Object getItem(int position) {
return mVisibleNodes.get(position);
} @Override
public long getItemId(int position) {
return position;
} @Override
public View getView(int position, View view, ViewGroup viewGroup) {
Node node=mVisibleNodes.get(position);
view=getConvertView(node,position,view,viewGroup);
//设置内边距
view.setPadding(30*node.getLevel(),3,3,3);
return view;
} /**
* 设置点击展开或者收缩
*
* @param position
*/
private void expandOrCollapse(int position) {
Node node = mVisibleNodes.get(position);
if (node != null) {
if (node.isLeft())
return;
node.setExpand(!node.isExpand());
mVisibleNodes=TreeHelp.filterVisibleNodes(mAllNodes);
notifyDataSetChanged();
}
} @Override
public void onItemClick(AdapterView<?> adapterView, View view, int position, long l) {
expandOrCollapse(position);
if (onTreeNodeClickListener!=null){
onTreeNodeClickListener.setOnClick(mVisibleNodes.get(position),position);
}
} public void setOnTreeNodeClickListener(OnTreeNodeClickListener onTredNodeClickListener){
this.onTreeNodeClickListener=onTredNodeClickListener;
} /**
* 设置node的点击回调
*/
public interface OnTreeNodeClickListener{
void setOnClick(Node node, int position);
} public abstract View getConvertView(Node node,int position, View view, ViewGroup viewGroup);
}

package com.example.keranbin.testdemo; import android.content.Context;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView; import com.example.keranbin.testdemo.treeHelp.Node;
import com.example.keranbin.testdemo.treeHelp.TreeListViewAdapter; import java.util.ArrayList;
import java.util.List; /**
* Created by keranbin on 2016/8/30.
*/
public class CheckBoxTreeListViewAdapter<T> extends TreeListViewAdapter {
//判断checkbox是否是单选的标志
private boolean isSingle = true; private static List<Node> nodeList; private OnTreeNodeChooseListener onTreeNodeChooseListener; /**
* @param context 上下文对象
* @param listView
* @param datas
* @param defaultExpandLevel 默认初始化时展开几层
* @param isSingle checkbox是不是单选的
* @throws IllegalAccessException
*/
public CheckBoxTreeListViewAdapter(Context context, ListView listView, List<T> datas, int defaultExpandLevel, boolean isSingle) throws IllegalAccessException {
super(context, listView, datas, defaultExpandLevel);
this.isSingle = isSingle;
} @Override
public View getConvertView(final com.example.keranbin.testdemo.treeHelp.Node node, int position, View view, ViewGroup viewGroup) {
ViewHolder vh=null;
if (view == null) {
vh = new ViewHolder();
view = inflater.inflate(R.layout.lv_tree_item, viewGroup, false);
vh.ivIcon = (ImageView) view.findViewById(R.id.iv_tree_icon);
vh.tvName = (TextView) view.findViewById(R.id.tv_tree_title);
vh.cbChoose = (CheckBox) view.findViewById(R.id.cb_tree_choose);
view.setTag(vh);
} else {
vh = (ViewHolder) view.getTag();
} //如果node的icon为-1,说明是叶子节点，隐藏图标，显示checkbox，否则显示相应的图标，隐藏checkbox
if (node.getIcon() == -1) {
vh.ivIcon.setVisibility(View.INVISIBLE);
vh.cbChoose.setVisibility(View.VISIBLE);
vh.cbChoose.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean isCheck) {
if (isSingle) { //如果checkbox是单选的
if (isCheck) { //如果checkbox的状态是选中的，那么除了被选中的那条数据，其他Node节点的checkbox状态都为false
for (int i = 0; i < mAllNodes.size(); i++) {
if (((Node) mAllNodes.get(i)).getId().equals(node.getId())) {
((Node) mAllNodes.get(i)).setChoose(isCheck);
} else {
((Node) mAllNodes.get(i)).setChoose(false);
}
}
} else {//如果checkbox的状态是选中的，所有Node节点checkbox状态都为false
for (int i = 0; i < mAllNodes.size(); i++) {
if (((Node) mAllNodes.get(i)).getId().equals(node.getId())) {
((Node) mAllNodes.get(i)).setChoose(isCheck);
}
}
}
} else { ////如果checkbox是多选的，对应node节点的checkbox状态视用户的操作而定
for (int i = 0; i < mAllNodes.size(); i++) {
if (((Node) mAllNodes.get(i)).getId().equals(node.getId()))
((Node) mAllNodes.get(i)).setChoose(isCheck); }
}
onTreeNodeChooseListener.OnTreeNodeChoose(getSelectedNodes());//回调所选择的节点数据给用户
notifyDataSetChanged();
}
});
vh.cbChoose.setChecked(node.isChoose());
} else {
vh.ivIcon.setVisibility(View.VISIBLE);
vh.ivIcon.setImageResource(node.getIcon());
vh.cbChoose.setVisibility(View.INVISIBLE);
}
vh.tvName.setText(node.getName());
return view;
} /**
* 返回所选node集合
* @return
*/
public List<Node> getSelectedNodes(){
nodeList=new ArrayList<>();
for(int i=0;i<mAllNodes.size();i++){
if(((Node)mAllNodes.get(i)).isChoose()){
nodeList.add((Node) mAllNodes.get(i));
}
}
return nodeList;
} public void setOnTreedNodeChooseListener(OnTreeNodeChooseListener onTreeNodeChooseListener) {
this.onTreeNodeChooseListener = onTreeNodeChooseListener;
} public interface OnTreeNodeChooseListener {
void OnTreeNodeChoose(List<Node> nodes);
} class ViewHolder {
private ImageView ivIcon;
private TextView tvName;
private CheckBox cbChoose;
}
}