(原创)无限级可分类的分类表ADT的实现(4)

 源码下载地址: http://www.javaall.com/resource/news.rar

  我最初写这个程序的目的是为了实现新闻系统的无限级可分类

   实际无论是新闻也好,产品也好,都可以利用该分类程序.

   这是分类表ADT的实现

package com.news.entity;

import java.util.ArrayList;

import com.news.entity.MenuTree;
import com.news.entity.NewsClass;

public class InfoClass implements InfoBase{
   private MenuTree root;
   private int numItems;
   //树的根节点
   public InfoClass(){
    root = new MenuTree();
    numItems = 0;
   }
   public InfoClass(NewsClass newsClass){
    root = new MenuTree(newsClass);
    numItems = 0;
   }
   /**
    * 用对象的ArrayList数组初始化一个分类表ADT
    * 初试化根节点
    * 完成从数据库记录集到分列表ADT的记录集的转化
    * @param list
    */
   public InfoClass(ArrayList list){
    //初试化根节点
    root = new MenuTree();
    numItems = list.size();
    //完成从数据库记录集到分列表ADT的记录集的转化
    for (int i = 0; i < list.size(); i++) {
   init((NewsClass)list.get(i));
    }
   }
   public int size(){
    return this.numItems;
   }

   public MenuTree remove(Integer index){
    MenuTree result = null;
    //得到目标子树
    MenuTree desNode = getChild(root,index);
    ArrayList list = this.getChild(index);
    if(desNode!=null){
    result = new MenuTree(desNode.getItem());
    //得到父树
    Integer parentID = desNode.getItem().getParentID();
    MenuTree parentNode =  getChild(root,parentID);
    //从父树的子树中删除该树
    parentNode.childs.remove(desNode);
    //更新父树至到顶级父类的child值,减1
    this.changeChildValue(desNode,result,"minus",list.size());
    //更新所有该目标树以后的ORDER值
    this.changeOrderID(root,desNode,result,"minus",list.size());
    }
    return result;
   
   }
   //更新父类一直到顶级的child值
   private void changeChildValue(MenuTree newNode,MenuTree result,String action,int size){
    Integer currClassID = newNode.getItem().getParentID();
    //System.out.println(currClassID);
    MenuTree currNode = getChild(root,currClassID);
    if(!currNode.equals(root)){
     int child = 0;
     if(action.equals("add")){
        child = currNode.getItem().getChild().intValue()+size;
     }
     else{
     if(action.equals("minus")){
        child = currNode.getItem().getChild().intValue()-size;
     }
     }
    // System.out.println(child);
     currNode.getItem().setChild(new Integer(child));
     result.childs.add(new MenuTree(currNode.getItem()));
     changeChildValue(currNode,result,action,size);
    }
   }
   private void changeOrderID(MenuTree root ,MenuTree newNode,MenuTree updateNode,String action,int size){
  
    if((root.getItem().getOrderID().intValue()>=newNode.getItem().getOrderID().intValue()&&(!newNode.equals(root)))){
     int orderid = 0;
     if(action.equals("add")){
        orderid = root.getItem().getOrderID().intValue()+size;
     }
     else{
     if(action.equals("minus")){
       orderid = root.getItem().getOrderID().intValue()-size;
     }
     }
     root.getItem().setOrderID(new Integer(orderid));
     updateNode.childs.add(new MenuTree(root.getItem()));
    
    }
  
    for(int i = 0 ; i<root.childs.size() ; i++){
     MenuTree node = (MenuTree)root.childs.get(i);
     changeOrderID(node ,newNode,updateNode,action,size);
    
    }
   }
   /**
    * 完成从数据库的一条记录到分类表ADT的一条记录的转化
    * @param newsClass
    */
   public void init(NewsClass newsClass){
    //封装为子树
    MenuTree node = new MenuTree(newsClass);
    //System.out.println(node.getItem().getClassID());
    //得到父树
    MenuTree parentNode = getChild(this.root,newsClass.getParentID());
  
    //将子树添加到父树
    if(parentNode!=null){
       parentNode.childs.add(node);
    }
    //分类表ADT的记录的个数加1
  
   }
   //更新分类表记录ADT的Orderid和Childid
   public MenuTree update(NewsClass newsClass){
    /**
     * MenuTree result封装所有的插入一条新记录而受影响的记录
     * result.item: 新记录
     * result.childs: 其他所有受影响的记录
     */
    MenuTree result = null;
    //得到新子树
    MenuTree node = new MenuTree(newsClass);
 
    if(newsClass.getParentID().intValue()==0){
     int depth = root.getItem().getDepth().intValue()+1;
     node.getItem().setDepth(new Integer(depth));
     //更新新子树的排序
     int orderid = numItems + 1;
     node.getItem().setOrderID(new Integer(orderid));
     //System.out.println(orderid);
     //将新子树添加到父树
     root.childs.add(node);
     numItems++;
     result = new MenuTree(node.getItem());
     return result;
    }
    else{
    //得到父树
    MenuTree parentNode = getChild(this.root,newsClass.getParentID());
    //更新新子树的层数
    int depth = parentNode.getItem().getDepth().intValue()+1;
    node.getItem().setDepth(new Integer(depth));
    //更新新子树的排序
    int orderid = parentNode.getItem().getOrderID().intValue()+parentNode.getItem().getChild().intValue()+1;
    //System.out.println(orderid);
    node.getItem().setOrderID(new Integer(orderid));
    //将新子树添加到父树
    parentNode.childs.add(node);
    //将新记录封装到MenuTree
    result = new MenuTree(node.getItem());
    //更新父树至到顶级父类的child属性,即数据加1
    this.changeChildValue(node,result,"add",1);
    //更新父树以后所有的树的orderid
    //初始化受影响的栏目树
    //result.childs.add(new MenuTree(parentNode.getItem()));
    this.changeOrderID(root ,node,result,"add",1);
    //分类表ADT的记录的个数加1
   
    numItems++;
    return result;
    }
   }
   public MenuTree changeParentID(Integer oldParentid,Integer newParentid){
    MenuTree result = null;
    return result;
   }
   public MenuTree add(NewsClass newsClass){
    /**
     * MenuTree result封装所有的插入一条新记录而受影响的记录
     * result.item: 新记录
     * result.childs: 其他所有受影响的记录
     */
    MenuTree result = null;
    //得到新子树
    MenuTree node = new MenuTree(newsClass);
    //System.out.println(numItems);
    if(newsClass.getParentID().intValue()==0){
     int depth = root.getItem().getDepth().intValue()+1;
     node.getItem().setDepth(new Integer(depth));
     //更新新子树的排序
     int orderid = numItems + 1;
     node.getItem().setOrderID(new Integer(orderid));
     //System.out.println(orderid);
     //将新子树添加到父树
     root.childs.add(node);
     numItems++;
     result = new MenuTree(node.getItem());
     return result;
    }
    else{
    //得到父树
    MenuTree parentNode = getChild(this.root,newsClass.getParentID());
    //更新新子树的层数
    int depth = parentNode.getItem().getDepth().intValue()+1;
    node.getItem().setDepth(new Integer(depth));
    //更新新子树的排序
    int orderid = parentNode.getItem().getOrderID().intValue()+parentNode.getItem().getChild().intValue()+1;
    System.out.println(orderid);
    node.getItem().setOrderID(new Integer(orderid));
    //将新子树添加到父树
    parentNode.childs.add(node);
    //将新记录封装到MenuTree
    result = new MenuTree(node.getItem());
    //更新父树至到顶级父类的child属性,即数据加1
    this.changeChildValue(node,result,"add",1);
    //更新父树以后所有的树的orderid
    //初始化受影响的栏目树
    //result.childs.add(new MenuTree(parentNode.getItem()));
    this.changeOrderID(root ,node,result,"add",1);
    //分类表ADT的记录的个数加1
   
    numItems++;
    return result;
    }
   }
   //根据ID值得到子树
   private MenuTree getChild(MenuTree root ,Integer classID){
    MenuTree result = null;
    if(root.getItem().classID.equals(classID)){
     return root;
    }
    else{
     for(int i = 0 ; i<root.childs.size() ; i++){
      MenuTree node = (MenuTree)root.childs.get(i);
      result = getChild(node ,classID);
      if (result != null){
       return result ;
      }
     }
     return result;
    }
   }
   //得到的子树封装成ArrayList
   public ArrayList getChild(Integer classID){
    ArrayList list = null;
    MenuTree node = this.getChild(root ,classID);
    if(node!=null){
    list = new ArrayList();
       this.getChildArrayList(node,list);
    }
    return list;
   }
   public MenuTree getRoot(){
    return this.root;
   }
   //遍历子树,得到子树所有的项
   private void getChildArrayList(MenuTree root,ArrayList list)
   {    if(root!=null){
        NewsClass temp=new NewsClass();
     temp.setClassID(root.getItem().getClassID());
     temp.setClassName(root.getItem().getClassName());
     temp.setChild(root.getItem().getChild());
     temp.setParentID(root.getItem().getParentID());
     temp.setDisplay(root.getItem().getDepth().intValue(),root.getItem().getClassName());
     temp.setListDisplay(root.getItem().getDepth().intValue());
     list.add(temp);
        for(int i=0;i<root.childs.size();i++)
        {
        MenuTree child =(MenuTree)root.childs.get(i);
        getChildArrayList(child,list);   
        }
   }
    
   }
   //删除所有子树,只保留跟节点
   public void removeAll(){
    root = new MenuTree();
    numItems = 0;
   }
  
   public void write(){
   this.root.write();
   }
   //判断树是否包含子树
   //返回0,表示不包含
   //返回1,表示是树本身
   //返回2,表示是包含子树
   public int hasChild(MenuTree root,Integer classID){
    MenuTree node = getChild(root,classID);
    if( node!= null){
     if(node.equals(root)){
        return 1;
     }
     else{
     return 2;
     }
    }
    else{
     return 0;
    }
   }
   public boolean move(Integer index,Integer classID){
    boolean result = false;
    MenuTree currNode = this.getChild(root,index);
    //如果源树包含目标父树,则不能执行操作
    if(hasChild(currNode,classID)==2){
     System.out.println("erter");
     return false;
    
    }
    else{
    Integer oldParentID = currNode.getItem().getParentID();
    if(!oldParentID.equals(classID)){
    MenuTree oldParentNode = this.getChild(root,oldParentID);
    oldParentNode.childs.remove(currNode);
    currNode.getItem().setParentID(classID);
    MenuTree parentNode = this.getChild(root,classID);
    parentNode.childs.add(currNode);
    }
        return true;
    }
   }
   public MenuTree move(Integer classid,NewsClass newNewsClass){
    MenuTree result = null;
    MenuTree currNode = this.getChild(root,classid);
    Integer oldParentID = currNode.getItem().getParentID();
    Integer newParentID = newNewsClass.getParentID();
    if(!oldParentID.equals(newParentID)){
    MenuTree oldParentNode = this.getChild(root,oldParentID);
    oldParentNode.childs.remove(currNode);
    currNode.getItem().setClassName(newNewsClass.getClassName());
    currNode.getItem().setParentID(newParentID);
    MenuTree parentNode = this.getChild(root,newParentID);
    parentNode.childs.add(currNode);
    }
    return result;
   }
   public MenuTree move(Integer index,String action){
   MenuTree result = null;
   MenuTree node = null;
   MenuTree parentNode = null;
   ArrayList childList = null;
   //得到子树
   node = this.getChild(root,index);
   if(node!=null){
    parentNode = this.getChild(root,node.getItem().getParentID());
   }
   if(action.equals("up")){
    if(parentNode!=null){
     childList = parentNode.childs;
        if(((MenuTree)childList.get(0)).equals(node)){
         return null;
        }
        else{
         //取得源树在父树中的位置
         int location = 0;
         for(int i=0;i<childList.size();i++){
          if(((MenuTree)childList.get(i)).equals(node)){
           location = i;
          }
        
         }
         //System.out.println(location);
         result = new MenuTree(node.getItem());
         //得到上移的位数
         int srcOrder = node.getItem().getOrderID().intValue();
         int desOrder = ((MenuTree)childList.get(location-1)).getItem().getOrderID().intValue();
         int srcChild = node.getItem().getChild().intValue();
         int desChild = ((MenuTree)childList.get(location-1)).getItem().getChild().intValue();
         //得到上移的位数
         int upSize = desChild+1;
         //System.out.println(upSize);
         //源树上移
         trans(node,"up",result,upSize);
         //System.out.println(node.getItem().getOrderID());
         //得到上移的位数
         int downSize = srcOrder - desOrder + srcChild - desChild ;
         //System.out.println(downSize);
        
         //目标树下移
         trans((MenuTree)childList.get(location-1),"down",result,downSize);
            //交换在childs中的位置
         childList.set(location,(MenuTree)childList.get(location-1));
         childList.set(location-1,node);
        }
      
    }
   }
   else{
    if(action.equals("down")){
     if(parentNode!=null){
      childList = parentNode.childs;
         if(((MenuTree)childList.get(childList.size()-1)).equals(node)){
          return null;
         }
         else{
          //取得源树在父树中的位置
          int location = 0;
          for(int i=0;i<childList.size();i++){
           if(((MenuTree)childList.get(i)).equals(node)){
            location = i;
           }
         
          }
          //System.out.println(location);
          result = new MenuTree(node.getItem());
          //得到上移的位数
          int srcOrder = node.getItem().getOrderID().intValue();
          int desOrder = ((MenuTree)childList.get(location+1)).getItem().getOrderID().intValue();
          int srcChild = node.getItem().getChild().intValue();
          int desChild = ((MenuTree)childList.get(location+1)).getItem().getChild().intValue();
          //得到上移的位数
          int upSize = srcChild+1;
          //System.out.println(upSize);
          //目标树上移
          trans((MenuTree)childList.get(location+1),"up",result,upSize);
          //System.out.println(node.getItem().getOrderID());
          //得到上移的位数
          int downSize = desOrder-srcOrder+ desChild-srcChild  ;
          //System.out.println(downSize);
         
          //目标树下移
          trans(node,"down",result,downSize);
             //交换在childs中的位置
          childList.set(location,(MenuTree)childList.get(location+1));
          childList.set(location+1,node);
         }
       
     }
    }
   }
   return result;
   }
   public void trans(MenuTree srcNode,String action,MenuTree updateNode,int size){
    int orderid = srcNode.getItem().getOrderID().intValue();
    if(action.equals("up")){
     orderid = orderid-size;
     srcNode.getItem().setOrderID(new Integer(orderid));
     updateNode.childs.add(new MenuTree(srcNode.getItem()));
    }
       else{
        orderid = orderid+size;
     srcNode.getItem().setOrderID(new Integer(orderid));
     updateNode.childs.add(new MenuTree(srcNode.getItem()));
    }
    for(int i = 0 ; i<srcNode.childs.size() ; i++){
     MenuTree node = (MenuTree)srcNode.childs.get(i);
     trans(node ,action,updateNode,size); 
    }
   }
   public static void main(String args[]){
    InfoClass infoClass = new InfoClass();
    NewsClass newsClass = new NewsClass();
    newsClass.setParentID(new Integer("0"));
    newsClass.setClassID(new Integer("1"));
    newsClass.setChild(new Integer("0"));
    newsClass.setClassName("首页");
    infoClass.add(newsClass);
 
    NewsClass newsClass1 = new NewsClass();
    newsClass1.setParentID(new Integer("1"));
    newsClass1.setClassID(new Integer("2"));
    newsClass1.setChild(new Integer("0"));
    newsClass1.setClassName("二级首页");
    infoClass.add(newsClass1);
    NewsClass newsClass2 = new NewsClass();
    newsClass2.setParentID(new Integer("0"));
    newsClass2.setClassID(new Integer("3"));
    newsClass2.setChild(new Integer("0"));
    newsClass2.setClassName("信息中心");
    infoClass.add(newsClass2);
    System.out.println(infoClass.size());
    infoClass.write();
  
   }
public int getNumItems() {
 return numItems;
}
public void setNumItems(int numItems) {
 this.numItems = numItems;
}
}

阅读更多
个人分类: java原创
上一篇(原创)无限级可分类的分类表ADT的实现(3)
下一篇2005.12.20 离职
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭