Java中的输出参数

class Foo {

    public static void main(String[] args) {
        String x = "foo";
        getString(x);
        System.out.println(x);
    }

    public static void getString(String output){
        output = "Hello World"
    }
}

在上述程序中,字符串“foo”将被输出, 不 “你好,世界”。

String ),则必须构建某种包装器类,您可以将其传递:

class Holder<T> {
    public Holder(T value) {
        this.value = value;
    }
    public T value;
}

public static void main(String[] args) {
    String x = "foo";
    Holder<String> h = new Holder(x);
    getString(h);
    System.out.println(h.value);
}

public static void getString(Holder<String> output){
    output.value = "Hello World"
}

这个例子是错误的,Java没有输出参数。

要模仿这种行为,您可以做的一件事是:

public void doSomething(String[] output) {
    output[0] = "Hello World!";
}

但我认为这在多个层面上都很糟糕

在.NET中,有一个利用输出参数的有趣结构:

bool IDictionary.TryGet(key, out value);

object obj;
if (myList.TryGet(theKey, out obj))
{
  ... work with the obj;
}

如果我看到旧式代码,我经常责骂我的开发人员,如:

if (myList.Contains(theKey))
{
  obj = myList.Get(theKey);
}

你看,它把性能减半了。在Java中,无法在一次调用中区分现有项的空值和映射中不存在的项。有时这是必要的。

另一方面

void getString(StringBuilder builder) {
    builder.delete(0, builder.length());
    builder.append("hello world");
}

将起作用,但我看不出这样做有什么好处(除非需要返回多个值)。

有时,这种机制可以避免创建新对象。

例子: 如果适当的对象无论如何都存在,那么将其传递给方法并更改某些字段会更快。

这比在被调用的方法中创建一个新对象,并返回和分配其引用(产生需要收集的垃圾)更有效。

字符串是不可变的,不能对不可变对象使用Java的伪输出参数。

输出 getString 方法。如果你改变主意

状态 参数的参数。考虑下面的例子:

void handle(Request r) {
    doStuff(r.getContent());
    r.changeState("foobar");
    r.setHandled();
}

如果管理器使用单个请求调用多个句柄,则可以更改请求的状态,以允许(由其他处理程序)对修改的内容进行进一步处理。经理还可以决定停止处理。

优势:

• 您不需要返回包含新内容的特殊对象以及处理是否应该停止。该对象只能使用一次,创建该对象会浪费内存和处理能力。
• 您不必创建另一个请求对象,也不必让垃圾收集器清除现在已经过时的旧引用。
• 在某些情况下,你 创建一个新对象。例如,因为该对象是使用工厂创建的,而您无权访问它,或者因为该对象有侦听器,而您不知道如何告诉正在侦听旧请求的对象它们应该侦听新请求。

实际上,在java中不可能有out参数,但您可以通过编写泛型类(其中不可变的是泛型,带有value和setter以及getter)或使用数组(其中元素长度为0,长度为1),来解决方法对不可变字符串和基元的去引用问题是首先实例化的值,因为在某些情况下,您需要返回多个值,而必须编写一个类才能返回这些值,而该类仅被使用,这只是浪费了文本,并且不能真正重复使用。

现在作为C/C++和.Net(mono或MS)的一员,它提醒我java至少不支持原语的反引用;因此,我转而使用数组。

public static Boolean validate_index(int index, int arr_len, int[] rem1)
{
    if (index < 0 || arr_len <= 0) return false;

    Boolean retVal = (index >= 0 && index < arr_len);

    if (retVal && rem1 != null) rem1[0] = (arr_len - (index + 1));

    return retVal;

}

现在如果我们使用它,我们可以得到布尔返回和余数。

 public static void main(String[] args)
 {
    int[] ints = int[]{1, 2, 3, 4, 5, 6};
    int[] aRem = int[]{-1};
    //because we can only scapegoat the de-ref we need to instantiate it first.
    Boolean result = validate_index(3, ints.length, aRem);

    System.out.println("Validation = " + result.toString());
    System.out.println("Remainding elements equals " + aRem[0].toString());

 }

puts:验证=真 puts:重新标记元素等于2

数组元素总是指向堆栈上的对象或堆上对象的地址。因此,使用它作为反引用是绝对可能的,即使对于数组,也可以将其作为双数组实例化为myArrayPointer=new Class[1][],然后将其传入,因为有时在调用通过类似“Boolean tryToGetArray(SomeObject o,t[][]pArray)的算法之前,您不知道数组的长度'这将与c/c++中的'template bool tryToGetArray(SomeObject*p,T**ppArray)'或c#'bool tryToGetArray(SomeObject o,ref T[]array')相同。