Java中的“引用传递”

做Java的小伙伴们肯定都知道，java的参数传递仅仅支持值传递，不像C#中可以用ref、out关键字传递引用！！

今天小编突然脑洞大开，Java也可以“引用传递”！！

话不多说，先上一段基本的Java代码

值类型参数传递

public static void main(String[] args) {
    int num = 9;
    change(num);
    System.out.println("main --> num:" + num);
}

private static void change(int num) {
    num += 2;
    System.out.println("change --> num:" + num);
}

输出结果

这个没有疑问！so easy

引用类型参数传递（String对象和基本数据类型对象）

用String做演示

public static void main(String[] args) {
    String str = "--mainMethod--";
    change(str);
    System.out.println("main --> str:" + str);
}

private static void change(String str) {
    str = "--changeMethod--";
    System.out.println("change --> str:" + str);
}

 

输出结果

也没有疑问？不管有没有，这里都要稍作解释一下

我们加上输出哈希编码，看看结果如何！

public static void main(String[] args) {
    String str = "--mainMethod--";
    System.out.println("main --> "+str.hashCode());
    change(str);
    System.out.println("main --> str:" + str);
}

private static void change(String str) {
    str = "--changeMethod--";
    System.out.println("change --> "+str.hashCode());
    System.out.println("change --> str:" + str);
}

 

输出结果

我们都知道，一般情况下 hashCode 的值不一样，表示对象也不一样。因此得出结果：这个字符串对象的引用在change方法中发生了改变（在Java中，只要是String对象中的值发生改变，就会重新创建一个String对象）。

但是为什么main方法中的str没有改变呢？

这里要说到Java的方法传参了。Java中方法传参是值类型传递的，这个大家都知道，但是，不仅如此，传送的还是参数的副本。

什么意思呢？就是在传递参数的同时，Java虚拟机做了个操作，将这个参数备份了一下，将副本传给这个方法。

在上面这个change方法中，副本的引用地址发生了改变，会影响到原参数吗？答案：不会的！

接着再看一段代码

引用类型参数传递（非（String对象和基本数据类型对象））

用List做演示

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("chb");
    change(list);
    System.out.println("main --> size:"+list.size());
    for (String item : list) {
        System.out.println("foreach --> "+item);
    }
}

private static void change(List<String> list) {
    list.add("yiming");
    System.out.println("change --> size:"+list.size());
}

输出结果

唉！怎么回事，这个值竟然添加进去了！

先嫑（不要）惊讶，看完下面代码，再惊讶也不晚！！

输出一下哈希编码

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("chb");
    System.out.println("main --> hashCode:"+list.hashCode());
    change(list);
    System.out.println("main --> size:"+list.size());
    for (String item : list) {
        System.out.println("foreach --> "+item);
    }
}

private static void change(List<String> list) {
    list.add("yiming");
    System.out.println("change --> hashCode:"+list.hashCode());
    System.out.println("change --> size:"+list.size());
}

输出结果

what？和上面的结论不一样了？hashCode改变了，为什么main函数中的list发生了改变呢？

输出一下，调用change方法之后的list的哈希编码

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("chb");
    System.out.println("main --> hashCode:"+list.hashCode());
    change(list);
    System.out.println("main --> hashCode:"+list.hashCode());
    System.out.println("main --> size:"+list.size());
    for (String item : list) {
        System.out.println("foreach --> "+item);
    }
}

private static void change(List<String> list) {
    list.add("yiming");
    System.out.println("change --> hashCode:"+list.hashCode());
    System.out.println("change --> size:"+list.size());
}

输出结果

是不是有些明白了？

再看下面代码，在change方法中重新new一次

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("chb");
    System.out.println("main --> hashCode:"+list.hashCode());
    change(list);
    System.out.println("main --> hashCode:"+list.hashCode());
    System.out.println("main --> size:"+list.size());
    for (String item : list) {
        System.out.println("foreach --> "+item);
    }
}

private static void change(List<String> list) {
    list = new ArrayList<String>();
    list.add("yiming");
    System.out.println("change --> hashCode:"+list.hashCode());
    System.out.println("change --> size:"+list.size());
}

输出结果

越看越乱，看看源码（add方法源码以及add方法关联方法源码）

//add
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

//ensureCapacityInternal
private void ensureCapacityInternal(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
         grow(minCapacity);
}

//grow
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

看到这里，原来如此，调用list函数的方法时，list集合长度改变，相当于重新创建了list集合，所以才会hashCode改变

所以呢，小编想到的方法是什么呢？

找到一个规律：只要不是让传入的对象等于（=）另一个对象，这个对象所做的改变，是会影响调用者传入的对象的！

一段代码，搞懂！

public static void main(String[] args) {
    // 问题： 我想传入一个 String 实现 C# 中的 ref、out 关键字的作用
    // 思路：不能用等号
    // 用别的对象封装起来呗！！
    // 什么对象？非（基本数据类型对象和String对象）
    // 那么用list试试吧！
    String str = "chb";
    List<String> list = new ArrayList<String>();
    list.add(str);// 封装
    change(list);// 此方法中进行一系列操作，将 str 的值进行改变
    str = list.get(0);//将操作后的值，返还给 str
    System.out.println(str);
}

private static void change(List<String> list) {
    // 一系列操作省略
    list.set(0, "wsm");// 将集合中下标是0的值，替换成：wsm
}

输出结果

这个时候就会有人说了，我用返回值不行吗？

小编给你的回答：可以，完全可以！但是，你想一下，编写的代码不可能总像小编写的这么简单吧！返回值要是返回了另一个数据呢？你这个值怎么办？

private static Element teleseme_template(String[] obj, List<List<String[]>> s) throws Exception {
//方法体保密
}

就像上面这个方法，怎么办？我在这个方法中更改了s参数中的List<String[]>集合的值，但是，在调用者那边还需要得到s参数里面List<String[]>的新值，而我的返回值类型却是一个实体！！

若有疑问或者发现小编写的有问题，还请留言！谢谢！！