JAVA中的值传递与引用传递

   java中到底是值传递还是引用传递，这个问题争论过无数次了。现在剖析一下java中传值的过程中到底是什么操作

首先说一下结论
1：基本数据类型传递的是字面量值的拷贝
2：引用数据类型传递的是对象所在堆地址的拷贝
我们都知道java中，数据类型分为基本数据类型与引用数据类型两种。基本数据类型的值会随它的引用存放在栈空间当中，而引用数据类型的值会存放在堆空间当中。看一个最基础的代码：

        int i = 1; //这代表创建一个名为i的变量，它的值为1

首先，先重新认识一下 = 号，这与我们平时最熟悉的数学中的 = 号的意义有些不同，在java中 = 号是一个运算符，赋值运算符。它跟 + - * /这种不是一种量级的运算符。 =号可以改变内存状态，而+ - * /则不可以。
赋值运算符通常的效果有两种：

1. 放弃原有的值或者引用
2. 赋予新的值或引用

看一下编译器在执行 int i = 1这串代码的时候，内存区到底发生了什么？
首先int i 代表着在栈空间开辟出一块内存，把 i 这个引用放入新开辟的空间，同时因为是基本数据类型的关系，所以1这个值会直接跟i这个引用放到一起。这时，引用跟值都在栈空间里面。

再看一下下面的代码

            String a = "A";

流程为：

1. 在栈空间内开辟内存，将a这个引用放入。
2. 在字符串常量池中，搜索有没有 “A”这个字符串，如果有的话，将a指向搜索到的字符串，如果没有找到，那么会在字符串常量池中创建一个“A”字符串，并且将a指向“A”。

在int i = 1 与String a = “A” 的操作中，等号的角色就是进行了一次赋值操作，将右边的值赋给左边的引用。
我们知道了等号的作用之后，再来看这个代码块

            int i = 1;
            i=2;

第一行代表了给变量i赋值为1，那么第二行则代表给变量i赋值为2，但是i变量之前的值到哪里去了？是被覆盖了呢？还是成为内存区中的垃圾？
答案是：被覆盖掉了，因为我们都知道基本数据类型的值是存在于栈空间的，栈空间中不会新开辟一片区域给i变量赋值，会直接将旧值抹除让新值覆盖掉。
那么这样呢？

            int i = 1;
            int k = i;
            k = 2;

答案是什么？

答案是： i = 1 ，k = 2。我们考虑一下内存分配的过程就知道了，首先内存区开辟 i 空间，并且把1赋予i。第二步则是在内存中开辟 k 空间，并且将 i 的值的拷贝，赋予给了k。此时 i的值跟k的值并无关联，所以之后k=2的操作影响不到变量 i 。

看完了基本数据类型之后，来看引用数据类型的内存操作。

            String a = "A";
            String b = a;
            b += " is a";
            /**
                结论为: a = "A",
            */

第一步，栈空间开辟出变量a的区域，并且在常量池搜索”A”字符串，发现没找到，然后创建了”A”。
第二步，栈空间开辟出变量b的区域，并且将变量a的引用的拷贝赋予变量b，此时a，b都指向同一个区域”A”。
第三步，b = b + ” is a”，无非就是一次赋值操作，将等号右边的值赋予等号左边的引用，那么来看一下b + ” is a” 实际上就是字符串”A is a”，这个操作实际会在字符串常量池搜索”A is a”这个字符串，如果没找到则会创建一个，然后将这个字符串赋予b，此时旧字符串 “A”依然存在字符串常量池中，引用a依旧指向”A”。但是引用b却指向了新创建的字符串”A is a”，与字符串”A”并无关系了。
过程如下图：
String a = “A”;
String b = a;

b += “is a”;

再来看一段代码：

            List<Integer> list = new ArrayList<Integer>();
            for(int i = 0;i<10;i++)
                list.add(i);
            List<Integer> listTwo = list;
            listTwo.add(100);
            /**
            请问现在的list里面都有那些元素？
            */

答案是：除了0-9以外，还有100。
过程显而易见，标准的引用数据类型赋值，listTwo = list 的时候，此时会将list这个引用的拷贝赋予listTwo，所以两个引用指向同一个对象，此时，listTwo.add(100)，就改变了内存中的那个两者共享的对象，所以此时list的值也会变。因为list与listTwo本就指向同一个对象。

下面来看一个例子：

public class TestMain {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        add(list);
        for (Integer j : list) {
            System.err.print(j+",");
        }
        System.err.println("");
        System.err.println("*********************");
        String a="A";
        append(a);
        System.err.println(a);
        int num = 5;
        addNum(num);
        System.err.println(num);
    }

    static void add(List<Integer> l){
        l.add(100);
    }

    static void append(String str){
        str+="is a";
    }
    static void addNum(int n){
        n=n+10;
    }
}
/**
输出结果为：
0,1,2,3,4,5,6,7,8,9,100,
*********************
A
5
*/

按照上面的理论来推理一下真实的过程是什么

        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < 10; i++)
            list.add(i);
        List<Integer> l = list;
        l.add(100);
        for (Integer j : list)
            System.err.print(j+",");
        System.err.println("");
        System.err.println("*********************");
        String a = "A";
        String str = a;
        str += "is a";
        System.err.println(a);
        int num = 5;
        int n = num;
        n = n+10;
        System.err.println(num);

我们可以看到，其实参数传递的过程就是一次赋值过程，方法签名内的参数是形参，真实放入的参数为实参，调用方法放入参数的过程实际就是一次赋值操作，就是将实参赋予形参，具体的传递过程要视数据类型而定。
上述例子最终结果：
0,1,2,3,4,5,6,7,8,9,100,
***********
A
5

初次写如此长篇的博客，如有错误之处，欢迎斧正，万分感谢。