hibernate生成树

  1. packagecom.bjsxt.hibernate;
  2. importjava.util.Set;
  3. publicclassNode{
  4. //标识符
  5. privateintid;
  6. //节点名称
  7. privateStringname;
  8. //层次
  9. privateintlevel;
  10. //是否叶子节点
  11. privatebooleanleaf;
  12. //父节点*---1
  13. privateNodeparent;
  14. //子节点1---*
  15. privateSetchildren;
  16. publicSetgetChildren(){
  17. returnchildren;
  18. }
  19. publicvoidsetChildren(Setchildren){
  20. this.children=children;
  21. }
  22. publicintgetId(){
  23. returnid;
  24. }
  25. publicvoidsetId(intid){
  26. this.id=id;
  27. }
  28. publicbooleanisLeaf(){
  29. returnleaf;
  30. }
  31. publicvoidsetLeaf(booleanleaf){
  32. this.leaf=leaf;
  33. }
  34. publicintgetLevel(){
  35. returnlevel;
  36. }
  37. publicvoidsetLevel(intlevel){
  38. this.level=level;
  39. }
  40. publicStringgetName(){
  41. returnname;
  42. }
  43. publicvoidsetName(Stringname){
  44. this.name=name;
  45. }
  46. publicNodegetParent(){
  47. returnparent;
  48. }
  49. publicvoidsetParent(Nodeparent){
  50. this.parent=parent;
  51. }
  52. }

  1. <?xmlversion="1.0"?>
  2. <!DOCTYPEhibernate-mapping(ViewSourceforfulldoctype...)>
  3. -<hibernate-mappingdefault-cascade="none"default-access="property"default-lazy="true"auto-import="true">
  4. -<classname="com.bjsxt.hibernate.Node"table="t_node"mutable="true"polymorphism="implicit"dynamic-update="false"dynamic-insert="false"select-before-update="false"optimistic-lock="version">
  5. -<idname="id">
  6. <generatorclass="native"/>
  7. </id>
  8. <propertyname="name"unique="false"optimistic-lock="true"lazy="false"generated="never"/>
  9. <propertyname="level"unique="false"optimistic-lock="true"lazy="false"generated="never"/>
  10. <propertyname="leaf"unique="false"optimistic-lock="true"lazy="false"generated="never"/>
  11. <many-to-onename="parent"column="pid"unique="false"update="true"insert="true"optimistic-lock="true"not-found="exception"embed-xml="true"/>
  12. -<setname="children"lazy="extra"inverse="true"sort="unsorted"mutable="true"optimistic-lock="true"embed-xml="true">
  13. <keycolumn="pid"on-delete="noaction"/>
  14. <one-to-manyclass="com.bjsxt.hibernate.Node"not-found="exception"embed-xml="true"/>
  15. </set>
  16. </class>
  17. </hibernate-mapping>
  1. packagecom.bjsxt.hibernate;
  2. importjava.io.File;
  3. importjava.util.Iterator;
  4. importjava.util.Set;
  5. importorg.hibernate.Session;
  6. publicclassNodeManager{
  7. privatestaticNodeManagernodeManager;
  8. privateNodeManager(){
  9. }
  10. publicstaticsynchronizedNodeManagergetInstance(){
  11. if(nodeManager==null){
  12. nodeManager=newNodeManager();
  13. }
  14. returnnodeManager;
  15. }
  16. //创建树型结构
  17. publicvoidcreateTree(Stringdir){
  18. Sessionsession=HibernateUtils.getSession();
  19. try{
  20. session.beginTransaction();
  21. Fileroot=newFile(dir);
  22. saveTree(root,session,null,0);
  23. session.getTransaction().commit();
  24. }catch(RuntimeExceptione){
  25. e.printStackTrace();
  26. session.getTransaction().rollback();
  27. }finally{
  28. HibernateUtils.closeSession(session);
  29. }
  30. }
  31. //递归创建一棵树
  32. privatevoidsaveTree(Filefile,Sessionsession,Nodeparent,intlevel){
  33. if(file==null||!file.exists()){
  34. return;
  35. }
  36. booleanisLeaf=file.isFile();
  37. Nodenode=newNode();
  38. node.setName(file.getName());
  39. node.setLevel(level);
  40. node.setParent(parent);
  41. node.setLeaf(isLeaf);
  42. session.save(node);
  43. File[]subs=file.listFiles();
  44. if(subs!=null&&subs.length>0){
  45. for(inti=0;i<subs.length;i++){
  46. saveTree(subs[i],session,node,level+1);
  47. }
  48. }
  49. }
  50. publicvoidprintTree(intid){
  51. Sessionsession=HibernateUtils.getSession();
  52. try{
  53. session.beginTransaction();
  54. Noderoot=(Node)session.load(Node.class,id);
  55. printNode(root);
  56. session.getTransaction().commit();
  57. }catch(RuntimeExceptione){
  58. e.printStackTrace();
  59. session.getTransaction().rollback();
  60. }finally{
  61. HibernateUtils.closeSession(session);
  62. }
  63. }
  64. privatevoidprintNode(Nodenode){
  65. if(node==null){
  66. return;
  67. }
  68. intlevel=node.getLevel();
  69. if(level>0){
  70. for(inti=0;i<level;i++){
  71. System.out.print("|");
  72. }
  73. System.out.print("--");
  74. }
  75. System.out.println(node.getName()
  76. +(node.isLeaf()?"":"["+node.getChildren().size()+"]"));
  77. Setchildren=node.getChildren();
  78. for(Iteratoriter=children.iterator();iter.hasNext();){
  79. Nodechild=(Node)iter.next();
  80. printNode(child);
  81. }
  82. }
  83. }

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在信号处理领域,DOA(Direction of Arrival)估计是一项关键技术,主要用于确定多个信号源到达接收阵列的方向。本文将详细探讨三种ESPRIT(Estimation of Signal Parameters via Rotational Invariance Techniques)算法在DOA估计中的实现,以及它们在MATLAB环境中的具体应用。 ESPRIT算法是由Paul Kailath等人于1986年提出的,其核心思想是利用阵列数据的旋转不变性来估计信号源的角度。这种算法相比传统的 MUSIC(Multiple Signal Classification)算法具有较低的计算复杂度,且无需进行特征值分解,因此在实际应用中颇具优势。 1. 普通ESPRIT算法 普通ESPRIT算法分为两个主要步骤:构造等效旋转不变系统和估计角度。通过空间平移(如延时)构建两个子阵列,使得它们之间的关系具有旋转不变性。然后,通过对子阵列数据进行最小二乘拟合,可以得到信号源的角频率估计,进一步转换为DOA估计。 2. 常规ESPRIT算法实现 在描述中提到的`common_esprit_method1.m`和`common_esprit_method2.m`是两种不同的普通ESPRIT算法实现。它们可能在实现细节上略有差异,比如选择子阵列的方式、参数估计的策略等。MATLAB代码通常会包含预处理步骤(如数据归一化)、子阵列构造、旋转不变性矩阵的建立、最小二乘估计等部分。通过运行这两个文件,可以比较它们在估计精度和计算效率上的异同。 3. TLS_ESPRIT算法 TLS(Total Least Squares)ESPRIT是对普通ESPRIT的优化,它考虑了数据噪声的影响,提高了估计的稳健性。在TLS_ESPRIT算法中,不假设数据噪声是高斯白噪声,而是采用总最小二乘准则来拟合数据。这使得算法在噪声环境下表现更优。`TLS_esprit.m`文件应该包含了TLS_ESPRIT算法的完整实现,包括TLS估计的步骤和旋转不变性矩阵的改进处理。 在实际应用中,选择合适的ESPRIT变体取决于系统条件,例如噪声水平、信号质量以及计算资源。通过MATLAB实现,研究者和工程师可以方便地比较不同算法的效果,并根据需要进行调整和优化。同时,这些代码也为教学和学习DOA估计提供了一个直观的平台,有助于深入理解ESPRIT算法的工作原理。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值