neo4j遍历示例它没有'；t给出正确的节点号

0我想使用neo4j进行遍历。 而它给了我newno的输出

为什么它没有从0-4中给我正确的节点号？深度为1-3 谢谢 我只想在这个图中逐级遍历，并分别输出向后和向前

预期输出应如下所示：

(1)
(1)--[KNOWS,0]-->(2)
(1)--[KNOWS,0]-->(2)--[KNOWS,2]-->(2)
(1)--[KNOWS,0]-->(4)

知道后的数字也应该像更小的数字。喜欢 java代码是：

public class TraversalExample
{
    private GraphDatabaseService db;
    private TraversalDescription friendsTraversal;

    public TraversalExample( GraphDatabaseService db )
    {
        this.db = db;
        // START SNIPPET: basetraverser
        friendsTraversal = db.traversalDescription()
                .depthFirst()
                .relationships( Rels.KNOWS )
                .uniqueness( Uniqueness.RELATIONSHIP_GLOBAL );
        // END SNIPPET: basetraverser
    }

    public static void main( String[] args )
    {
        final String DB_PATH = "target/neo4j-hello-db";
        GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH);
        TraversalExample op = new TraversalExample( db );
        op.createTheGraph();
        op.shutdownGraph();
    }
    public void shutdownGraph()
    {
        try
        {
            if ( db != null )
            {
                db.shutdown();
            }
        }
        finally
        {
            db = null;
        }
    }

    public Node createTheGraph()
    {
        try ( Transaction tx = db.beginTx() )
        {
            // START SNIPPET: createGraph

            Node[] newno=new Node[5];
            for(int i=0; i<newno.length; i++){
                newno[i]=db.createNode();
            }

            newno[1].createRelationshipTo(newno[2], Rels.KNOWS );
            newno[1].createRelationshipTo(newno[4], Rels.KNOWS );
            newno[4].createRelationshipTo(newno[2], Rels.KNOWS );
            newno[2].createRelationshipTo(newno[3], Rels.KNOWS );
            System.out.println(knowsTraverserforward(newno[1]));

            return newno[1];
        }
    }
    public String knowsLikesTraverser( Node node )
    {
        String output = "";
        // START SNIPPET: knowslikestraverser
        for ( Path position : db.traversalDescription()
                .depthFirst()
                .relationships( Rels.KNOWS )
                .relationships( Rels.LIKES, Direction.INCOMING )
                .evaluator( Evaluators.toDepth( 5 ) )
                .traverse( node ) )
        {
            output += position + "\n";
        }
        // END SNIPPET: knowslikestraverser
        return output;
    }
    public String knowsTraverserforward( Node node )
    {
        String output = "";
        // START SNIPPET: knowslikestraverser
        for ( Path position : db.traversalDescription()
                .depthFirst()
                .relationships( Rels.KNOWS, Direction.OUTGOING )
                .evaluator( Evaluators.toDepth(5 ) )
                .traverse( node ) )
        {
            output += position + "\n";
        }
        // END SNIPPET: knowslikestraverser
        return output;
    }


    public String traverseBaseTraverser( Node node )
    {
        String output = "";
        // START SNIPPET: traversebasetraverser
        for ( Path path : friendsTraversal.traverse( node ) )
        {
            output += path + "\n";
        }
        // END SNIPPET: traversebasetraverser
        return output;
    }

    public String depth3( Node node )
    {
        String output = "";
        // START SNIPPET: depth3
        for ( Path path : friendsTraversal
                .evaluator( Evaluators.toDepth( 3 ) )
                .traverse( node ) )
        {
            output += path + "\n";
        }
        // END SNIPPET: depth3
        return output;
    }

    public String depth4( Node node )
    {
        String output = "";
        // START SNIPPET: depth4
        for ( Path path : friendsTraversal
                .evaluator( Evaluators.fromDepth( 2 ) )
                .evaluator( Evaluators.toDepth( 4 ) )
                .traverse( node ) )
        {
            output += path + "\n";
        }
        // END SNIPPET: depth4
        return output;
    }

    public String nodes( Node node )
    {
        String output = "";
        // START SNIPPET: nodes
        for ( Node currentNode : friendsTraversal
                .traverse( node )
                .nodes() )
        {
            output += currentNode.getProperty( "name" ) + "\n";
        }
        // END SNIPPET: nodes
        return output;
    }

    public String relationships( Node node )
    {
        String output = "";
        // START SNIPPET: relationships
        for ( Relationship relationship : friendsTraversal
                .traverse( node )
                .relationships() )
        {
            output += relationship.getType().name() + "\n";
        }
        // END SNIPPET: relationships
        return output;
    }

    // START SNIPPET: sourceRels
    private enum Rels implements RelationshipType
    {
        LIKES, KNOWS
    }
    // END SNIPPET: sourceRels


}

公共类遍历示例
{
私有GraphDatabaseService数据库；
私人穿越描述友谊；
公共遍历示例（GraphDatabaseService db）
{
这个.db=db；
//开始代码段：BaseTranverser
friendsTraversal=db.traversalDescription（）
.depthFirst（）
.关系（相关知识）
.唯一性（唯一性、全球关系）；
//结束代码段：BaseTranverser
}
公共静态void main（字符串[]args）
{
最终字符串DB_PATH=“target/neo4j hello DB”；
GraphDatabaseService db=new GraphDatabaseFactory（）.newEmbeddedDatabase（db_路径）；
TraversalExample op=新的TraversalExample（db）；
op.createTheGraph（）；
op.shutdownGraph（）；
}
公共无效关闭图（）
{
尝试
{
如果（db！=null）
{
db.shutdown（）；
}
}
最后
{
db=null；
}
}
公共节点createTheGraph（）
{
try（事务tx=db.beginTx（））
{
//开始代码段：createGraph
节点[]newno=新节点[5]；
对于（int i=0；i任何节点的内部节点id都是一个实现细节。您不应该对节点id进行任何假设

我猜，如果您打印正在创建的节点的节点id，它们将与您的遍历非常相似：

for(int i=0; i<newno.length; i++){
    newno[i]=db.createNode();
    System.out.println(newno[i].getId());
}

用于（int i=0；我可以请你澄清你当前的结果是什么以及预期的结果是什么？更新！谢谢评论！你能解决我的问题吗？你好，你的解决方案没有解决问题嗨，我只是想让节点的打印id与我相同，比如从0到newno.length。比如0，1，2，3，4，…我只是你的代码。它给了我一个大节点e id像503047 503046 503045 503044 503043 503042 503041 503040 503055如何解决此问题
for(int i=0; i<newno.length; i++){
    newno[i]=db.createNode();
    System.out.println(newno[i].getId());
}