Java基本数据类型与引用类型参数传递及String、StringBuild、StringBuffer类型作为形参传递

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);
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果：

调用前x的值：10

调用后x的值：10
1
2
3

可以看到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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

执行类如下：

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());
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果如下：

调用前user的值：User [name=zhangsan, age=26]

调用后user的值：User [name=Lishen, age=18]
1
2
3

很显然，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());
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

我们通过一个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]
1
2
3
4
5
6
7

我们发现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
2
3
4
5

直接赋值创建对象的过程

      1 首先在常量池中查找是否存在内容为"abc"字符串对象

      2 如果不存在则会在堆内存中创建字符串，然后到字符串常量池中注册该字符串

      3 如果存在则直接让str引用该对象
1
2
3
4
5

（2）

String str3 = new String("Tulun");

String str4 = new String("Tulun");

System.out.println(str3 == str4);//false
1
2
3
4
5

new 创建对象的过程

     1 首先在堆中（不是常量池）创建一个指定的对象，并让str引用指向该对象。

     2 在字符串常量池中查看，是否存在内容为"abc"字符串对象

     3 若存在，则将new出来的字符串对象与字符串常量池中的对象联系起来（即让那个特殊的成员变量value的指针指向它）

     4 若不存在，则在字符串常量池中创建一个内容为"abc"的字符串对象，并将堆中的对象与之联系起来。（有可能此时常量池中的"abc"已经被回收，所以要先创建一个内容       为"abc"的字符串对象）
1
2
3
4
5
6
7

（3）

String str5 = new String("Tulun");

String str6 = "Tulun";

System.out.println(str5 == str6);//false
1
2
3
4
5

（4）

String str7 = new String("Tulun");

String str8 = "Tu"+"lun";//Tulun  常量池

System.out.println(str7 == str8)//false
1
2
3
4
5

（5）

char[] array = {'t','u','l','u','n'};

String str11 = "tulun";

String str12 = new String(array);

System.out.println(str11 == str12);//false
1
2
3
4
5
6
7

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);
    }
1
2
3
4
5
6
7
8
9
10
11

结果：

被调用方法修改后的字符串值:b
调用方法修改后的字符串值:a
1
2

主要是由于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);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

结果：

StringBuffer修改前：a
StringBuffer修改后被调用方法：ab
StringBuffer修改后调用方法：ab
StringBuilder修改前：a
StringBuilder修改后被调用方法：ab
StringBuilder修改后调用方法：ab
1
2
3
4
5
6

参考文章：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是一个和对象性质一样的引用调用。