v5browser

新概念智能树形菜单--利用加权多叉树结合JavaScript树形控件实现

一、智能树形菜单的概念
在描述智能树形菜单的概念之前，请先阅读我的上一篇文章 《多叉树结合JavaScript树形控件实现无限级树形菜单（一种构建多级有序树形结构JSON（或XML）数据源的方法）》，请点击链接查看： http://www.iteye.com/topic/1122125，阅读完上一篇文章之后，再继续向下阅读，因为这两篇文章是紧密联系、前后关联的，谢谢。

大家都知道树形菜单，不管在基于什么样的技术开发的系统上，树形菜单都是用户界面中非常常用的一种菜单形式，在目前市场上常见的JavaScript框架及组件库中均包含自己的树形控件，例如JQuery、Dojo、Yahoo UI、Ext JS等，还有一些独立的树形控件，例如dhtmlxtree等，这些树形控件完美的解决了层次数据的展示问题。那么树形菜单发展到现在就算完美了吗？还有没有进一步的发展空间呢？还有没有进一步的完善空间呢？答案是肯定的。在这篇文章里，我提出一种新的想法对树形菜单进行扩展，也许会给您的项目带来一些新的用户体验，我管这种扩展型的树形菜单叫做“智能树形菜单”。那么智能树形菜单和普通的树形菜单到底有什么区别呢，它到底智能在哪呢，让我们先来看一组用例场景：

网民高小宝是一名网上银行的忠实用户，他经常利用网银办理各种银行业务，假设高小宝在
某某银行开通了网上银行功能，他回到家之后，想试验一下这个新的网银系统，于是他首次登录了某某银行的网上银行，登录成功后，系统展示界面如下所示（简略概要图）：
图1.1

他想给自己的朋友李小磊转一笔钱，于是他在界面左上角的“输入交易功能关键字”输入框中输入“转账”二字，点击“搜索”按钮，查询出了如下的结果，如图：
图1.2

他看到左侧的树形菜单区域中搜索出了三个交易功能，分别是行内转账、跨行转账和跨行快速转账，于是他点击跨行转账后，主界面进入跨行转账信息录入界面，高小宝很快完成了转账操作，如下图：
图1.3

高小宝一看，这个银行的网上银行系统操作这么方便，于是他又陆续使用了以下几个功能，分别是“投资理财->定活互转”、“投资理财->理财产品->产品购买”、“我的贷款->贷款信息查询”、“客户服务->昵称设置”，本次登录他一共使用了五个功能点，其中“转账汇款->跨行转账”功能使用了两次，一次是给朋友李小磊转钱，另一次是给朋友王小然转钱，其他四个功能各使用了一次。

第二天，高小宝又登录了网上银行系统，登录成功后，他看到系统的操作界面和第一次登录时不太一样了，变成了如下样子：
图1.4

他看到昨天使用的五个功能点菜单全部自动展开了，而且菜单顺序也发生了变化：原来排在最后的一级菜单“客户服务”居然移到了“我的贷款”下面，而原来排在第一位的“账户管理”却移到了“客户服务”下面，由于部分菜单自动展开，所以菜单栏右侧出现了滚动条。
不光一级菜单的顺序发生了变化，二级菜单的顺序也发生了变化，原来在“转账汇款”下面的子菜单中，“跨行转账”排在“行内转账”下面，现在却排在了第一位。不光菜单发生了变化，中间主界面也发生了变化，原来是欢迎界面，现在变成了“跨行转账”信息录入界面。
高小宝一看，正合我意，他正想给朋友吴艳清转一笔钱，吴艳清的开户行是工商银行，不是本行，正好需要使用跨行转账功能，于是他很快完成了转账操作。他今天还想通过“定活互转”功能，存一笔定期，由于昨天使用了一次该功能，所以这个功能也默认自动展开，他很容易就看到了这个菜单项，顺利完成了存定期的操作，也就是说功能使用率大于平均功能使用率的功能节点自动展开了（假设有10个功能，功能A和功能B分别被使用了3次和2次，其它功能都被使用了1次，那么平均使用率是（3+2+8）/ 10 = 1.3次，A和B的使用率大于平均使用率，自动展开，其他8个功能的使用率小于1.3，不展开），真智能啊！高小宝心想，看来以后得多多使用网上银行了，太方便了。

好了，读者朋友们，通过上面这组用例场景，相信您已经看出了本文要论述的主题内容，对了，这就是智能树形菜单，现在我们给智能树形菜单下一个完整科学的定义，

智能树形菜单满足如下几个条件：

Html代码

A、用户首次登录系统时，功能菜单树全部闭合，并且按照菜单编号排序，且每一层菜单节点都按照这个规则排序，保持整棵功能树兄弟节点横向有序（关于“兄弟节点横向有序”的概念请查看附录：我的上一篇文章《多叉树结合JavaScript树形控件实现无限级树形菜单（一种构建多级有序树形结构JSON（或XML）数据源的方法）》）；
B、系统会自动记录每一个功能路径（功能路径指的是由一级菜单节点到功能叶子节点的一条完整路径，例如“投资理财->理财产品->产品购买”就是一条功能路径）的使用率；
C、系统提供菜单节点搜索功能，用户可以输入菜单节点关键字，系统会搜索出包含关键字的所有功能路径，并展示出搜索结果；
D、用户再次登录系统时，功能菜单重新排序，并且部分展开，其规则如下：
（1）整棵功能菜单树按照使用率加节点编号的方式排序，先按使用率排序，使用率相同的情况下按照节点编号排序，保持兄弟节点横向有序；
（2）热点功能自动展开（热点功能指的是功能使用率大于所有功能平均使用率的功能叶子节点，例如在上面的用例场景中，高小宝第一次使用网银时，“跨行转账”被使用了两次，“定活互转”、“产品购买”、“贷款信息查询”、“昵称设置”都被使用了一次，其他功能被使用了零次，假设一共有30个功能，那么功能平均使用率是（2+1+1+1+1）/ 30 = 0.2，这五个功能的使用率均大于0.2，所以都属于热点功能）
E、系统主界面默认进入焦点功能（焦点功能指的是热点功能中使用率最高的功能）的操作界面；

A、用户首次登录系统时，功能菜单树全部闭合，并且按照菜单编号排序，且每一层菜单节点都按照这个规则排序，保持整棵功能树兄弟节点横向有序（关于“兄弟节点横向有序”的概念请查看附录：我的上一篇文章《多叉树结合JavaScript树形控件实现无限级树形菜单（一种构建多级有序树形结构JSON（或XML）数据源的方法）》）；

B、系统会自动记录每一个功能路径（功能路径指的是由一级菜单节点到功能叶子节点的一条完整路径，例如“投资理财->理财产品->产品购买”就是一条功能路径）的使用率；

C、系统提供菜单节点搜索功能，用户可以输入菜单节点关键字，系统会搜索出包含关键字的所有功能路径，并展示出搜索结果；

D、用户再次登录系统时，功能菜单重新排序，并且部分展开，其规则如下：
（1）整棵功能菜单树按照使用率加节点编号的方式排序，先按使用率排序，使用率相同的情况下按照节点编号排序，保持兄弟节点横向有序；
（2）热点功能自动展开（热点功能指的是功能使用率大于所有功能平均使用率的功能叶子节点，例如在上面的用例场景中，高小宝第一次使用网银时，“跨行转账”被使用了两次，“定活互转”、“产品购买”、“贷款信息查询”、“昵称设置”都被使用了一次，其他功能被使用了零次，假设一共有30个功能，那么功能平均使用率是（2+1+1+1+1）/ 30 = 0.2， 这五个功能的使用率均大于0.2，所以都属于热点功能）

E、系统主界面默认进入焦点功能（焦点功能指的是热点功能中使用率最高的功能）的操作界面；

好了，智能树形菜单的概念就介绍完了，下面讲述详细实现方案。

二、详细实现方案
在《多叉树结合JavaScript树形控件实现无限级树形菜单（一种构建多级有序树形结构JSON（或XML）数据源的方法）》一文中，谈到了多叉树，智能树形菜单就可以在多叉树的基础上进行扩展，实现概念定义中所描述的所有功能，下面介绍详细设计方案。

下面这张图就是扩展之后的多叉树，并且根据这张图定义了一系列名词概念，如图所示：
图1.5

我们先根据这张图定义一组名词概念：
1、菜单树
所有菜单可以抽象成一棵菜单树，为了保持树的完整性，在一级菜单上面加了一个虚拟的根节点，每个节点由两个值组成，用逗号分割，前一个值是菜单节点编号，后一个值是节点权值，默认权值都为1。

2、节点权值
为了描述某一个节点在其兄弟节点之中的优先级（也就是功能使用率），用一个数值来表示，就叫节点权值。

3、功能叶子节点
菜单树中的叶子节点，下面不再下挂其他子功能节点。

4、功能路径
由根节点到功能叶子节点的一条完整路径，例如图中的蓝色线条部分，即 “根->3->32->323”就是一条功能路径，上图的菜单树中共有13条功能路径，您可以数一数，呵呵。

5、功能路径权值
功能路径权值由功能路径中所有节点的权值由父到子拼接而成，例如路径“根->3->32->323”的路径权值是“111”。

6、优先功能路径
指的是功能路径权值最高的那一条路径，如上图菜单树中的红色线条部分，该路径为“根->1->11”，它的路径权值是“32”。路径权值比较的规则是逐级比较，“32”的第一级是3，“111”的第一级是1，所以“32”大于“111”，路径权值相同时比较节点编号，也就是用权值加节点编号进行比较，例如路径“根->1->11”和路径“根->1->12->121”，它们的路径权值分别是“32”和“322”，当比较到第二级时，节点权值都是2，但是由于节点11比节点12的编号小，所以节点11排列在节点12前面，也就是说功能路径“根->1->11”的优先级排在“根->1->12->121”之前。

7、功能叶子列表
当构造好一棵菜单树后，通过深度优先先序遍历，找到所有叶子节点，并将其存放在一个列表里面，这个列表叫做功能叶子列表。

8、功能叶子权值
功能叶子节点的权值叫做功能叶子权值。

9、热点功能叶子
功能叶子权值大于所有功能叶子节点的平均权值的叶子节点，例如上图中功能叶子列表中的前两个节点：11和121，其权值分别是2和2，而叶子节点的平均权值是1.15，用数学语言描述就是权值大于加权平均数的功能叶子节点。

10、焦点功能叶子
热点功能叶子中权值最高的叶子叫做焦点功能叶子，如果权值相等，则比较节点编号，节点编号优先的叶子为焦点功能叶子。

11、功能路径可见
在菜单节点中增加一个“是否可见”属性，如果一条功能路径中所有节点的“是否可见”属性为true，那么称该条路径可见，否则该条路径不可见，所谓不可见，指的是不向用户展示这条功能路径。

12、菜单节点搜索
指的是在整棵功能树的所有节点中按照节点关键字查找包含该关键字的菜单节点。

13、功能路径筛选
指的是对整棵树的功能路径的可见性进行重新设置，首先将所有节点设置为不可见，然后根据菜单节点的搜索结果，将包含该菜单节点的所有功能路径设置为可见，也就是向用户展示菜单节点搜索的结果。

14、增加功能路径权值
指的是将包含某一功能叶子节点的一条完整功能路径上的所有节点的权值增加相同的幅度（例如将某一功能路径上的所有节点权值加1）。

我们可以把这棵加了节点权值的多叉树叫做加权多叉树，英文名称叫weighted multiple tree，简称W-M-Tree。

好了，定义完名词概念之后，用下面一组图来展示加权多叉树的变化过程。

图一，用户首次登录系统时，在服务器端构造出加权多叉树和功能叶子列表：
图1.6

其中黄色圆圈代表功能叶子节点。

构造出这棵树之后，向客户端的JavaScript树形控件返回树形结构的JSON字符串，返回如下内容：

Js代码

{
id: '0',
text: '根',
children: [
{
id: '1',
text: '1',
children: [
{
id: '11',
text: '11',
leaf: true
},
{
id: '12',
text: '12',
children: [
{
id: '121',
text: '121',
leaf: true
},
{
id: '122',
text: '122',
leaf: true
},
{
id: '123',
text: '123',
leaf: true
}
]
}
]
},
{
id: '2',
text: '2',
children: [
{
id: '21',
text: '21',
leaf: true
},
{
id: '22',
text: '22',
leaf: true
}
]
},
{
id: '3',
text: '3',
children: [
{
id: '31',
text: '31',
leaf: true
},
{
id: '32',
text: '32',
children: [
{
id: '321',
text: '321',
leaf: true
},
{
id: '322',
text: '322',
leaf: true
},
{
id: '323',
text: '323',
leaf: true
}
]
}
]
},
{
id: '4',
text: '4',
children: [
{
id: '41',
text: '41',
leaf: true
},
{
id: '42',
text: '42',
leaf: true
},
{
id: '43',
text: '43',
leaf: true
}
]
}
]
}

{
  id: '0',
  text: '根',
  children: [
    {
      id: '1',
      text: '1',
      children: [
        {
          id: '11',
          text: '11',
          leaf: true
        },
        {
          id: '12',
          text: '12',
          children: [
            {
              id: '121',
              text: '121',
              leaf: true
            },
            {
              id: '122',
              text: '122',
              leaf: true
            },
            {
              id: '123',
              text: '123',
              leaf: true
            }
          ]
        }
      ]
    },
    {
      id: '2',
      text: '2',
      children: [
        {
          id: '21',
          text: '21',
          leaf: true
        },
        {
          id: '22',
          text: '22',
          leaf: true
        }
      ]
    },
    {
      id: '3',
      text: '3',
      children: [
        {
          id: '31',
          text: '31',
          leaf: true
        },
        {
          id: '32',
          text: '32',
          children: [
            {
              id: '321',
              text: '321',
              leaf: true
            },
            {
              id: '322',
              text: '322',
              leaf: true
            },
            {
              id: '323',
              text: '323',
              leaf: true
            }
          ]
        }
      ]
    },
    {
      id: '4',
      text: '4',
      children: [
        {
          id: '41',
          text: '41',
          leaf: true
        },
        {
          id: '42',
          text: '42',
          leaf: true
        },
        {
          id: '43',
          text: '43',
          leaf: true
        }
      ]
    }
  ]
}

图二，用户使用关键字“12”在功能叶子列表中进行搜索，并将包含搜索结果的功能路径设置为可见，其他路径设置为不可见，图中红色线条部分为可见路径，其他的为不可见路径，如图所示：
图1.7

进行功能路径筛选后，向客户端返回如下JSON字符串：

Js代码

{
id: '0',
text: '根',
children: [
{
id: '1',
text: '1',
children: [
{
id: '12',
text: '12',
children: [
{
id: '121',
text: '121',
leaf: true
},
{
id: '122',
text: '122',
leaf: true
},
{
id: '123',
text: '123',
leaf: true
}
]
}
]
}
]
}

{
  id: '0',
  text: '根',
  children: [
    {
      id: '1',
      text: '1',
      children: [
        {
          id: '12',
          text: '12',
          children: [
            {
              id: '121',
              text: '121',
              leaf: true
            },
            {
              id: '122',
              text: '122',
              leaf: true
            },
            {
              id: '123',
              text: '123',
              leaf: true
            }
          ]
        }
      ]
    }
  ]
}

图三，用户再使用关键字“321”在功能叶子列表中进行搜索，搜索结果如图所示：
图1.8

进行功能路径筛选后，向客户端返回如下JSON字符串：

Js代码

{
id: '0',
text: '根',
children: [
{
id: '3',
text: '3',
children: [
{
id: '32',
text: '32',
children: [
{
id: '321',
text: '321',
leaf: true
}
]
}
]
}
]
}

{
  id: '0',
  text: '根',
  children: [
    {
      id: '3',
      text: '3',
      children: [
        {
          id: '32',
          text: '32',
          children: [
            {
              id: '321',
              text: '321',
              leaf: true
            }
          ]
        }
      ]
    }
  ]
}

到这里，您一定会问：菜单节点搜索必须要在服务器端进行吗，这样响应速度岂不是很慢？是的，这的确是个问题，那么，该功能能否放在客户端来实现呢？通过改造现有的树形控件或者重新开发新的树形控件，利用JavaScript在客户端来实现菜单节点的搜索功能，而无需与服务器进行交互。比如，能否利用JavaScript在客户端构造一棵多叉树，然后采用类似的方法来实现菜单节点的搜索呢？具体实现方法不是本文讨论的重点，本文只是提供一个思路，具体实现还要看您了，呵呵。

图四，用户使用某个功能后，系统将该功能路径权值加1，并将该功能路径上的所有节点的权值更新到数据库中的菜单节点定义表中，如图所示，路径“根->3->32->323”的权值加1，由“111”变成了“222”：
图1.9

图五，当用户退出，再次登录系统后，在服务器端再次构造出加权多叉树和功能叶子列表，此时数据结构变成如下样子：
图2.0

树中红色线条部分为优先功能路径，功能叶子列表中红色圆圈为焦点功能叶子。

图六，用户再次使用某个功能后，系统将该功能路径权值加1，并将该功能路径上的所有节点的权值更新到数据库中的菜单节点定义表中，如图所示，路径“根->1->12->122”的权值加1，由“111”变成了“222”：
图2.1

图七，当用户退出，再次登录系统后，在服务器端再次构造出加权多叉树和功能叶子列表，此时数据结构变成如下样子：
图2.2

树中红色线条部分根据路径权值和节点编号重新进行了兄弟节点横向排序；
功能叶子列表中红色圆圈为热点叶子，现在有两个热点叶子了，其中122为焦点叶子。

现在服务器向客户端返回的JSON字符串变成了如下：

Js代码

{
id: '0',
text: '根',
children: [
{
id: '1',
text: '1',
children: [
{
id: '12',
text: '12',
children: [
{
id: '122',
text: '122',
leaf: true
},
{
id: '121',
text: '121',
leaf: true
},
{
id: '123',
text: '123',
leaf: true
}
]
},
{
id: '11',
text: '11',
leaf: true
}
]
},
{
id: '3',
text: '3',
children: [
{
id: '32',
text: '32',
children: [
{
id: '323',
text: '323',
leaf: true
},
{
id: '321',
text: '321',
leaf: true
},
{
id: '322',
text: '322',
leaf: true
}
]
},
{
id: '31',
text: '31',
leaf: true
}
]
},
{
id: '2',
text: '2',
children: [
{
id: '21',
text: '21',
leaf: true
},
{
id: '22',
text: '22',
leaf: true
}
]
},
{
id: '4',
text: '4',
children: [
{
id: '41',
text: '43211',
leaf: true
},
{
id: '42',
text: '42',
leaf: true
},
{
id: '43',
text: '43',
leaf: true
}
]
}
]
}

{
  id: '0',
  text: '根',
  children: [
    {
      id: '1',
      text: '1',
      children: [
        {
          id: '12',
          text: '12',
          children: [
            {
              id: '122',
              text: '122',
              leaf: true
            },
            {
              id: '121',
              text: '121',
              leaf: true
            },
            {
              id: '123',
              text: '123',
              leaf: true
            }
          ]
        },
        {
          id: '11',
          text: '11',
          leaf: true
        }
      ]
    },
    {
      id: '3',
      text: '3',
      children: [
        {
          id: '32',
          text: '32',
          children: [
            {
              id: '323',
              text: '323',
              leaf: true
            },
            {
              id: '321',
              text: '321',
              leaf: true
            },
            {
              id: '322',
              text: '322',
              leaf: true
            }
          ]
        },
        {
          id: '31',
          text: '31',
          leaf: true
        }
      ]
    },
    {
      id: '2',
      text: '2',
      children: [
        {
          id: '21',
          text: '21',
          leaf: true
        },
        {
          id: '22',
          text: '22',
          leaf: true
        }
      ]
    },
    {
      id: '4',
      text: '4',
      children: [
        {
          id: '41',
          text: '43211',
          leaf: true
        },
        {
          id: '42',
          text: '42',
          leaf: true
        },
        {
          id: '43',
          text: '43',
          leaf: true
        }
      ]
    }
  ]
}

对于热点功能叶子自动展开，和系统默认进入焦点功能界面这两个功能，只需要客户端通过AJAX的方式从服务器端的功能叶子列表中取出热点功能叶子和焦点功能叶子的节点编号后，在客户端通过编程处理，取热点功能叶子的方法很简单，只需要取出叶子权值大于叶子平均权值的节点即可，然后再找到一个权值最大的叶子就是焦点功能叶子；至于如何展开树形控件的叶子节点本文不做叙述，那是树形控件要实现的功能。

三、源代码实现（服务器端JAVA代码演示）

以下代码拷贝出来后可以直接运行测试（注：关于菜单节点搜索功能，这里用java来演示，在服务器端进行，系统响应速度很慢，应该放在客户端实现）：

Java代码

package test;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Collections;
/**
* 功能菜单树类
*/
public class FunctionTree {
public static void main(String[] args) {
// 读取层次数据结果集列表
List dataList = VirtualDataGenerator.getVirtualResult();
// 构造加权多叉树
Node root = buildWeightedMultiTree(dataList);
// 构造功能叶子列表
List functionLeafList = buildFunctionLeafList(root);
// 对多叉树重新进行横向排序
root.sortChildren();
// 输出首次登录后的树形菜单
System.out.println("首次登录时的树形菜单：\n" + root.toString());
// 进行菜单节点搜索（即功能路径筛选）
searchTreeNode(root, "321");
// 输出搜索结果
System.out.println("搜索后的树形菜单：\n" + root.toString());
// 增加功能路径权值
increaseRouteWeight(root, functionLeafList, "122");
increaseRouteWeight(root, functionLeafList, "323");
// 对多叉树重新进行横向排序
root.sortChildren();
// 输出权值变化后的树形菜单
System.out.println("路径权值变化后再次登录时的树形菜单：\n" + root.toString());
// 获取热点功能叶子
List hotFunctionLeaf = getHotFunctionLeaf(functionLeafList);
// 输出热点功能叶子
printHotFunctionLeaf(hotFunctionLeaf);
// 程序输出结果如下：
// 首次登录时的树形菜单：
// {id : '0', text : '根', children : [{id : '1', text : '1', children : [{id : '11', text : '11', leaf : true},{id : '12', text : '12', children : [{id : '121', text : '121', leaf : true},{id : '122', text : '122', leaf : true},{id : '123', text : '123', leaf : true}]}]},{id : '2', text : '2', children : [{id : '21', text : '21', leaf : true},{id : '22', text : '22', leaf : true}]},{id : '3', text : '3', children : [{id : '31', text : '31', leaf : true},{id : '32', text : '32', children : [{id : '321', text : '321', leaf : true},{id : '322', text : '322', leaf : true},{id : '323', text : '323', leaf : true}]}]},{id : '4', text : '4', children : [{id : '41', text : '41', leaf : true},{id : '42', text : '42', leaf : true},{id : '43', text : '43', leaf : true}]}]}
// 搜索后的树形菜单：
// {id : '0', text : '根', children : [{id : '3', text : '3', children : [{id : '32', text : '32', children : [{id : '321', text : '321', leaf : true}]}]}]}
// 路径权值变化后再次登录时的树形菜单：
// {id : '0', text : '根', children : [{id : '1', text : '1', children : [{id : '12', text : '12', children : [{id : '122', text : '122', leaf : true},{id : '121', text : '121', leaf : true},{id : '123', text : '123', leaf : true}]},{id : '11', text : '11', leaf : true}]},{id : '3', text : '3', children : [{id : '32', text : '32', children : [{id : '323', text : '323', leaf : true},{id : '321', text : '321', leaf : true},{id : '322', text : '322', leaf : true}]},{id : '31', text : '31', leaf : true}]},{id : '2', text : '2', children : [{id : '21', text : '21', leaf : true},{id : '22', text : '22', leaf : true}]},{id : '4', text : '4', children : [{id : '41', text : '41', leaf : true},{id : '42', text : '42', leaf : true},{id : '43', text : '43', leaf : true}]}]}
// 热点功能叶子：
// [{id : '323', text : '323', leaf : true}, {id : '122', text : '122', leaf : true}]
}
/**
* 构造加权多叉树
* @return
*/
public static Node buildWeightedMultiTree(List dataList) {
// 节点列表（散列表，用于临时存储节点对象）
HashMap nodeList = new HashMap();
// 根节点
Node root = null;
// 根据结果集构造节点列表（存入散列表）
for (Iterator it = dataList.iterator(); it.hasNext();) {
Map dataRecord = (Map) it.next();
Node node = new Node();
node.id = (String) dataRecord.get("id");
node.text = (String) dataRecord.get("text");
node.parentId = (String) dataRecord.get("parentId");
node.weight = Integer.parseInt((String) dataRecord.get("weight"));
nodeList.put(node.id, node);
}
// 构造无序的多叉树
Set entrySet = nodeList.entrySet();
for (Iterator it = entrySet.iterator(); it.hasNext();) {
Node node = (Node) ((Map.Entry) it.next()).getValue();
if (node.parentId == null || node.parentId.equals("")) {
root = node;
} else {
((Node) nodeList.get(node.parentId)).addChild(node);
// 在节点中增加一个父节点的引用
node.parentNode = (Node) nodeList.get(node.parentId);
}
}
return root;
}
/**
* 构造功能叶子列表
* @param root
* @return
*/
public static List buildFunctionLeafList(Node root) {
List functionLeafList = new ArrayList();
root.initializeLeafList(functionLeafList);
return functionLeafList;
}
/**
* 进行菜单节点搜索（即功能路径筛选）
* @param root
* @param keyWord
*/
public static void searchTreeNode(Node root, String keyWord) {
// 首先设置整棵树的功能路径为不可见
root.setTreeNotVisible();
// 在整棵功能树中搜索包含关键字的节点，并进行路径筛选
root.searchTreeNode(keyWord);
}
/**
* 增加功能路径权值
* @param root
*/
public static void increaseRouteWeight(Node root, List functionLeafList, String nodeId) {
// 首先设置整棵树的功能路径为可见
root.setTreeVisible();
// 对包含功能叶子节点的路径权值加1
for (Iterator it = functionLeafList.iterator(); it.hasNext();) {
Node leafNode = (Node) it.next();
if (leafNode.id.equals(nodeId)) {
leafNode.increaseRouteWeight();
}
}
}
/**
* 获取热点功能叶子
* @param functionLeafList
* @return
*/
public static List getHotFunctionLeaf(List functionLeafList) {
int count = 0;
int totalWeight = 0;
BigDecimal avgWeight;
for (Iterator it = functionLeafList.iterator(); it.hasNext();) {
Node node = (Node) it.next();
totalWeight += node.weight;
count++;
}
avgWeight = (new BigDecimal(totalWeight)).divide(new BigDecimal(count), 2, BigDecimal.ROUND_HALF_UP);
List retList = new ArrayList();
for (Iterator it = functionLeafList.iterator(); it.hasNext();) {
Node node = (Node) it.next();
if (node.weight > avgWeight.doubleValue()) {
retList.add(node);
}
}
return retList;
}
/**
* 输出热点功能叶子
* @param hotFunctionLeaf
*/
public static void printHotFunctionLeaf(List hotFunctionLeaf) {
System.out.println("热点功能叶子：\n" + hotFunctionLeaf);
}
}
/**
* 节点类
*/
class Node {
/**
* 节点编号
*/
public String id;
/**
* 节点内容
*/
public String text;
/**
* 父节点编号
*/
public String parentId;
/**
* 节点权值
*/
public int weight;
/**
* 是否可见，默认为true
*/
public boolean visible = true;
/**
* 父节点引用
*/
public Node parentNode;
/**
* 孩子节点列表
*/
private Children children = new Children();
// 添加孩子节点
public void addChild(Node node) {
this.children.addChild(node);
}
// 先序遍历，拼接JSON字符串
public String toString() {
if (visible) {
String result = "{"
+ "id : '" + id + "'"
+ ", text : '" + text + "'";
if (children != null && children.getSize() != 0) {
result += ", children : " + children.toString();
} else {
result += ", leaf : true";
}
return result + "}";
} else {
return "";
}
}
// 兄弟节点横向排序
public void sortChildren() {
if (children != null && children.getSize() != 0) {
children.sortChildren();
}
}
// 先序遍历，构造功能叶子列表
public void initializeLeafList(List leafList) {
if (children == null || children.getSize() == 0) {
leafList.add(this);
} else {
children.initializeLeafList(leafList);
}
}
// 先序遍历，设置该节点下的所有功能路径为不可见
public void setTreeNotVisible() {
visible = false;
if (children != null && children.getSize() != 0) {
children.setTreeNotVisible();
}
}
// 先序遍历，设置该节点下的所有功能路径为可见
public void setTreeVisible() {
visible = true;
if (children != null && children.getSize() != 0) {
children.setTreeVisible();
}
}
// 设置包含该叶子节点的功能路径可见
public void setRouteVisible() {
visible = true;
for (Node parentNode = this.parentNode; parentNode != null; parentNode = parentNode.parentNode) {
parentNode.visible = true;
}
}
// 对包含该叶子节点的功能路径权值加1
public void increaseRouteWeight() {
weight++;
updateNodeWeightToDB(this);
for (Node parentNode = this.parentNode; parentNode != null; parentNode = parentNode.parentNode) {
parentNode.weight++;
updateNodeWeightToDB(parentNode);
}
}
// 更新节点权值到数据库
public void updateNodeWeightToDB(Node node) {
// 暂时不实现，实际应用中需要实现该方法
// 或者用户退出系统时，遍历整棵树，统一更新所有节点的权值到数据库中，应该这样做比较好，一次性统一处理
}
// 先序遍历，搜索菜单节点，同时进行功能路径过滤
public void searchTreeNode(String keyWord) {
if (this.text.indexOf(keyWord) > -1) {
this.setTreeVisible();
this.setRouteVisible();
} else {
if (children != null && children.getSize() != 0) {
children.searchTreeNode(keyWord);
}
}
}
}
/**
* 孩子列表类
*/
class Children {
private List list = new ArrayList();
public int getSize() {
return list.size();
}
public void addChild(Node node) {
list.add(node);
}
// 拼接孩子节点的JSON字符串
public String toString() {
String result = "[";
for (Iterator it = list.iterator(); it.hasNext();) {
Node node = (Node) it.next();
if (node.visible) {
result += node.toString();
result += ",";
}
}
result = result.substring(0, result.length() - 1);
result += "]";
return result;
}
// 在孩子节点中寻找功能叶子节点
public void initializeLeafList(List leafList) {
for (Iterator it = list.iterator(); it.hasNext();) {
((Node) it.next()).initializeLeafList(leafList);
}
}
// 孩子节点排序
public void sortChildren() {
// 对本层节点进行排序
// 可根据不同的排序属性，传入不同的比较器，这里传入优先级比较器
Collections.sort(list, new NodePriorityComparator());
// 对每个节点的下一层节点进行排序
for (Iterator it = list.iterator(); it.hasNext();) {
((Node) it.next()).sortChildren();
}
}
// 设置孩子节点为不可见
public void setTreeNotVisible() {
for (Iterator it = list.iterator(); it.hasNext();) {
((Node) it.next()).setTreeNotVisible();
}
}
// 设置孩子节点为可见
public void setTreeVisible() {
for (Iterator it = list.iterator(); it.hasNext();) {
((Node) it.next()).setTreeVisible();
}
}
// 搜索菜单节点，同时进行功能路径过滤
public void searchTreeNode(String keyWord) {
for (Iterator it = list.iterator(); it.hasNext();) {
((Node) it.next()).searchTreeNode(keyWord);
}
}
}
/**
* 节点比较器
*/
class NodePriorityComparator implements Comparator {
// 按照（节点权值+节点编号）比较
public int compare(Object o1, Object o2) {
// 按权值由大到小排序
int w1 = ((Node)o1).weight;
int w2 = ((Node)o2).weight;
if (w1 < w2) {
return 1;
} else if (w1 > w2) {
return -1;
} else { // 权值相等时，按照节点编号由小到大排序
int i1 = Integer.parseInt(((Node)o1).id);
int i2 = Integer.parseInt(((Node)o2).id);
return i1 < i2 ? -1 : (i1 == i2 ? 0 : 1);
}
}
}
/**
* 构造虚拟的层次数据
*/
class VirtualDataGenerator {
// 构造无序的结果集列表，实际应用中，该数据应该从数据库中查询获得；
public static List getVirtualResult() {
List dataList = new ArrayList();
HashMap dataRecord1 = new HashMap();
dataRecord1.put("id", "0");
dataRecord1.put("text", "根");
dataRecord1.put("parentId", "");
dataRecord1.put("weight", "1");
HashMap dataRecord2 = new HashMap();
dataRecord2.put("id", "1");
dataRecord2.put("text", "1");
dataRecord2.put("parentId", "0");
dataRecord2.put("weight", "1");
HashMap dataRecord3 = new HashMap();
dataRecord3.put("id", "2");
dataRecord3.put("text", "2");
dataRecord3.put("parentId", "0");
dataRecord3.put("weight", "1");
HashMap dataRecord4 = new HashMap();
dataRecord4.put("id", "3");
dataRecord4.put("text", "3");
dataRecord4.put("parentId", "0");
dataRecord4.put("weight", "1");
HashMap dataRecord5 = new HashMap();
dataRecord5.put("id", "4");
dataRecord5.put("text", "4");
dataRecord5.put("parentId", "0");
dataRecord5.put("weight", "1");
HashMap dataRecord6 = new HashMap();
dataRecord6.put("id", "11");
dataRecord6.put("text", "11");
dataRecord6.put("parentId", "1");
dataRecord6.put("weight", "1");
HashMap dataRecord7 = new HashMap();
dataRecord7.put("id", "12");
dataRecord7.put("text", "12");
dataRecord7.put("parentId", "1");
dataRecord7.put("weight", "1");
HashMap dataRecord8 = new HashMap();
dataRecord8.put("id", "21");
dataRecord8.put("text", "21");
dataRecord8.put("parentId", "2");
dataRecord8.put("weight", "1");
HashMap dataRecord9 = new HashMap();
dataRecord9.put("id", "22");
dataRecord9.put("text", "22");
dataRecord9.put("parentId", "2");
dataRecord9.put("weight", "1");
HashMap dataRecord10 = new HashMap();
dataRecord10.put("id", "31");
dataRecord10.put("text", "31");
dataRecord10.put("parentId", "3");
dataRecord10.put("weight", "1");
HashMap dataRecord11 = new HashMap();
dataRecord11.put("id", "32");
dataRecord11.put("text", "32");
dataRecord11.put("parentId", "3");
dataRecord11.put("weight", "1");
HashMap dataRecord12 = new HashMap();
dataRecord12.put("id", "41");
dataRecord12.put("text", "41");
dataRecord12.put("parentId", "4");
dataRecord12.put("weight", "1");
HashMap dataRecord13 = new HashMap();
dataRecord13.put("id", "42");
dataRecord13.put("text", "42");
dataRecord13.put("parentId", "4");
dataRecord13.put("weight", "1");
HashMap dataRecord14 = new HashMap();
dataRecord14.put("id", "43");
dataRecord14.put("text", "43");
dataRecord14.put("parentId", "4");
dataRecord14.put("weight", "1");
HashMap dataRecord15 = new HashMap();
dataRecord15.put("id", "121");
dataRecord15.put("text", "121");
dataRecord15.put("parentId", "12");
dataRecord15.put("weight", "1");
HashMap dataRecord16 = new HashMap();
dataRecord16.put("id", "122");
dataRecord16.put("text", "122");
dataRecord16.put("parentId", "12");
dataRecord16.put("weight", "1");
HashMap dataRecord17 = new HashMap();
dataRecord17.put("id", "123");
dataRecord17.put("text", "123");
dataRecord17.put("parentId", "12");
dataRecord17.put("weight", "1");
HashMap dataRecord18 = new HashMap();
dataRecord18.put("id", "321");
dataRecord18.put("text", "321");
dataRecord18.put("parentId", "32");
dataRecord18.put("weight", "1");
HashMap dataRecord19 = new HashMap();
dataRecord19.put("id", "322");
dataRecord19.put("text", "322");
dataRecord19.put("parentId", "32");
dataRecord19.put("weight", "1");
HashMap dataRecord20 = new HashMap();
dataRecord20.put("id", "323");
dataRecord20.put("text", "323");
dataRecord20.put("parentId", "32");
dataRecord20.put("weight", "1");
dataList.add(dataRecord1);
dataList.add(dataRecord2);
dataList.add(dataRecord3);
dataList.add(dataRecord4);
dataList.add(dataRecord5);
dataList.add(dataRecord6);
dataList.add(dataRecord7);
dataList.add(dataRecord8);
dataList.add(dataRecord9);
dataList.add(dataRecord10);
dataList.add(dataRecord11);
dataList.add(dataRecord12);
dataList.add(dataRecord13);
dataList.add(dataRecord14);
dataList.add(dataRecord15);
dataList.add(dataRecord16);
dataList.add(dataRecord17);
dataList.add(dataRecord18);
dataList.add(dataRecord19);
dataList.add(dataRecord20);
return dataList;
}
}

package test;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Collections;

/**
 * 功能菜单树类
*/
public class FunctionTree {
	
	public static void main(String[] args) {
		// 读取层次数据结果集列表
		List dataList = VirtualDataGenerator.getVirtualResult();

		// 构造加权多叉树
		Node root = buildWeightedMultiTree(dataList);
		
		// 构造功能叶子列表
		List functionLeafList = buildFunctionLeafList(root);
		
		// 对多叉树重新进行横向排序
		root.sortChildren();
		// 输出首次登录后的树形菜单
		System.out.println("首次登录时的树形菜单：\n" + root.toString());	
		
		// 进行菜单节点搜索（即功能路径筛选）
		searchTreeNode(root, "321");
		
		// 输出搜索结果
		System.out.println("搜索后的树形菜单：\n" + root.toString());
		
		// 增加功能路径权值
		increaseRouteWeight(root, functionLeafList, "122");
		increaseRouteWeight(root, functionLeafList, "323");
		
		// 对多叉树重新进行横向排序
		root.sortChildren();
		// 输出权值变化后的树形菜单		
		System.out.println("路径权值变化后再次登录时的树形菜单：\n" + root.toString());
		
		// 获取热点功能叶子
		List hotFunctionLeaf = getHotFunctionLeaf(functionLeafList);
		
		// 输出热点功能叶子
		printHotFunctionLeaf(hotFunctionLeaf);

		// 程序输出结果如下：
		// 首次登录时的树形菜单：
		// {id : '0', text : '根', children : [{id : '1', text : '1', children : [{id : '11', text : '11', leaf : true},{id : '12', text : '12', children : [{id : '121', text : '121', leaf : true},{id : '122', text : '122', leaf : true},{id : '123', text : '123', leaf : true}]}]},{id : '2', text : '2', children : [{id : '21', text : '21', leaf : true},{id : '22', text : '22', leaf : true}]},{id : '3', text : '3', children : [{id : '31', text : '31', leaf : true},{id : '32', text : '32', children : [{id : '321', text : '321', leaf : true},{id : '322', text : '322', leaf : true},{id : '323', text : '323', leaf : true}]}]},{id : '4', text : '4', children : [{id : '41', text : '41', leaf : true},{id : '42', text : '42', leaf : true},{id : '43', text : '43', leaf : true}]}]}
		// 搜索后的树形菜单：
		// {id : '0', text : '根', children : [{id : '3', text : '3', children : [{id : '32', text : '32', children : [{id : '321', text : '321', leaf : true}]}]}]}
		// 路径权值变化后再次登录时的树形菜单：
		// {id : '0', text : '根', children : [{id : '1', text : '1', children : [{id : '12', text : '12', children : [{id : '122', text : '122', leaf : true},{id : '121', text : '121', leaf : true},{id : '123', text : '123', leaf : true}]},{id : '11', text : '11', leaf : true}]},{id : '3', text : '3', children : [{id : '32', text : '32', children : [{id : '323', text : '323', leaf : true},{id : '321', text : '321', leaf : true},{id : '322', text : '322', leaf : true}]},{id : '31', text : '31', leaf : true}]},{id : '2', text : '2', children : [{id : '21', text : '21', leaf : true},{id : '22', text : '22', leaf : true}]},{id : '4', text : '4', children : [{id : '41', text : '41', leaf : true},{id : '42', text : '42', leaf : true},{id : '43', text : '43', leaf : true}]}]}
		// 热点功能叶子：
		// [{id : '323', text : '323', leaf : true}, {id : '122', text : '122', leaf : true}]
	}			
	
	/**
	 * 构造加权多叉树
	 * @return
	 */
	public static Node buildWeightedMultiTree(List dataList) {
		// 节点列表（散列表，用于临时存储节点对象）
		HashMap nodeList = new HashMap();
		// 根节点
		Node root = null;
		// 根据结果集构造节点列表（存入散列表）
		for (Iterator it = dataList.iterator(); it.hasNext();) {
			Map dataRecord = (Map) it.next();
			Node node = new Node();
			node.id = (String) dataRecord.get("id");
			node.text = (String) dataRecord.get("text");
			node.parentId = (String) dataRecord.get("parentId");
			node.weight = Integer.parseInt((String) dataRecord.get("weight"));
			nodeList.put(node.id, node);
		}
		// 构造无序的多叉树
		Set entrySet = nodeList.entrySet();
		for (Iterator it = entrySet.iterator(); it.hasNext();) {
			Node node = (Node) ((Map.Entry) it.next()).getValue();
			if (node.parentId == null || node.parentId.equals("")) {
				root = node;
			} else {
				((Node) nodeList.get(node.parentId)).addChild(node);
				// 在节点中增加一个父节点的引用
				node.parentNode = (Node) nodeList.get(node.parentId);
			}
		}

		return root;
	} 
	
	/**
	 * 构造功能叶子列表
	 * @param root
	 * @return
	 */
	public static List buildFunctionLeafList(Node root) {
		List functionLeafList = new ArrayList();
		root.initializeLeafList(functionLeafList);
		return functionLeafList;
	}
	
	/**
	 * 进行菜单节点搜索（即功能路径筛选）
	 * @param root
	 * @param keyWord
	 */
	public static void searchTreeNode(Node root, String keyWord) {
		// 首先设置整棵树的功能路径为不可见
		root.setTreeNotVisible();
		// 在整棵功能树中搜索包含关键字的节点，并进行路径筛选
		root.searchTreeNode(keyWord);					
	}
	
	/**
	 * 增加功能路径权值
	 * @param root
	 */
	public static void increaseRouteWeight(Node root, List functionLeafList, String nodeId) {
		// 首先设置整棵树的功能路径为可见
		root.setTreeVisible();		
		// 对包含功能叶子节点的路径权值加1
		for (Iterator it = functionLeafList.iterator(); it.hasNext();) {
			Node leafNode = (Node) it.next();
			if (leafNode.id.equals(nodeId)) {
				leafNode.increaseRouteWeight();
			}
		}		
	}
	
	/**
	 * 获取热点功能叶子
	 * @param functionLeafList
	 * @return
	 */
	public static List getHotFunctionLeaf(List functionLeafList) {
		int count = 0;
		int totalWeight = 0;
		BigDecimal avgWeight;
		for (Iterator it = functionLeafList.iterator(); it.hasNext();) {
			Node node = (Node) it.next();
			totalWeight += node.weight;
			count++;
		}
		avgWeight = (new BigDecimal(totalWeight)).divide(new BigDecimal(count), 2, BigDecimal.ROUND_HALF_UP);
		List retList = new ArrayList();
		for (Iterator it = functionLeafList.iterator(); it.hasNext();) {
			Node node = (Node) it.next();
			if (node.weight > avgWeight.doubleValue()) {
				retList.add(node);
			}
		}
		return retList;
	}
	
	/**
	 * 输出热点功能叶子
	 * @param hotFunctionLeaf
	 */
	public static void printHotFunctionLeaf(List hotFunctionLeaf) {
		System.out.println("热点功能叶子：\n" + hotFunctionLeaf);
	}
	
	
}


/**
* 节点类
*/
class Node {
	/**
	 * 节点编号
	 */
	public String id;
	/**
	 * 节点内容
	 */
	public String text;
	/**
	 * 父节点编号
	 */
	public String parentId;
	/**
	 * 节点权值
	 */
	public int weight;
	/**
	 * 是否可见，默认为true
	 */
	public boolean visible = true;
	/**
	 * 父节点引用
	 */
	public Node parentNode;
	/**
	 * 孩子节点列表
	 */
	private Children children = new Children();
	
	// 添加孩子节点
	public void addChild(Node node) {
		this.children.addChild(node);
	}
	
	// 先序遍历，拼接JSON字符串
	public String toString() {
		if (visible) {
			String result = "{"
				+ "id : '" + id + "'"
				+ ", text : '" + text + "'";
			
			if (children != null && children.getSize() != 0) {
				result += ", children : " + children.toString();
			} else {
				result += ", leaf : true";
			}
					
			return result + "}";
		} else {
			return "";
		}
	}
	
	// 兄弟节点横向排序
	public void sortChildren() {
		if (children != null && children.getSize() != 0) {
			children.sortChildren();
		}
	}
	
	// 先序遍历，构造功能叶子列表
	public void initializeLeafList(List leafList) {
		if (children == null || children.getSize() == 0) {
			leafList.add(this);
		} else {
			children.initializeLeafList(leafList);
		}
	}
	
	// 先序遍历，设置该节点下的所有功能路径为不可见
	public void setTreeNotVisible() {
		visible = false;
		if (children != null && children.getSize() != 0) {
			children.setTreeNotVisible();
		}
	}
	
	// 先序遍历，设置该节点下的所有功能路径为可见
	public void setTreeVisible() {
		visible = true;
		if (children != null && children.getSize() != 0) {
			children.setTreeVisible();
		}
	}
	
	// 设置包含该叶子节点的功能路径可见
	public void setRouteVisible() {
		visible = true;
		for (Node parentNode = this.parentNode; parentNode != null; parentNode = parentNode.parentNode) {
			parentNode.visible = true;
		}
	}
	
	// 对包含该叶子节点的功能路径权值加1
	public void increaseRouteWeight() {
		weight++;
		updateNodeWeightToDB(this);
		for (Node parentNode = this.parentNode; parentNode != null; parentNode = parentNode.parentNode) {
			parentNode.weight++;
			updateNodeWeightToDB(parentNode);
		}
	}
	
	// 更新节点权值到数据库
	public void updateNodeWeightToDB(Node node) {
		// 暂时不实现，实际应用中需要实现该方法
		// 或者用户退出系统时，遍历整棵树，统一更新所有节点的权值到数据库中，应该这样做比较好，一次性统一处理
	}
	
	// 先序遍历，搜索菜单节点，同时进行功能路径过滤
	public void searchTreeNode(String keyWord) {
		if (this.text.indexOf(keyWord) > -1) {
			this.setTreeVisible();
			this.setRouteVisible();
		} else {
			if (children != null && children.getSize() != 0) {
				children.searchTreeNode(keyWord);
			}
		}
	}
}

/**
* 孩子列表类
*/
class Children {
	private List list = new ArrayList();
	
	public int getSize() {
		return list.size();
	}
	
	public void addChild(Node node) {
		list.add(node);
	}
	
	// 拼接孩子节点的JSON字符串
	public String toString() {
		String result = "[";		
		for (Iterator it = list.iterator(); it.hasNext();) {
			Node node = (Node) it.next();
			if (node.visible) {
				result += node.toString();
				result += ",";
			}
		}
		result = result.substring(0, result.length() - 1);
		result += "]";
		return result;
	}
	
	// 在孩子节点中寻找功能叶子节点
	public void initializeLeafList(List leafList) {
		for (Iterator it = list.iterator(); it.hasNext();) {
			((Node) it.next()).initializeLeafList(leafList);
		}
	}
	
	// 孩子节点排序
	public void sortChildren() {
		// 对本层节点进行排序
		// 可根据不同的排序属性，传入不同的比较器，这里传入优先级比较器
		Collections.sort(list, new NodePriorityComparator());
		// 对每个节点的下一层节点进行排序
		for (Iterator it = list.iterator(); it.hasNext();) {
			((Node) it.next()).sortChildren();
		}
	}
	
	// 设置孩子节点为不可见 
	public void setTreeNotVisible() {
		for (Iterator it = list.iterator(); it.hasNext();) {
			((Node) it.next()).setTreeNotVisible();
		}
	}
	
	// 设置孩子节点为可见 
	public void setTreeVisible() {
		for (Iterator it = list.iterator(); it.hasNext();) {
			((Node) it.next()).setTreeVisible();
		}
	}
	
	// 搜索菜单节点，同时进行功能路径过滤
	public void searchTreeNode(String keyWord) {
		for (Iterator it = list.iterator(); it.hasNext();) {
			((Node) it.next()).searchTreeNode(keyWord);
		}
	}
}

/**
 * 节点比较器
 */
class NodePriorityComparator implements Comparator {
	// 按照 （节点权值+节点编号） 比较
	public int compare(Object o1, Object o2) {
		// 按权值由大到小排序
		int w1 = ((Node)o1).weight;
	    int w2 = ((Node)o2).weight;
	    if (w1 < w2) {
	    	return 1;
	    } else if (w1 > w2) {
	    	return -1;
	    } else { // 权值相等时，按照节点编号由小到大排序
	    	int i1 = Integer.parseInt(((Node)o1).id);
	    	int i2 = Integer.parseInt(((Node)o2).id);
	    	return i1 < i2 ? -1 : (i1 == i2 ? 0 : 1);
	    }
	}	
}

/**
 * 构造虚拟的层次数据
 */
class VirtualDataGenerator {
	// 构造无序的结果集列表，实际应用中，该数据应该从数据库中查询获得；
	public static List getVirtualResult() {				
		List dataList = new ArrayList();
		
		HashMap dataRecord1 = new HashMap();
		dataRecord1.put("id", "0");
		dataRecord1.put("text", "根");
		dataRecord1.put("parentId", "");
		dataRecord1.put("weight", "1");
		
		HashMap dataRecord2 = new HashMap();
		dataRecord2.put("id", "1");
		dataRecord2.put("text", "1");
		dataRecord2.put("parentId", "0");
		dataRecord2.put("weight", "1");
		
		HashMap dataRecord3 = new HashMap();
		dataRecord3.put("id", "2");
		dataRecord3.put("text", "2");
		dataRecord3.put("parentId", "0");
		dataRecord3.put("weight", "1");
						
		HashMap dataRecord4 = new HashMap();
		dataRecord4.put("id", "3");
		dataRecord4.put("text", "3");
		dataRecord4.put("parentId", "0");
		dataRecord4.put("weight", "1");
						
		HashMap dataRecord5 = new HashMap();
		dataRecord5.put("id", "4");
		dataRecord5.put("text", "4");
		dataRecord5.put("parentId", "0");
		dataRecord5.put("weight", "1");
		
		HashMap dataRecord6 = new HashMap();
		dataRecord6.put("id", "11");
		dataRecord6.put("text", "11");
		dataRecord6.put("parentId", "1");
		dataRecord6.put("weight", "1");
		
		HashMap dataRecord7 = new HashMap();
		dataRecord7.put("id", "12");
		dataRecord7.put("text", "12");
		dataRecord7.put("parentId", "1");
		dataRecord7.put("weight", "1");
		
		HashMap dataRecord8 = new HashMap();
		dataRecord8.put("id", "21");
		dataRecord8.put("text", "21");
		dataRecord8.put("parentId", "2");
		dataRecord8.put("weight", "1");
		
		HashMap dataRecord9 = new HashMap();
		dataRecord9.put("id", "22");
		dataRecord9.put("text", "22");
		dataRecord9.put("parentId", "2");
		dataRecord9.put("weight", "1");
		
		HashMap dataRecord10 = new HashMap();
		dataRecord10.put("id", "31");
		dataRecord10.put("text", "31");
		dataRecord10.put("parentId", "3");
		dataRecord10.put("weight", "1");
		
		HashMap dataRecord11 = new HashMap();
		dataRecord11.put("id", "32");
		dataRecord11.put("text", "32");
		dataRecord11.put("parentId", "3");
		dataRecord11.put("weight", "1");
		
		HashMap dataRecord12 = new HashMap();
		dataRecord12.put("id", "41");
		dataRecord12.put("text", "41");
		dataRecord12.put("parentId", "4");
		dataRecord12.put("weight", "1");
		
		HashMap dataRecord13 = new HashMap();
		dataRecord13.put("id", "42");
		dataRecord13.put("text", "42");
		dataRecord13.put("parentId", "4");
		dataRecord13.put("weight", "1");
		
		HashMap dataRecord14 = new HashMap();
		dataRecord14.put("id", "43");
		dataRecord14.put("text", "43");
		dataRecord14.put("parentId", "4");
		dataRecord14.put("weight", "1");
				
		HashMap dataRecord15 = new HashMap();
		dataRecord15.put("id", "121");
		dataRecord15.put("text", "121");
		dataRecord15.put("parentId", "12");
		dataRecord15.put("weight", "1");
		
		HashMap dataRecord16 = new HashMap();
		dataRecord16.put("id", "122");
		dataRecord16.put("text", "122");
		dataRecord16.put("parentId", "12");
		dataRecord16.put("weight", "1");
		
		HashMap dataRecord17 = new HashMap();
		dataRecord17.put("id", "123");
		dataRecord17.put("text", "123");
		dataRecord17.put("parentId", "12");
		dataRecord17.put("weight", "1");
				
		HashMap dataRecord18 = new HashMap();
		dataRecord18.put("id", "321");
		dataRecord18.put("text", "321");
		dataRecord18.put("parentId", "32");
		dataRecord18.put("weight", "1");
		
		HashMap dataRecord19 = new HashMap();
		dataRecord19.put("id", "322");
		dataRecord19.put("text", "322");
		dataRecord19.put("parentId", "32");
		dataRecord19.put("weight", "1");
		
		HashMap dataRecord20 = new HashMap();
		dataRecord20.put("id", "323");
		dataRecord20.put("text", "323");
		dataRecord20.put("parentId", "32");
		dataRecord20.put("weight", "1");
				
		dataList.add(dataRecord1);
		dataList.add(dataRecord2);
		dataList.add(dataRecord3);
		dataList.add(dataRecord4);
		dataList.add(dataRecord5);
		dataList.add(dataRecord6);
		dataList.add(dataRecord7);		
		dataList.add(dataRecord8);
		dataList.add(dataRecord9);
		dataList.add(dataRecord10);
		dataList.add(dataRecord11);
		dataList.add(dataRecord12);
		dataList.add(dataRecord13);
		dataList.add(dataRecord14);		
		dataList.add(dataRecord15);
		dataList.add(dataRecord16);
		dataList.add(dataRecord17);
		dataList.add(dataRecord18);
		dataList.add(dataRecord19);
		dataList.add(dataRecord20);
		
		return dataList;
	}	
}

四、联系方式
[email protected]

你可能感兴趣的:(JavaScript)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
高性能javascript--算法和流程控制海淀萌狗
-for,while和do-while性能相当-避免使用for-in循环，==除非遍历一个属性量未知的对象==es5:for-in遍历的对象便不局限于数组，还可以遍历对象。原因：for-in每次迭代操作会同时搜索实例或者原型属性，for-in循环的每次迭代都会产生更多开销，因此要比其他循环类型慢，一般速度为其他类型循环的1/7。因此，除非明确需要迭代一个属性数量未知的对象，否则应避免使用for-i
360前端星计划-动画可以这么玩马小蜗
动画的基本原理定时器改变对象的属性根据新的属性重新渲染动画functionupdate(context){//更新属性}constticker=newTicker();ticker.tick(update,context);动画的种类1、JavaScript动画操作DOMCanvas2、CSS动画transitionanimation3、SVG动画SMILJS动画的优缺点优点：灵活度、可控性、性能
JavaScript中秋快乐！ Q_w7742 javascript 开发语言 ecmascript
我们来实现一个简单的祝福网页~主要的难度在于使用canvas绘图当点击canvas时候，跳出“中秋节快乐”字样，需要注册鼠标单击事件和计时器。首先定义主要函数：初始化当点击canvas之后转到onCanvasClick函数，绘图生成灯笼。functiononCanvasClick(){//事件处理函数context.clearRect(0,0,canvas1.width,canvas1.heigh
Nginx从入门到实践(三) 听你讲故事啊
动静分离动静分离是将网站静态资源（JavaScript，CSS，img等文件）与后台应用分开部署，提高用户访问静态代码的速度，降低对后台应用访问。动静分离的一种做法是将静态资源部署在nginx上，后台项目部署到应用服务器上，根据一定规则静态资源的请求全部请求nginx服务器，达到动静分离的目标。rewrite规则Rewrite规则常见正则表达式Rewrite主要的功能就是实现URL的重写，Ngin
Nginx的使用场景：构建高效、可扩展的Web架构张某布响丸辣 nginx 前端架构
Nginx，作为当今最流行的Web服务器和反向代理软件之一，凭借其高性能、稳定性和灵活性，在众多Web项目中扮演着核心角色。无论是个人博客、中小型网站，还是大型企业级应用，Nginx都能提供强大的支持。本文将探讨Nginx的几个主要使用场景，帮助读者理解如何在实际项目中充分利用Nginx的优势。1.静态文件服务对于包含大量静态文件（如HTML、CSS、JavaScript、图片等）的网站，Ngin
前端知识点 ZhangTao_zata 前端 javascript css
下面是一个最基本的html代码body{font-family:Arial,sans-serif;margin:20px;}//JavaScriptfunctionthatdisplaysanalertwhencalledfunctionshowMessage(){alert("Hello!Youclickedthebutton.");}MyFirstHTMLPageWelcometoMyPage
【JS】前端文件读取FileReader操作总结程序员-张师傅前端前端 javascript 开发语言
前端文件读取FileReader操作总结FileReader是JavaScript中的一个WebAPI，它允许web应用程序异步读取用户计算机上的文件（或原始数据缓冲区）的内容，例如读取文件以获取其内容，并在不将文件发送到服务器的情况下在客户端使用它。这对于处理图片、文本文件等非常有用，尤其是当你想要在用户界面中即时显示文件内容或进行文件预览时。创建FileReader对象首先，你需要创建一个Fi
webstorm报错TypeError: this.cliEngine is not a constructor Blue_Color
点击Details在控制台会显示报错的位置TypeError:this.cliEngineisnotaconstructoratESLintPlugin.invokeESLint(/Applications/RubyMine.app/Contents/plugins/JavaScriptLanguage/languageService/eslint/bin/eslint-plugin.js:97:
创建一个完整的购物商城系统是一个复杂的项目，涉及前端（用户界面）、后端（服务器逻辑）、数据库等多个部分。由于篇幅限制，我无法在这里提供一个完整的系统代码，但我可以分别给出一些关键部分的示例代码，涵盖几 uthRaman 前端 ui 服务器
前端（HTML/CSS/JavaScript）grsyzp.cnHTML页面结构（index.html）html购物商城欢迎来到购物商城JavaScript（Ajax请求商品数据，app.js）javascriptdocument.addEventListener('DOMContentLoaded',function(){fetch('/api/products').then(response=
了解 UNPKG：前端开发者的包管理利器小于负无穷前端 javascript typescript css html5 node.js
在现代前端开发中，JavaScript包管理和模块化是至关重要的，而npm则是最流行的JavaScript包管理器之一。不过，随着前端项目复杂性的增加，有时候我们希望快速引入外部依赖，而无需本地安装和构建。此时，CDN（内容分发网络）成为了一种方便快捷的解决方案，而UNPKG就是这种方式中的佼佼者。什么是UNPKG？UNPKG是一个基于npm的内容分发网络（CDN），它允许开发者直接通过URL从n
2019-05-29 vue-router的两种模式的区别 Kason晨
1、大家都知道vue是一种单页应用,单页应用就是仅在页面初始化的时候加载相应的html/css/js一单页面加载完成,不会因为用户的操作而进行页面的重新加载或者跳转,用javascript动态的变化html的内容优点:良好的交互体验,用户不需要刷新页面,页面显示流畅,良好的前后端工作分离模式,减轻服务器压力,缺点:不利于SEO,初次加载耗时比较多2、hash模式vue-router默认的是hash
electron多标签页模式更像客户端 diygwcom electron javascript 前端
Electron多标签页模式是指在Electron框架中实现的类似Web浏览器的多标签页功能。Electron是一个使用Web技术（HTML、CSS和JavaScript）来创建跨平台桌面应用程序的框架。在Electron中实现多标签页模式，通常需要借助一些特定的库或组件，如BrowserView或electron-tabs，或者通过自定义实现。实现方式1.使用BrowserViewBrowser
外卖霸王餐返利外卖会员卡小程序开发闹小艾 good506070 微信小程序小程序
外卖霸王餐返利外卖会员卡小程序开发"社交电商赋能下的外卖返利小程序"是专为商家与用户双赢而设计的创新平台。以下是其开发方案的详细步骤：一、需求梳理：首先，我们需要明确小程序的核心功能和特色。包括设定活动类型、返利策略，以及用户体验友好的界面设计。二、技术决策：技术选型是关键。我们采用小程序的开发框架，利用JavaScript作为前端开发语言，并结合微信提供的API进行后端接口调用与数据处理。三、账
Axure设计之全屏与退出全屏交互实现招风的黑耳 Axure axure 交互
在AxureRP中，设计全屏与退出全屏的交互功能可以极大地提升用户体验，尤其是在展示产品原型或进行演示时。本文将详细介绍如何在AxureRP中通过结合JavaScript代码实现全屏与退出全屏的交互效果。Axure原型设计web端交互元件库：https://1zvcwx.axshare.com一、设计思路全屏与退出全屏的交互设计主要依赖于JavaScript代码来控制浏览器的全屏模式。在Axure
全面指南：用户行为从前端数据采集到实时处理的最佳实践数字沉思营销流量运营系统架构前端内容运营大数据
引言在当今的数据驱动世界，实时数据采集和处理已经成为企业做出及时决策的重要手段。本文将详细介绍如何通过前端JavaScript代码采集用户行为数据、利用API和Kafka进行数据传输、通过Flink实时处理数据的完整流程。无论你是想提升产品体验还是做用户行为分析，这篇文章都将为你提供全面的解决方案。设计一个通用的ClickHouse表来存储用户事件时，需要考虑多种因素，包括事件类型、时间戳、用户信
EcmaScript和JavaScript的区别每天吃八顿前端 ecmascript
ECMAScript和JavaScript是经常被混淆的两个术语，但实际上它们之间存在一些区别：ECMAScript：ECMAScript（通常缩写为ES，并且有版本号如ES5,ES6和ES7等）是由ECMA国际（EuropeanComputerManufacturersAssociation）制定的一种脚本语言的规范。这个规范定义了语法、命令、数据类型等基本元素。ECMAScript是一种规范，
javascript添加p元素，html添加文字，appendChild 游勇一 javascript html添加p appendChild
javascript添加p元素，html添加文字，appendChild。网页添加p元素效果截图。个人签名：游志勇，预制板，南托岭预制场。文字展示#wordsadd{font-size:70px;word-break:break-all;}#wordsaddp{margin:002px0;padding:002px0;line-height:93%;}.btn_width{width:90px;}
CesiumJS+SuperMap3D.js混用实现可视域分析 S3M图层加载裁剪区域绘制 SteveJi666 WebGL cesium EarthSDK SuperMap 3d javascript 前端 arcgis
版本简介：cesium：1.99；Supermap3D：SuperMapiClientJavaScript11i(2023)；官方下载文档链家：SuperMap技术资源中心|为您提供全面的在线技术服务示例参考：support.supermap.com.cn:8090/webgl/Cesium/examples/webgl/examples.html#analysissupport.supermap
html打开本地excel文件夹,html使用excel表格数据库-html读取本地excel文件并展示睿理
html表格如何导入到excel中在vs里面用添加数据源就可以啊,再使用数据控件,就可以操作.添加数据源可以用odbc数据源,两种方式1,是在控制面板的管理工具里在ODBC里先设置好.2,是使用连接字符串.用vs的添加数据源向导做.html中有没有类似excel表格，可以填数的表格控件？首先html不能读取本地excel文件其次就算是javascript也是不允许的这是为了安全考虑如果前端脚本可以
如何在 Python 中声明一个静态属性? 潮易 python 开发语言
在Python中，静态属性的定义和使用方式与JavaScript中的类似，主要是通过`@staticmethod`装饰器来实现。静态属性不需要实例化对象就可以访问，它们属于类本身。###如何声明一个静态属性：1.首先，需要在属性名前添加`@staticmethod`装饰器。2.接下来，定义一个普通方法，该方法的第一个参数通常为`cls`（用于表示类的引用）。###代码示例：```pythoncla
数据格式：什么是JSON和XML isNotNullX json xml
JSON和XML都是数据交换的一种格式，用于在不同的系统和应用程序之间传输和存储数据。本文将解释JSON和XML的基础内容，并探讨两者的不同。一·什么是JSON？1.JSON（JavaScriptObjectNotation）即JavaScript对象标记法：-JSON是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。-JSON基于JavaScript的一个子集，但JSON是
HighCharts图表自动化简介知识的宝藏 Selenium高级篇 Selenium图表自动化测试 highcharts图表自动化 Selenium图表自动化图表自动化测试 highcharts Selenium
什么是分析数据？在任何应用程序中捕获并以图形或图表形式显示的分析数据是任何产品或系统的关键部分，因为它提供了对实时数据的洞察。验证此类分析数据非常重要，因为不准确的数据可能会在报告中产生问题，并可能影响应用程序/系统的其他相关领域。什么是HighChart？Highcharts是一个用纯JavaScript编写的j基于SVG成图技术的图表库，提供了一种简单的方法来向您的网站或Web应用程序添加交互
SAX解析xml文件小猪猪08 xml
1.创建SAXParserFactory实例 2.通过SAXParserFactory对象获取SAXParser实例 3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 4.SAXParser实例的parse来获取文件 public static void main(String[] args) { //
为什么mysql里的ibdata1文件不断的增长？ brotherlamp linux linux运维 linux资料 linux视频 linux运维自学
我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： ibdata1存了什么？当你启用了 i
Quartz-quartz.properties配置 eksliang quartz
其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。下面是这些默认值的解释 #-----集群的配置 org.quartz.scheduler.instanceName =
informatica session的使用 18289753290 workflow session log Informatica
如果希望workflow存储最近20次的log，在session里的Config Object设置，log options做配置，save session log :sessions run ;savesessio log for these runs:20 session下面的source 里面有个tracing
Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误酷的飞上天空 scrapy
Scrapy版本0.14.4 出现问题现象： ERROR: Error downloading <GET http://xxxxx CRC check failed 解决方法 1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0' 明确表示不支持任何形式的压缩格式，避免程序的解压
java Swing小集锦永夜-极光 java swing
1.关闭窗体弹出确认对话框 1.1 this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE); 1.2 this.addWindowListener ( new WindowAdapter () { public void windo
强制删除.svn文件夹随便小屋 java
在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
GET和POST有什么区别？及为什么网上的多数答案都是错的。 aijuans get post
如果有人问你，GET和POST，有什么区别？你会如何回答？我的经历前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
谈谈新浪微博背后的那些算法 aoyouzi 谈谈新浪微博背后的那些算法
本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
Connection reset 连接被重置的解决方法百合不是茶 java 字符流连接被重置
流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置被重置的代码如下; 客户端代码; package 通信软件服务器; import java.io.BufferedWriter; import java.io.OutputStream; import java.io.O
web.xml配置详解之filter bijian1013 java web.xml filter
一.定义 <filter> <filter-name>encodingfilter</filter-name> <filter-class>com.my.app.EncodingFilter</filter-class> <init-param> <param-name>encoding<
Heritrix Bill_chen 多线程 xml 算法制造配置管理
作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
【Zookeeper】FAQ bit1129 zookeeper
1.脱离IDE，运行简单的Java客户端程序 #ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient 1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 2. 如果Zookeeper集群跨越多个机房，那么Leader/
The user specified as a definer ('aaa'@'localhost') does not exist 白糖_ localhost
今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 最后找原因发现删除操作做了触发器，而触发器里面有这样一句 /*!50017 DEFINER = ''aaa@'localhost' */ 原来最初
javascript中showModelDialog刷新父页面 bozch JavaScript 刷新父页面 showModalDialog
在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行： window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self 在子页面使用w
编程之美-买书折扣 bylijinnan 编程之美
import java.util.Arrays; public class BookDiscount { /**编程之美买书折扣书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。下面用动态规划实现。哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要 chenbowen00 struts WEB安全
因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。下面记录下本次解决的过程以便后续 1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议，而使用ftp协议默认会产生一个匿名用
[电力与暖气]煤炭燃烧与电力加温 comsci
在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区..... 不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢? &nbs
oracle O7_DICTIONARY_ACCESSIBILITY参数 daizj oracle
O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
比较全面的MySQL优化参考 dengkane mysql
本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。 1、硬件层相关优化 1.1、CPU相关在服务器的BIOS设置中，可
C语言homework2，有一个逆序打印数字的小算法 dcj3sjt126com c
#h1# 0、完成课堂例子 1、将一个四位数逆序打印 1234 ==> 4321 实现方法一： # include <stdio.h> int main(void) { int i = 1234; int one = i%10; int two = i / 10 % 10; int three = i / 100 % 10;
apacheBench对网站进行压力测试 dcj3sjt126com apachebench
ab 的全称是 ApacheBench ，是 Apache 附带的一个小工具，专门用于 HTTP Server 的 benchmark testing ，可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。
2种办法让HashMap线程安全 flyfoxs java jdk jni
多线程之--2种办法让HashMap线程安全多线程之--synchronized 和reentrantlock的优缺点多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync) HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全.
Spring Security（04）——认证简介 234390216 Spring Security 认证过程
认证简介目录 1.1 认证过程 1.2 Web应用的认证过程 1.2.1 ExceptionTranslationFilter 1.2.2 在request之间共享SecurityContext 1
Java 位运算 Javahuhui java 位运算
// 左移( << ) 低位补0 // 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： // 0000 0000 0000 0000 0000 0000 0001 1000 System.out.println(6 << 2);// 运行结果是24 // 右移( >> ) 高位补"
mysql免安装版配置 ldzyz007 mysql
1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 3、my-large.ini是为专用于一个SQL数据
MFC和ado数据库使用时遇到的问题你不认识的休道人 sql C++mfc
=================================================================== 第一个 =================================================================== try{ CString sql; sql.Format("select * from p
表单重复提交Double Submits rensanning double
可能发生的场景： *多次点击提交按钮 *刷新页面 *点击浏览器回退按钮 *直接访问收藏夹中的地址 *重复发送HTTP请求（Ajax）（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： http://getbootstrap.co
Java String 十大常见问题 tomcat_oracle java 正则表达式
　1.字符串比较，使用“==”还是equals()? 　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。　　equals()判断两个字符串的值是否相等。　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。　　
SpringMVC 登陆拦截器实现登陆控制 xp9802 springMVC
思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。实现方法： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23