1

在我的原始代码中，我将节点添加到树中。我的目标是以某种方式访问​​我在树中添加的最后一个节点（我的想法是创建另一个指向最后一个对象的对象（我的原始示例中的节点））。

public class RandomSubClass 
{
    int firstNum;
}    

import java.util.LinkedList;

public class RandomClass 
{
    LinkedList<RandomSubClass> myListOfObjects = new LinkedList<RandomSubClass>();

    void addItem(int firstNum, RandomSubClass toBeReturned)
    {       
        RandomSubClass o1 = new RandomSubClass();
        o1.firstNum = firstNum;
        myListOfObjects.add(o1);

        // Here I was thinking that 'toBeReturned' will get same address as
        // 'o1', and by changing 'toBeReturned' (in main), values in 'o1' change
        //
        toBeReturned = o1;

        // This following commented code worked, 
        // but I can't use it in my original code.
        //
        // The reason I can't use it is because when I add a node to a tree, 
        // I start at the root and trace the new node's way to a new leaf, 
        // which makes it hard to do (simply) that.
        //
        //toBeReturned.firstNum = firstNum;
        //myListOfObjects.add(toBeReturned);
    }   
}

public class Main 
{
    public static void main(String[] args) 
    {
        RandomClass myList = new RandomClass();

        RandomSubClass r1 = new RandomSubClass();
        RandomSubClass r2 = new RandomSubClass();

        myList.addItem(1, r1);
        myList.addItem(2, r2);

        // I would like to do that, and see changes in the node in 'myList'
        //  
        r1.firstNum = 10;
        r2.firstNum = 20;
    }
}

在将节点添加到树后，我想检查有关该节点的某些内容，如果它满足某些条件，我想更改该节点的标志。

我可以再次重新跟踪节点（从根开始），但我的树可能会在某个时候变得很大，这需要时间。因此，如果我在添加该节点时获得了该节点的地址，并且在检查了我的条件之后，我可以修改该地址处的标志，知道它将更改该节点处的标志（最后添加）。

4

3 回答 3

2

是的，你可以这样做。我允许你。:-) 但是您的示例代码不起作用，因为 Java 对象是按值传递的，而不是按引用传递的。也就是说，当您将对象传递给函数时，如果您重新分配该对象，它对调用者没有影响。例如：

void caller()
{
  String s1="Hello";
  updateString(s1);
  System.out.println(s1);
}
void updateString(String s1)
{
  s1="Goodbye";
}

这个函数的输出是“Hello”，而不是“Goodbye”。updateString 函数中的赋值不会改变调用者传入的值。

有（至少）三种方法可以做你想做的事。

方法一：最简单的就是返回新的对象，而不是更新一个参数：

SomeObject addItem(int firstnum)
{
  SomeObject o1=new SomeObject();
  o1.firstnum=firstnum;
  objectList.add(o1);
  return o1;
}
...
void callingFunction()
{
  SomeObject newObject=addItem(1);
  newObject.secondnum=2;
  ... etc ...
}

我更喜欢这种不需要其他返回值的方法：它简洁明了。

方法2：创建一个全局变量并在其中存储对象的句柄。但是这种方法很糟糕，因为全局变量通常很糟糕。我只是提到它告诉你不要这样做。

方法 3：创建一个包装器来保存对对象的引用。然后将包装器传递给“add”函数，该函数可以更新类内的值。

class SomeObjectWrapper
{
  public SomeObject someObject;
}
...
void addItem(int firstnum, SomeObjectWrapper sow)
{
  SomeObject o1=new SomeObject();
  o1.firstnum=firstnum;
  objectList.add(o1);
  sow.someobject=o1;
}
...
void callingFunction()
{
  SomeObjectWrapper sow=new SomeObjectWrapper();
  SomeObject newObject=addItem(1, sow);
  sow.someObject.secondnum=2;
  ... whatever ...
}
于 2012-04-26T17:59:16.663 回答
1

用返回值来做这件事怎么样：

RandomSubClass addItem(int firstNum)
{       
    RandomSubClass o1 = new RandomSubClass();
    o1.firstNum = firstNum;
    myListOfObjects.add(o1);

    // Here I was thinking that 'toBeReturned' will get same address as
    // 'o1', and by changing 'toBeReturned' (in main), values in 'o1' change
    //
    ....
    return o1
}
于 2012-04-26T17:50:03.233 回答
0

在 Java 中，所有对象都通过地址的参数返回/传递。只有原始类型（int、float、double ...）按值传递，如果您希望原始类型按地址传递，请使用：-Integer 代替 int -Double 代替 double -Float 代替 Float -ect。 ..

于 2012-04-26T17:55:07.977 回答