Java 在Traver中的setProperty之后显示错误的值

下面是一个具有两种边的neo4j图。首先我们遍历边（BFS），然后对每种边的属性值进行规格化。但是，当在不同的循环中检索值时，会打印错误的值

这看起来很奇怪。也许我错过了什么。如果有的话，这将是非常有帮助的 有人让我纠正或建议我一个更好的方法来避免这个错误。提前感谢：）

package org.neo4j.examples；
导入java.io.File；
导入java.util.HashMap；
导入org.neo4j.graphdb.Direction；
导入org.neo4j.graphdb.GraphDatabaseService；
导入org.neo4j.graphdb.Node；
导入org.neo4j.graphdb.Path；
导入org.neo4j.graphdb.Relationship；
导入org.neo4j.graphdb.RelationshipType；
导入org.neo4j.graphdb.Transaction；
导入org.neo4j.graphdb.factory.GraphDatabaseFactory；
导入org.neo4j.graphdb.traversal.Evaluator；
导入org.neo4j.graphdb.traversal.Evaluators；
导入org.neo4j.graphdb.traversal.TraversalDescription；
导入org.neo4j.graphdb.traversal.Traverser；
导入org.neo4j.graphdb.traversal.university；
导入org.neo4j.kernel.Traversal；
公共类MyNeo4jExpt{
公共枚举RelTypes实现RelationshipType{
共同事件、运动
}
私有静态最终字符串MY\u TRAVERSAL\u DB=“target/MY TRAVERSAL DB”；
专用GraphDatabaseService graphDb；
静态节点shop1=null；
Node shop2=null；
Node shop3=null；
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
MyNeo4jExpt矩阵=新的MyNeo4jExpt（）；
matrix.setUp（）；
矩阵归一化（shop1）；
matrix.shutdown（）；
}
公共作废设置（）{
deleteFileOrDirectory（新文件（MY_TRAVERSAL_DB））；
graphDb=新GraphDatabaseFactory（）
.newEmbeddedDatabase（MY_TRAVERSAL_DB）；
registerShutdownHook（）；
createNodespace（）；
}
公共空间关闭（）{
graphDb.shutdown（）；
}
public void createNodespace（）{
try（事务tx=graphDb.beginTx（））{
//创建店铺1
shop1=graphDb.createNode（）；
店铺1.setProperty（“名称”、“家具店-1”）；
//创建店铺2
shop2=graphDb.createNode（）；
店铺2.setProperty（“名称”、“家具店-2”）；
//创建店铺3
shop3=graphDb.createNode（）；
店铺3.setProperty（“名称”、“家具店-3”）；
////将shop1连接到shop2///////
关系rel=shop1.createRelationshipTo（shop2，
相关类型（共发生）；
相对setProperty（“coOccurence”（双精度）5.0）；
rel=shop1.createRelationshipTo（shop2，RelTypes.CAMPAIGN）；
相对setProperty（“家具”（双）0.6）；
相对setProperty（“椅子”（双）0.6）；
相对setProperty（“表”，（双精度）0.6）；
// ///////////////////////////////////////
////将shop1连接到shop3///////
rel=shop1.createRelationshipTo（shop3，RelTypes.CAMPAIGN）；
相对setProperty（“家具”（双）0.7）；
相对setProperty（“沙发”（双）0.7）；
// ////////////////////////////////////////
////将shop3连接到shop2///////
rel=shop3.createRelationshipTo（shop2，RelTypes.CO_事件）；
相对setProperty（“coOccurence”（双精度）4.0）；
// ///////////////////////////////////////
成功（）；
}
}
//此函数调用给定节点上的BFS
//并规范化关系属性w.r.t
//右边缘类型（RelType）
私有遍历器规范化（最终节点）{
Traverser friendsTraverser=null；
HashMap relHash=新HashMap（）；
try（事务tx=graphDb.beginTx（））{
if（node==null）{
System.out.println（“\n完整节点\n”）；
返回null；
}
friendsTraverser=getFriends（节点）；
if（friendsTraverser==null）{
System.err.println（“空遍历器”）；
返回null；
}
HashMap maxVal=新的HashMap（）；
字符串temp=“”；
try（事务tx2=graphDb.beginTx（））{
for（路径friendPath:friendsTraverser）{
System.out.println（“\nAt depth”+friendPath.length（）
+“=>”+friendPath.toString（））；
//输出+=friendPath.startNode（）.getProperty（“名称”）+“”
// ;
for（Relationship rel:friendPath.relationships（））{
temp=”“+rel.getStartNode（）.getProperty（“名称”）；
for（字符串名称：rel.getPropertyKeys（））{
Double propVal=（Double）rel.getProperty（name）；
temp+=“--”+”（“+name+”，“+propVal+”）；
if（（maxVal.get（rel.getType（））==null）
||（propVal>maxVal.get（rel.getType（）））{
maxVal.put（rel.getType（），propVal）；//
尝试删除内部事务，它们对您没有帮助
当设置或打印出值时，还打印出节点和rel的id，以便您看到，您实际上正在查看相同的对象
package org.neo4j.examples;

import java.io.File;
import java.util.HashMap;

import org.neo4j.graphdb.Direction;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Node;
import org.neo4j.graphdb.Path;
import org.neo4j.graphdb.Relationship;
import org.neo4j.graphdb.RelationshipType;
import org.neo4j.graphdb.Transaction;
import org.neo4j.graphdb.factory.GraphDatabaseFactory;
import org.neo4j.graphdb.traversal.Evaluator;
import org.neo4j.graphdb.traversal.Evaluators;
import org.neo4j.graphdb.traversal.TraversalDescription;
import org.neo4j.graphdb.traversal.Traverser;
import org.neo4j.graphdb.traversal.Uniqueness;
import org.neo4j.kernel.Traversal;

public class MyNeo4jExpt {
    public enum RelTypes implements RelationshipType {
        CO_OCCURANCE, CAMPAIGN
    }

    private static final String MY_TRAVERSAL_DB = "target/my-traversal-db";
    private GraphDatabaseService graphDb;

    static Node shop1 = null;
    Node shop2 = null;
    Node shop3 = null;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyNeo4jExpt matrix = new MyNeo4jExpt();
        matrix.setUp();
        matrix.normalizeRelations(shop1);
        matrix.shutdown();
    }

    public void setUp() {
        deleteFileOrDirectory(new File(MY_TRAVERSAL_DB));
        graphDb = new GraphDatabaseFactory()
                .newEmbeddedDatabase(MY_TRAVERSAL_DB);
        registerShutdownHook();
        createNodespace();
    }

    public void shutdown() {
        graphDb.shutdown();
    }

    public void createNodespace() {
        try (Transaction tx = graphDb.beginTx()) {

            // Create shop1
            shop1 = graphDb.createNode();
            shop1.setProperty("name", "FurnitureShop-1");

            // create shop2
            shop2 = graphDb.createNode();
            shop2.setProperty("name", "FurnitureShop-2");

            // create shop3
            shop3 = graphDb.createNode();
            shop3.setProperty("name", "FurnitureShop-3");

            // ////// connect shop1 to shop2 ///////
            Relationship rel = shop1.createRelationshipTo(shop2,
                    RelTypes.CO_OCCURANCE);
            rel.setProperty("coOccurence", (Double) 5.0);

            rel = shop1.createRelationshipTo(shop2, RelTypes.CAMPAIGN);
            rel.setProperty("furniture", (Double) 0.6);
            rel.setProperty("chair", (Double) 0.6);
            rel.setProperty("table", (Double) 0.6);
            // ///////////////////////////////////////

            // ///// connect shop1 to shop3///////
            rel = shop1.createRelationshipTo(shop3, RelTypes.CAMPAIGN);
            rel.setProperty("furniture", (Double) 0.7);
            rel.setProperty("sofa", (Double) 0.7);
            // ////////////////////////////////////////

            // ////// connect shop3 to shop2 ///////
            rel = shop3.createRelationshipTo(shop2, RelTypes.CO_OCCURANCE);
            rel.setProperty("coOccurence", (Double) 4.0);
            // ///////////////////////////////////////

            tx.success();
        }
    }

    // this function calls a BFS on the given node
    // and normalize relation properties w.r.t. the
    // right edge type (RelType)
    private Traverser normalizeRelations(final Node node) {
        Traverser friendsTraverser = null;
        HashMap<Relationship, Path> relHash = new HashMap<Relationship, Path>();
        try (Transaction tx = graphDb.beginTx()) {
            if (node == null) {
                System.out.println("\nNULL NODE\n");
                return null;
            }
            friendsTraverser = getFriends(node);

            if (friendsTraverser == null) {
                System.err.println("NULL TRAVERSER");
                return null;
            }

            HashMap<RelationshipType, Double> maxVal = new HashMap<RelationshipType, Double>();
            String temp = "";
            try (Transaction tx2 = graphDb.beginTx()) {
                for (Path friendPath : friendsTraverser) {
                    System.out.println("\nAt depth " + friendPath.length()
                            + " => " + friendPath.toString());
                    // output += friendPath.startNode().getProperty("name")+ " "
                    // ;
                    for (Relationship rel : friendPath.relationships()) {
                        temp = " " + rel.getStartNode().getProperty("name");
                        for (String name : rel.getPropertyKeys()) {
                            Double propVal = (Double) rel.getProperty(name);
                            temp += "---" + "(" + name + ", " + propVal + ")";
                            if ((maxVal.get(rel.getType()) == null)
                                    || (propVal > maxVal.get(rel.getType()))) {
                                maxVal.put(rel.getType(), propVal); // <----
                                                                    // Save the
                                                                    // Max Value
                                                                    // for
                                                                    // Particular
                                                                    // Rel Type
                            }
                        }

                        temp += "----" + rel.getEndNode().getProperty("name")
                                + "\n";

                    }
                    // numberOfFriends++;
                    System.out.println(temp);
                }
                tx2.success();
            }
            System.out.println("*************************************");
            System.out.println("**** Devide w.r.t maxVal = "
                    + maxVal.entrySet()
                    + "And Normalized Values Are:*************");
            System.out.println("*************************************");
            temp = "";
            for (Path friendPath : friendsTraverser) {
                System.out.println("\nAt depth " + friendPath.length() + " => "
                        + friendPath.toString());
                for (Relationship rel : friendPath.relationships()) {
                    temp = "" + rel.getStartNode().getProperty("name");
                    try (Transaction tx3 = graphDb.beginTx()) {
                        for (String propName : rel.getPropertyKeys()) {
                            Double propVal = (Double) rel.getProperty(propName)
                                    / maxVal.get(rel.getType());
                            rel.setProperty(propName, propVal);
                            temp += "---" + "(" + propName + ", "
                                    + rel.getProperty(propName) + ")";
                        }
                        tx3.success();
                    }
                    temp += "----" + rel.getEndNode().getProperty("name")
                            + "\n";
                }
                System.out.println(temp);
            }
            tx.success();

        }
        System.out
                .println("\n+++++++++++++NOW WRONG VALUES WILL BE PRINTED+++++++++++++++");
        try (Transaction tx = graphDb.beginTx()) {
            String temp = "";
            for (Path friendPath : friendsTraverser) {
                System.out.println("\nAt depth " + friendPath.length() + " => "
                        + friendPath.toString());
                for (Relationship rel : friendPath.relationships()) {
                    temp = " " + rel.getStartNode().getProperty("name");
                    for (String propName : rel.getPropertyKeys()) {
                        temp += "---" + "(" + propName + ", "
                                + rel.getProperty(propName) + ")";
                    }
                    temp += "----" + rel.getEndNode().getProperty("name")
                            + "\n";
                }
                System.out.println(temp);
            }
            tx.success();
        }
        return friendsTraverser;
    }

    // START SNIPPET: get-friends
    private static Traverser getFriends(final Node person) {
        TraversalDescription td = Traversal.description().breadthFirst()
                .relationships(RelTypes.CAMPAIGN, Direction.BOTH)
                .relationships(RelTypes.CO_OCCURANCE, Direction.BOTH)
                .evaluator(Evaluators.toDepth(10))
                .evaluator(Evaluators.excludeStartPosition())
                .uniqueness(Uniqueness.RELATIONSHIP_GLOBAL);
        return td.traverse(person);
    }

    // END SNIPPET: get-friends

    private void registerShutdownHook() {
        // Registers a shutdown hook for the Neo4j instance so that it
        // shuts down nicely when the VM exits (even if you "Ctrl-C" the
        // running example before it's completed)
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                graphDb.shutdown();
            }
        });
    }

    private static void deleteFileOrDirectory(final File file) {
        if (!file.exists()) {
            return;
        }

        if (file.isDirectory()) {
            for (File child : file.listFiles()) {
                deleteFileOrDirectory(child);
            }
        } else {
            file.delete();
        }
    }
}

At depth 1 => (0)--[CAMPAIGN,1]-->(1)
 FurnitureShop-1---(furniture, 0.6)---(chair, 0.6)---(table, 0.6)----FurnitureShop-2


At depth 1 => (0)--[CAMPAIGN,2]-->(2)
 FurnitureShop-1---(furniture, 0.7)---(sofa, 0.7)----FurnitureShop-3


At depth 1 => (0)--[CO_OCCURANCE,0]-->(1)
 FurnitureShop-1---(coOccurence, 5.0)----FurnitureShop-2


At depth 2 => (0)--[CAMPAIGN,1]-->(1)<--[CO_OCCURANCE,3]--(2)
 FurnitureShop-3---(coOccurence, 4.0)----FurnitureShop-2

*************************************
**** Devide w.r.t maxVal = [RelationshipTypeToken[name:CO_OCCURANCE, id:0]=5.0, RelationshipTypeToken[name:CAMPAIGN, id:1]=0.7]And Normalized Values Are:*************
*************************************

At depth 1 => (0)--[CAMPAIGN,1]-->(1)
FurnitureShop-1---**(furniture, 0.8571428571428572)---(chair, 0.8571428571428572)---(table, 0.8571428571428572)**----FurnitureShop-2


At depth 1 => (0)--[CAMPAIGN,2]-->(2)
FurnitureShop-1---(furniture, 1.0)---(sofa, 1.0)----FurnitureShop-3


At depth 1 => (0)--[CO_OCCURANCE,0]-->(1)
FurnitureShop-1---(coOccurence, 1.0)----FurnitureShop-2


At depth 2 => (0)--[CAMPAIGN,1]-->(1)<--[CO_OCCURANCE,3]--(2)
FurnitureShop-3---(coOccurence, 0.8)----FurnitureShop-2


+++++++++++++NOW **WRONG VALUES** WILL BE PRINTED+++++++++++++++

At depth 1 => (0)--[CAMPAIGN,1]-->(1)
 FurnitureShop-1---**(furniture, 1.2244897959183676)---(chair, 1.2244897959183676)**---(table, 1.2244897959183676)----FurnitureShop-2


At depth 1 => (0)--[CAMPAIGN,2]-->(2)
 FurnitureShop-1---(furniture, 1.0)---(sofa, 1.0)----FurnitureShop-3


At depth 1 => (0)--[CO_OCCURANCE,0]-->(1)
 FurnitureShop-1---(coOccurence, 1.0)----FurnitureShop-2


At depth 2 => (0)--[CAMPAIGN,1]-->(1)<--[CO_OCCURANCE,3]--(2)
 FurnitureShop-3---(coOccurence, 0.8)----FurnitureShop-2