读读这段Lambda表达式代码，测试下你对JAVA传参方式的理解程度

最新推荐文章于 2024-04-17 15:57:51 发布

强哥叨逼叨

最新推荐文章于 2024-04-17 15:57:51 发布

阅读量354

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/seanxwq/article/details/97416255

版权

java 专栏收录该内容

86 篇文章 11 订阅

订阅专栏

直接进入正题，首先我们有一个Uer对象如下：

static class Student {
    private String name;
    private int score;
    private int star;
    Student(String name, int score, int star){
        this.name = name;
        this.score = score;
        this.star = star;
    }
    //省略get set方法
}

然后我们假设一个场景：对成绩大于等于60分的同学都加一颗星，并输出这些学生信息。

来看看代码实现：

public static void main(String[] args) {
    List<Student> students = new ArrayList<>();
    for (int i=0; i<10; i++){
        Student student = new Student("student" + i, 55+i, 0);
        students.add(student);
    }
    //过滤用户
    filterUser(students);
    students.forEach(student -> System.out.println(student.getName() + "|" + student.getScore() + "|" + student.getStar()));
}

private static void filterUser(List<Student> students){
    students = students.stream().filter(student -> student.getScore() >= 60).collect(Collectors.toList());
    students.fo
}

大家可以先想想输出的结果是什么。然后再看看下面的输出和你想的是不是一样：

student0|55|0
student1|56|0
student2|57|0
student3|58|0
student4|59|0
student5|60|1
student6|61|1
student7|62|1
student8|63|1
student9|64|1

从上面的输出结果我们可以看到，按照我们正常的想法，应该是输出student5~9的学生，为什么把不及格的学生也输出出来了呢？难道过滤条件没有起到作用，可是，student5~9的学生的星星确实又都加了1了啊，这么说过滤应该是有效果的才对。

好吧，先卖个关子，强哥先问大家一道面试题：

问：以下对Java的方法传参方式哪个选项的说法是正确的：

Java传参方式是引用传递。
Java传参方式是值传递。
值传递和引用传递，区分的条件是传递的内容，如果是个值，就是值传递。如果是个引用，就是引用传递。
传递的参数如果是基本类型，那就是值传递，如果是对象，那就是引用传递。

答案是：（9+7-10）/3。（为了不让大家直接看出答案，大家计算完上面的算式就能得到结果）。

好吧，没错，Java的传参方式只有一种，那就是值传递。我相信很多人的答案会是4，对于基本类型，Java和很多语言一样用值传递这个很好理解，可是如果是对象类型，难道不是引用传递吗？这里我们就要先梳理下值传递和引用传递的区别了：

值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

也就是说，并不是我们给方法传递的是对象的引用，就是引用传递，而是要看传递给函数的是什么东西，是实际参数复制的一份值，还是实际参数对应的物理地址。

这么说可能不好理解，针对对象传递我们来举个形象的例子：

你有一把钥匙（对象引用在堆栈的地址），当你的朋友想要去你家（堆中具体的对象）的时候，如果你直接把你的钥匙给他了，这就是引用传递（也就相当于把对象引用对应的地址给了方法参数）。这种情况下，如果他对这把钥匙做了什么事情，比如他把钥匙弄断了（修改了对象引用的地址），那么这把钥匙还给你的时候，你自己的钥匙就是断了的这把。

而假如你有一把钥匙（对象引用在堆栈的地址），当你的朋友想要去你家的时候，你复刻了一把新钥匙（新的一个对象引用，与原对象引用在堆栈中的地址值不同，但该地址中存的值（指向对象的地址）是一样的）给他，自己的还在自己手里，这就是值传递。这种情况下，他对这把钥匙做什么都不会影响你手里的这把钥匙。

而Java中，只存在值传递而不存在引用传递！而Java中，只存在值传递而不存在引用传递！而Java中，只存在值传递而不存在引用传递！

重要的事情说三遍。那既然是这样，为什么上面我们在filterUser中修改了students列表对象值，在输出的时候却还是输出了所有的内容呢？这里再给大家看看下面一个修改后的filterUser方法：


private static void filterUser(List<Student> students){
    students.removeIf(user -> user.getScore() < 60);
    students.forEach(student -> student.setStar(student.getStar()+1));
}

输出结果如下：

student5|60|1
student6|61|1
student7|62|1
student8|63|1
student9|64|1

啊，这回终于是我们想要的结果了。额，比较下和上一个filterUser方法的区别，在这两行代码：

students = students.stream().filter(student -> student.getScore() >= 60).collect(Collectors.toList());

students.removeIf(user -> user.getScore() < 60);

啊，再细想一下，难不成，哈哈，对的，我们对students进行了赋值操作，而赋给他的值如果是原对象倒是没有问题，但是如果你把students赋值了一个新new出来的对象，那么你再对filterUser方法中的students对象进行操作就无法影响到原来的main方法中的students了。

就相当于你给了朋友的这把复刻的钥匙，朋友是个高手，把他的钥匙修了一下之后用来开另一人的房间去了，这样就开不了你的房间了。而我们第一个方法中的Lamda表达式中的Collectors.toList()这句就是new出来了一个新的列表（即搞出来了一个新的房间）：


/**
 * Returns a {@code Collector} that accumulates the input elements into a
 * new {@code List}. There are no guarantees on the type, mutability,
 * serializability, or thread-safety of the {@code List} returned; if more
 * control over the returned {@code List} is required, use {@link #toCollection(Supplier)}.
 *
 * @param <T> the type of the input elements
 * @return a {@code Collector} which collects all the input elements into a
 * {@code List}, in encounter order
 */
public static <T>
Collector<T, ?, List<T>> toList() {
    return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
                               (left, right) -> { left.addAll(right); return left; },
                               CH_ID);
}

嗯，这样我么就知道了为什么最后输出还是会把student0~9都输出出来了。可是问题又来了，上面说的是给new了一个新的对象，那为什么student0~4的start是0，而student5~9的却变成了1了呢，这不是还是改变了对象中的值了吗，不是说钥匙现在只能开另一个房间了吗，怎么把原来房间的东西给变了。

嗯，其实这里还有一点原因就是students对应的是个列表，而列表里存的又是Student对象。我们打个比方就是，第一个房间里其实还有10把钥匙，用来开10个学生的房间，而第二个房间因为是拿第一个房间过滤改造出来的（这里可能是另一维度的世界了吧，哈哈），第二个房间只有5~9号房间的钥匙，用来开这5个学生的房间。而你朋友现在拿着这5把钥匙，开了对应学生的房间，分别放进去了一个小星星。那么，当你拿着这10把钥匙开这10个学生的房间时，自然会发现有5个学生的房间多了一颗小星星啦。

所以，为什么第一个filterUser方法输出的结果包含10个学生，且student0~4的start是0，而student5~9的却变成了1也就清楚啦。

我们只要记住，Java中的传参方式只有一种就是值传递就行了。更有甚者，其实我们只要弄清了Java中对象及对象引用的存储方式，至于它是值传递还是引用传递就没有这么重要了。不过，做面试题的时候还是挺重要的。

说了这么多，既然Java只有值传递，那么引用传递能不能给个例子嘞，那就亮一下支持引用传递的语言吧，这里拿C++举例：

#include <stdio.h>
void swap1(int* a,int* b);
void swap2(int& a,int& b);
void swap3(int* a,int* b);

void main(){
    printf("Hello World!\n");
    int a = 3;
    int b = 4;
    printf("bef swap, add of a = %d\n",&a);
    printf("aft swap, val of a = %d\n",a);
    //swap(a,b);
    //swap1(&a,&b);
    swap2(a,b);
    //swap3(&a,&b);
    
    printf("aft swap, add of a = %d\n",&a);
    printf("aft swap, val of a = %d\n",a);
}
// pass by value
void swap(int a,int b){
    int temp = a;
    a = b;
    b = temp;
}
// pass by address
void swap1(int* a,int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}
// pass by reference
void swap2(int& a,int& b){
    int temp = a;
    a = b;
    b = temp;
}
// pass by value ?
void swap3(int* a,int *b){
    int* temp = a;
    a = b;
    b = temp;
}

调用不同方法输出结果：