如何在java中显式实现按引用传递？

我知道java不支持按引用传递。但是，如果不是像在C/C++中那样直接实现的话，还有任何其他方式实现它的可能性吗？

没有。你不能这么做。这不是你可以“实施”的东西。这是语言的一个基本方面。

不。你不能这么做。这不是你可以“实施”的东西。这是语言的一个基本方面。

如果您试图做的是对原语值进行“引用”，您可以传递该原语值，这样您就可以在方法内修改原语值，并在所述方法外看到更改

。。。只需传递包含基元的数组，如下所示：

// By value
int value = 1;
changeValue(value); // changes value to 5
System.out.println(value); // prints 1

// By "reference"
int[] reference = {1};
changeValue(reference); // changes value inside "reference" to 5
System.out.println(reference[0]); // prints 5

// Methods
void changeValue(int value) { value = 5; }
void changeValue(int[] reference) { reference[0] = 5; }

请记住，这不是“通过引用传递”。Java没有传递对值的引用，而是传递数组引用的值。
关于这一点，您可以阅读以获得更好的讨论。

如果您试图做的是对一个原语值进行“引用”，您可以传递该原语值，这样您就可以在方法内修改原语值，并在所述方法外看到更改

。。。只需传递包含基元的数组，如下所示：

// By value
int value = 1;
changeValue(value); // changes value to 5
System.out.println(value); // prints 1

// By "reference"
int[] reference = {1};
changeValue(reference); // changes value inside "reference" to 5
System.out.println(reference[0]); // prints 5

// Methods
void changeValue(int value) { value = 5; }
void changeValue(int[] reference) { reference[0] = 5; }

请记住，这不是“通过引用传递”。Java没有传递对值的引用，而是传递数组引用的值。

---

关于这一点，您可以阅读以获得更好的讨论。

传递值是经过设计的：

f（x）

可能会改变x值的内部结构，但x不会获得另一个值_例如，不能使用f的形式参数将null赋值给f中的x

在java中，可以通过函数的结果执行输入输出参数：

插入节点

就是这样一种方法

public class SortedLinkedList<T extends Comparable<T>> {
    private static class Node { ... }
    Node head;
    int size;

    public void insert(T data) {
        head = insertInNodes(head, data);
    }

    private Node insertInNodes(Node node, T data) {
        if (node == null || data.compareTo(node.data) < 0) {
            ++size;
            return new Node(data, node);
        }
        if (data.compareTo(node.data) > 0) {
            node.next = insertInNodes(node.next, data);
        }
        return node;
    }
}

公共类分类链接列表{
私有静态类节点{…}
节点头；
整数大小；
公共空白插入（T数据）{
head=插入节点（head，数据）；
}
专用节点插入节点（节点节点，T数据）{
if（node==null | | data.compareTo（node.data）<0）{
++大小；
返回新节点（数据、节点）；
}
if（data.compareTo（node.data）>0）{
node.next=插入节点（node.next，数据）；
}
返回节点；
}
}

通过引用传递需要伪造它：传递一个容器对象，然后组件实际上就是一个引用。例如，一个包含一个元素的数组或一个类似于

Atomic

的包装类

通过传递所需“变量”的getter和setter，可以实现更纯形式的按引用传递

公共作废插入（T数据）{
插入节点（this:：getHead，this:：setHead，data）；
//或插入节点（（）->head，（n）->head=n，数据）；
}
私有void插入节点（供应商getter、消费者setter、T数据）{
if（getter.get（）==null | | data.compareTo（getter.get（）.data）<0）{
++大小；
apply（新节点（数据，getter.get（））；
}
if（data.compareTo（node.data）>0）{
//插入节点（（）->node.next，（n）->node.next=n，数据）；
//或
插入节点（节点：：setNext，节点：：getNext，数据）；
}
返回节点；
}

---

这个有用吗？不，仅在特定的用例中。

传递值是经过设计的：

f（x）

可能会改变x值的内部结构，但x不会获得另一个值_例如，不能使用f的形式参数将null赋值给f中的x

在java中，可以通过函数的结果执行输入输出参数：

插入节点

就是这样一种方法

public class SortedLinkedList<T extends Comparable<T>> {
    private static class Node { ... }
    Node head;
    int size;

    public void insert(T data) {
        head = insertInNodes(head, data);
    }

    private Node insertInNodes(Node node, T data) {
        if (node == null || data.compareTo(node.data) < 0) {
            ++size;
            return new Node(data, node);
        }
        if (data.compareTo(node.data) > 0) {
            node.next = insertInNodes(node.next, data);
        }
        return node;
    }
}

公共类分类链接列表{
私有静态类节点{…}
节点头；
整数大小；
公共空白插入（T数据）{
head=插入节点（head，数据）；
}
专用节点插入节点（节点节点，T数据）{
if（node==null | | data.compareTo（node.data）<0）{
++大小；
返回新节点（数据、节点）；
}
if（data.compareTo（node.data）>0）{
node.next=插入节点（node.next，数据）；
}
返回节点；
}
}

通过引用传递需要伪造它：传递一个容器对象，然后组件实际上就是一个引用。例如，一个包含一个元素的数组或一个类似于

Atomic

的包装类

通过传递所需“变量”的getter和setter，可以实现更纯形式的按引用传递

公共作废插入（T数据）{
插入节点（this:：getHead，this:：setHead，data）；
//或插入节点（（）->head，（n）->head=n，数据）；
}
私有void插入节点（供应商getter、消费者setter、T数据）{
if（getter.get（）==null | | data.compareTo（getter.get（）.data）<0）{
++大小；
apply（新节点（数据，getter.get（））；
}
if（data.compareTo（node.data）>0）{
//插入节点（（）->node.next，（n）->node.next=n，数据）；
//或
插入节点（节点：：setNext，节点：：getNext，数据）；
}
返回节点；
}

---

这个有用吗？不，仅在特定的用例中。

您实际上想做什么？不管是什么，都可能有办法做到。Java对对象使用按引用传递，对原语使用按值传递，但不知道是否有办法使其显式化。@SBylemans没有。Java按值传递引用。这与按引用传递不同，因为在C++C中没有按引用传递。您可以执行类似于“void method（ArgClass[]arg）”的操作，然后可以分配arg[0]=。。。它的行为更像一个指针/引用。“我知道这不可能做到，但无论如何我都想做到。”。Tha