Java的传值分为值传递和引用传递,其中有一个特殊情况,就是String传递(属于引用传递)。接下来我们就聊一下这三种传递方式。
其实java中并不存在引用调用,这点是没错的,因为java程序设计语言的确是采用了按值调用,即call by value。也就是说方法得到的所有参数值是一个拷贝,方法并不能修改传递给它的任何参数变量的内容。
(有力证据!)官方文档:
中文翻译:
我们要注意的是一个方法可以修改传递引用所对应的变量值,而不能修改值传递调用所对应的变量值,这句话相当重要,这是按值调用和引用调用的根本区别!
1、值调用
概念:按值调用表示方法接收的是调用者提供的值。
代码实例:
package com.zejian.test;
/**
* java中的按值调用
* @author zejian
*/
public class CallByValue {
private static int x=10;
public static void updateValue(int value){
value = 3 * value;
}
public static void main(String[] args) {
System.out.println("调用前x的值:"+x);
updateValue(x);
System.out.println("调用后x的值:"+x);
}
}
运行结果:
调用前x的值:10
调用后x的值:10
可以看到x的值并没有变化,接下来我们一起来看一下具体的执行过程:
分析:
1)value被初始化为x值的一个拷贝(也就是10)
2)value被乘以3后等于30,但注意此时x的值仍为10!
3)这个方法结束后,参数变量value不再使用,被回收。
内存结构:
结论:
当传递方法参数类型为基本类型(数字以及布尔值)时。一个方法是不可能修改一个基本数据类型的参数。即方法操作的是参数变量(也就是原型变量的一个值的拷贝)改变的也只是原型变量的拷贝而已。
2、引用调用
概念:引用调用则表示方法接收的是调用者提供的变量地址(如果是C语言的话就是指针,java就是地址)。
代码实例:
声明一个User对象类型:
package com.zejian.test;
public class User {
private String name;
private int age;
public User(String name, int age) {
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
执行类如下:
package com.zejian.test;
/**
* java中的按值调用
* @author zejian
*/
public class CallByValue {
private static User user=null;
public static void updateUser(User student){
student.setName("Lishen");
student.setAge(18);
}
public static void main(String[] args) {
user = new User("zhangsan",26);
System.out.println("调用前user的值:"+user.toString());
updateUser(user);
System.out.println("调用后user的值:"+user.toString());
}
}
运行结果如下:
调用前user的值:User [name=zhangsan, age=26]
调用后user的值:User [name=Lishen, age=18]
很显然,User的值被改变了,也就是说方法参数类型如果是引用类型的话,引用类型对应的值将会被修改,下面我们来分析一下这个过程:
过程分析:
1)student变量被初始化为user值的拷贝,这里是一个对象的引用。
2)调用student变量的set方法作用在这个引用对象上,user和student同时引用的User对象内部值被修改。
3)方法结束后,student变量不再使用,被释放,而user还是没有变,依然指向User对象。
内存结构:
结论:当传递方法参数类型为引用数据类型时,一个方法将修改一个引用出数据类型的参数所指向对象的值。
虽然到这里两个数据类型的传递都分析完了,也明白的基本数据类型的传递和引用数据类型的传递区别,前者将不会修改原数据的值,而后者将会修改引用所指向对象的值。可通过上面的实例我们可能就会觉得java同时拥有按值调用和按引用调用啊,可惜的是这样的理解是有误导性的,虽然上面引用传递表面上体现了按引用调用现象,但是java中确实只有按值调用而没有按引用调用。 到这里估计不少人都蒙逼了,下面我们通过一个反例来说明(回忆一下开头我们所说明的按值调用与按引用调用的根本区别)。
package com.zejian.test;
/**
* java中的按值调用
* @author zejian
*/
public class CallByValue {
private static User user=null;
private static User stu=null;
/**
* 交换两个对象
* @param x
* @param y
*/
public static void swap(User x,User y){
User temp =x;
x=y;
y=temp;
}
public static void main(String[] args) {
user = new User("user",26);
stu = new User("stu",18);
System.out.println("调用前user的值:"+user.toString());
System.out.println("调用前stu的值:"+stu.toString());
swap(user,stu);
System.out.println("调用后user的值:"+user.toString());
System.out.println("调用后stu的值:"+stu.toString());
}
}
我们通过一个swap函数来交换两个变量user和stu的值,在前面我们说过,如果是按引用调用那么一个方法可以修改传递引用所对应的变量值,也就是说如果java是按引用调用的话,那么swap方法将能够实现数据的交换,而实际运行结果是:
调用前user的值:User [name=user, age=26]
调用前stu的值:User [name=stu, age=18]
调用后user的值:User [name=user, age=26]
调用后stu的值:User [name=stu, age=18]
我们发现user和stu的值并没有发生变化,也就是方法并没有改变存储在变量user和stu中的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝,这个方法交换的是这两个拷贝的值而已,最终,所做的事都是白费力气罢了。在方法结束后x,y将被丢弃,而原来的变量user和stu仍然引用这个方法调用之前所引用的对象。
这个过程也充分说明了java程序设计语言对对象采用的不是引用调用,实际上是对象引用进行的是值传递,当然在这里我们可以简单理解为这就是按值调用和引用调用的区别,而且必须明白即使java函数在传递引用数据类型时,也只是拷贝了引用的值罢了,之所以能修改引用数据是因为它们同时指向了一个对象,但这仍然是按值调用而不是引用调用。
3、String调用
首先先说一下String类型的几种创建方式:
参考文章:http://t.csdn.cn/MHGBX
参考文章:这个文章写了string对象内存(很详细)https://www.cnblogs.com/kmchen/p/14975673.html
(1)
String str1 = "Tulun";
String str2 = "Tulun";
System.out.println(str1 == str2);//true
直接赋值创建对象的过程
1 首先在常量池中查找是否存在内容为"abc"字符串对象
2 如果不存在则会在堆内存中创建字符串,然后到字符串常量池中注册该字符串
3 如果存在则直接让str引用该对象
(2)
String str3 = new String("Tulun");
String str4 = new String("Tulun");
System.out.println(str3 == str4);//false
new 创建对象的过程
1 首先在堆中(不是常量池)创建一个指定的对象,并让str引用指向该对象。
2 在字符串常量池中查看,是否存在内容为"abc"字符串对象
3 若存在,则将new出来的字符串对象与字符串常量池中的对象联系起来(即让那个特殊的成员变量value的指针指向它)
4 若不存在,则在字符串常量池中创建一个内容为"abc"的字符串对象,并将堆中的对象与之联系起来。(有可能此时常量池中的"abc"已经被回收,所以要先创建一个内容 为"abc"的字符串对象)
(3)
String str5 = new String("Tulun");
String str6 = "Tulun";
System.out.println(str5 == str6);//false
(4)
String str7 = new String("Tulun");
String str8 = "Tu"+"lun";//Tulun 常量池
System.out.println(str7 == str8)//false
(5)
char[] array = {'t','u','l','u','n'};
String str11 = "tulun";
String str12 = new String(array);
System.out.println(str11 == str12);//false
String的equal()方法
1.先比较引用的地址是否一样,若相等则直接返回true.
2.再比较类型是否一样 。
a.比较长度。
1).依次比较数值是否相等,依次比较每一个字符,全部相等则为true,否则为false。
接下来进入正题
参考文章:http://t.csdn.cn/mKbqd
@Test
public void stringTest(){
String a = "a";
stringUpdate(a);
System.out.println("调用方法修改后的字符串值:" + a);
}
public void stringUpdate(String a){
a = "b";
System.out.println("被调用方法修改后的字符串值:" + a);
}
结果:
被调用方法修改后的字符串值:b
调用方法修改后的字符串值:a
主要是由于string内部保存值方式的原因string是通过一个final char[]数组进行保存的,由于final类型的数组值不能够改变,所以在外部调用函数时将string地址的引用进行传递给函数的参数,函数的内部再修改这个引用时,由于final char[] 不可以修改,所以在给变量赋新的值时都会重新创建一个string实例这个新创建的string实例所指向的地址和外部string变量所指向的地址是不同的所以改变不了外部的变量)。另外一个点说明因为final String 对象是不可变的,所以可以共享 也就是说 String op=“abc” 和 String op1=“abc” 指向的是同一个引用对象(字符串是常量;它们的值在创建之后不能更改—jdk Api)
如图所示最终外部变量A指向的地址和方法B中A指向的地址不同
今天公司漂亮的小姐姐同事说StringBuffer和StringBuilder 类型传参是不会创建新string的,直接上代码!
@Test
public void a(){
StringBuffer sbf = new StringBuffer("a");
System.out.println("StringBuffer修改前:" + sbf);
stringBufferTest(sbf);
System.out.println("StringBuffer修改后调用方法:" + sbf);
StringBuilder sbd = new StringBuilder("a");
System.out.println("StringBuilder修改前:" + sbd);
stringBuilderTest(sbd);
System.out.println("StringBuilder修改后调用方法:" + sbd);
}
public void stringBufferTest(StringBuffer sbf){
sbf.append("b");
System.out.println("StringBuffer修改后被调用方法:" + sbf);
}
public void stringBuilderTest(StringBuilder sbd){
sbd.append("b");
System.out.println("StringBuilder修改后被调用方法:" + sbd);
}
结果:
StringBuffer修改前:a
StringBuffer修改后被调用方法:ab
StringBuffer修改后调用方法:ab
StringBuilder修改前:a
StringBuilder修改后被调用方法:ab
StringBuilder修改后调用方法:ab
参考文章:1、http://t.csdn.cn/puT0t
参考文章:2、http://t.csdn.cn/yXrB2
我们来看一下StringBuild的底层实现:
Stringbuilder和Stringbuffer 继承自同一个顶层类AbstractStringBuilder,所以成员变量不是finall修饰的。
无参数的构造方法,初始长度是16。
扩容后新数组长度=旧数组的长度*2+2。
通过StringBuilder和StringBuffer继承自同一个父类这点, 我们可以推断出它俩的方法都是差不多的. 通过查看源码也发现确实如此, 只不过StringBuffer在方法上添加了 synchronized关键字, 证明它的方法绝大多数方法都是线程同步方法. 也就是说在多线程的环境下我们应该使用StringBuffer以保证线程安全, 在单线程环境下我们应使用StringBuilder以获得更高的效率。
通过查看StringBuilder和String的源码我们会发现两者之间一个关键的区别: 对于String, 凡是涉及到返回参数类型为String类型的方法, 在返回的时候都会通过new关键字创建一个新的字符串对象; 而对于StringBuilder, 大多数方法都会返回StringBuilder对象自身。
综上所述,stringBuild是一个可以改变的字符串,并且调用append等方法(改变字符串时)返回的是本身。所以stringBuild是一个和对象性质一样的引用调用。