Java中只有传值调用（值传递），没有传址调用（址传递或者引用传递）。所以在java方法中改变参数的值是不会改变原变量的值的，但为什么改变引用变量的属性值却可以呢？请看下面的解答。

java中的数据类型

Java中数据类型分为两大类：基本类型和引用类型。相应的，变量也分这两种类型：基本类型和引用类型。

基本类型的变量保存原始值，即它代表的值就是数值本身；

而引用类型的变量保存的值是引用值，"引用值"指向内存空间的地址，代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。

基本类型包括：byte,short,int,long,char,float,double,Boolean,returnAddress。

引用类型包括：类、接口类型和数组。

java中只有值传递

在日常编码中，会经常看到如下现象：

1、对于基本类型参数，在方法体内对参数进行重新赋值，不会改变原有变量的值。

2、对于引用类型参数，在方法体内对参数进行重新赋予引用，不会改变原有变量所持有的引用。

3、方法体内对参数进行运算，不会改变原有变量的值。

4、对于引用类型参数，方法体内对参数所指向对象的属性进行操作，将改变原有变量所指向对象的属性值。

举个例子：

public class Main {

    private static void getMiddleOne(boolean b, Boolean boo, Boolean[] arr){

        b = true;

        boo = new Boolean(true);

        arr[0] = true;

    }

       //测试

    public static void main(String[] args) {

        boolean b = false;

        Boolean boo = new Boolean(false);

        Boolean[] arr = new Boolean[]{false};

        getMiddleOne(b, boo, arr);

        System.out.println(b);

        System.out.println(boo.toString());

        System.out.println(arr[0]);

        /**

        * output:

        * false

        * false

        * true

        */

    }

}

我们只要了解了下面两点就可以解答上面的现象了：

1、基本数据类型的值就是数值本身，所以示例中的b的值就是false；包装类因为会自动装箱拆箱，所以可以和基本类型一样处理，所以示例中boo的值就是false；数组是引用类型，所以arr的值就是指向该Boolean[]的引用。

2、java中只有值传递没有引用传递，所以传入getMiddleOne方法的三个参数分别是b的值拷贝, boo的值拷贝, arr的值拷贝。

通过上面两点就可以清楚了，getMiddleOne方法中执行的 b=true 和 boo = new Boolean(true) 都是把新值赋给了他们的拷贝，所以不改变原变量的值；同样，arr[0] = true 是把true复制给了arr的拷贝所指向的数组的第一个元素，arr的值和arr的拷贝的值都是该数组的引用，所以arr的拷贝所指向的数组和arr所指向的数组是同一个，所以改变arr的拷贝的数组的元素会同样影响到原变量arr。

总结

java中只有值传递，基本类型传递的是值的副本，引用类型传递的是引用的副本。

 

引用大佬的博客： Java：强引用，软引用，弱引用和虚引用
建议直接看大佬的博客，我这里只做总结。
总结
强引用 相当于 Object obj=new Object()这种引用就是强引用，即使OOM也不会被垃圾回收器进行回收

软引用 如果将要发生了OOM（内存不够用了）则会将对象自动回收

弱引用 只要发生了gc()就会进行回收虚引用的对象

虚引用 主要用来跟踪对象被垃圾回收的活动。虚引用必须和引用队列关联使用。
案例：
import java.lang.ref.*;

public class WeakReferenceDemo {

    public static void main(String[] args) {
        softReferenceTest();// 软引用
        weakReferenceTest();// 弱引用
    }

    /**
     * 软引用测试案例
     * 会发现gc后软引用还能获取"hello world!!!"，只有将要OOM的gc才会回收对象那么返回null
     */
    private static void softReferenceTest() {
        String helloWorldString = new String("hello world!!!"); // 在堆中根据常量字符串创建一个新的字符串对象
        SoftReference<String> stringSoftReference = new SoftReference<>(helloWorldString);
        System.out.println("打印一下软引用的字符串：" + stringSoftReference.get());//没有进行gc前软引用能得到对象
        /**
         * 置 null 的作用
         * 去除helloWorldString强引用字符串"hello world!!!"，
         * 因为对象一旦被强引用指向，即使内存不够,宁愿报错也不会被回收改对象，相当于"hello world!!!"原先由两个引用指向这个对象
         */
        helloWorldString = null;
        System.gc();//进行垃圾回收
        stringSoftReference.get();
        System.out.println("软引用的字符串被垃圾回收了，得到的字符串是：" + stringSoftReference.get());
    }

    /**
     * 弱引用测试案例
     * 会发现gc后，弱引用不能获取"hello world!!!"
     */
    private static void weakReferenceTest() {
        String helloWorldString = new String("hello world!!!"); // 在堆中根据常量字符串创建一个新的字符串对象
        WeakReference<String> stringWeakReference = new WeakReference<>(helloWorldString);// 创建一个弱引用，将弱引用指向堆中的那个字符串

        /**
         * 置 null 的作用
         * 去除helloWorldString强引用字符串"hello world!!!"，
         * 因为对象一旦被强引用指向，即使内存不够，宁愿报错也不会被回收改对象，相当于"hello world!!!"原先由两个引用指向这个对象
         */
        helloWorldString = null;
        System.out.println("打印一下弱引用的字符串：" + stringWeakReference.get());//没有进行gc前软引用能得到对象
        System.gc();//进行垃圾回收
        stringWeakReference.get();
        System.out.println("弱引用的字符串被垃圾回收了，得到的字符串是：" + stringWeakReference.get());
    }
}


再度总结
之所以要分成这四种引用，就是在gc的时候被引用的对象是否会被回收内存所分成的情况，以及考虑发生OOM的情况进行gc

强引用： 不用举例子，平时new引用的对象就是强引用

软引用： 可以通过SoftReference<Obj> sr = new SoftReference<Obj>(obj);进行引用，

弱引用： 通过WeakReference<String> sr = new WeakReference<String>(new String("hello"));这个例子使用new创建对象为了避免对象在常量池中。

虚引用： 主要用来跟踪对象被垃圾回收的活动（GCRoot中的引用链应该就是用这个做的，如果一个对象没有被引用GCRoot引用到，则说明这是一个内存垃圾，需要进行垃圾回收）

虚引用的使用例子：
ReferenceQueue<String> queue = new ReferenceQueue<String>();
PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);

强引用

强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfM moryError错误，使程序异常终止，也不会靠随意回收具有强引用 对象来解决内存不足的问题。


软引用

软引用是用来描述一些还有用但并非必须的对象。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。


 

/**
 * 软引用何时被收集
 * 运行参数 -Xmx200m -XX:+PrintGC
 * Created by ccr at 2018/7/14.
 */
public class SoftReferenceDemo {

    public static void main(String[] args) throws InterruptedException {
        //100M的缓存数据
        byte[] cacheData = new byte[100 * 1024 * 1024];
        //将缓存数据用软引用持有
        SoftReference<byte[]> cacheRef = new SoftReference<>(cacheData);
        //将缓存数据的强引用去除
        cacheData = null;
        System.out.println("第一次GC前" + cacheData);
        System.out.println("第一次GC前" + cacheRef.get());
        //进行一次GC后查看对象的回收情况
        System.gc();
        //等待GC
        Thread.sleep(500);
        System.out.println("第一次GC后" + cacheData);
        System.out.println("第一次GC后" + cacheRef.get());

        //在分配一个120M的对象，看看缓存对象的回收情况
        byte[] newData = new byte[120 * 1024 * 1024];
        System.out.println("分配后" + cacheData);
        System.out.println("分配后" + cacheRef.get());
    }

}

第一次GC前null
第一次GC前[B@7d4991ad
[GC (System.gc())  105728K->103248K(175104K), 0.0009623 secs]
[Full GC (System.gc())  103248K->103139K(175104K), 0.0049909 secs]
第一次GC后null
第一次GC后[B@7d4991ad
[GC (Allocation Failure)  103805K->103171K(175104K), 0.0027889 secs]
[GC (Allocation Failure)  103171K->103171K(175104K), 0.0016018 secs]
[Full GC (Allocation Failure)  103171K->103136K(175104K), 0.0089988 secs]
[GC (Allocation Failure)  103136K->103136K(199680K), 0.0009408 secs]
[Full GC (Allocation Failure)  103136K->719K(128512K), 0.0082685 secs]
分配后null
分配后null



从上面的示例中就能看出，软引用关联的对象不会被GC回收。JVM在分配空间时，若果Heap空间不足，就会进行相应的GC，但是这次GC并不会收集软引用关联的对象，但是在JVM发现就算进行了一次回收后还是不足（Allocation Failure），JVM会尝试第二次GC，回收软引用关联的对象。



像这种如果内存充足，GC时就保留，内存不够，GC再来收集的功能很适合用在缓存的引用场景中。在使用缓存时有一个原则，如果缓存中有就从缓存获取，如果没有就从数据库中获取，缓存的存在是为了加快计算速度，如果因为缓存导致了内存不足进而整个程序崩溃，那就得不偿失了。


弱引用

弱引用也是用来描述非必须对象的，他的强度比软引用更弱一些，被弱引用关联的对象，在垃圾回收时，如果这个对象只被弱引用关联（没有任何强引用关联他），那么这个对象就会被回收。


 

/**
 * 弱引用关联对象何时被回收
 * Created by ccr at 2018/7/14.
 */
public class WeakReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        //100M的缓存数据
        byte[] cacheData = new byte[100 * 1024 * 1024];
        //将缓存数据用软引用持有
        WeakReference<byte[]> cacheRef = new WeakReference<>(cacheData);
        System.out.println("第一次GC前" + cacheData);
        System.out.println("第一次GC前" + cacheRef.get());
        //进行一次GC后查看对象的回收情况
        System.gc();
        //等待GC
        Thread.sleep(500);
        System.out.println("第一次GC后" + cacheData);
        System.out.println("第一次GC后" + cacheRef.get());

        //将缓存数据的强引用去除
        cacheData = null;
        System.gc();
        //等待GC
        Thread.sleep(500);
        System.out.println("第二次GC后" + cacheData);
        System.out.println("第二次GC后" + cacheRef.get());
    }
}
第一次GC前[B@7d4991ad
第一次GC前[B@7d4991ad
第一次GC后[B@7d4991ad
第一次GC后[B@7d4991ad
第二次GC后null
第二次GC后null



从上面的代码中可以看出，弱引用关联的对象是否回收取决于这个对象有没有其他强引用指向它。这个确实很难理解，既然弱引用关联对象的存活周期和强引用差不多，那直接用强引用好了，干嘛费用弄出个弱引用呢？其实弱引用存在必然有他的应用场景。


 

static Map<Object,Object> container = new HashMap<>();
public static void putToContainer(Object key,Object value){
    container.put(key,value);
}

public static void main(String[] args) {
    //某个类中有这样一段代码
    Object key = new Object();
    Object value = new Object();
    putToContainer(key,value);

    //..........
    /**
     * 若干调用层次后程序员发现这个key指向的对象没有用了，
     * 为了节省内存打算把这个对象抛弃，然而下面这个方式真的能把对象回收掉吗？
     * 由于container对象中包含了这个对象的引用,所以这个对象不能按照程序员的意向进行回收.
     * 并且由于在程序中的任何部分没有再出现这个键，所以，这个键 / 值 对无法从映射中删除。
     * 很可能会造成内存泄漏。
     */
    key = null;
}


下面一段话摘自《Java核心技术卷1》：


设计 WeakHashMap类是为了解决一个有趣的问题。如果有一个值，对应的键已经不再 使用了， 将会出现什么情况呢？ 假定对某个键的最后一次引用已经消亡，不再有任何途径引 用这个值的对象了。但是，由于在程序中的任何部分没有再出现这个键，所以，这个键 / 值 对无法从映射中删除。为什么垃圾回收器不能够删除它呢？ 难道删除无用的对象不是垃圾回 收器的工作吗？



遗憾的是，事情没有这样简单。垃圾回收器跟踪活动的对象。只要映射对象是活动的， 其中的所有桶也是活动的， 它们不能被回收。因此，需要由程序负责从长期存活的映射表中 删除那些无用的值。 或者使用 WeakHashMap完成这件事情。当对键的唯一引用来自散列条

目时， 这一数据结构将与垃圾回收器协同工作一起删除键 / 值对。



下面是这种机制的内部运行情况。WeakHashMap 使用弱引用（weak references) 保存键。 WeakReference 对象将引用保存到另外一个对象中，在这里，就是散列键。对于这种类型的 对象，垃圾回收器用一种特有的方式进行处理。通常，如果垃圾回收器发现某个特定的对象 已经没有他人引用了，就将其回收。然而， 如果某个对象只能由 WeakReference 引用， 垃圾 回收器仍然回收它，但要将引用这个对象的弱引用放人队列中。WeakHashMap将周期性地检 查队列， 以便找出新添加的弱引用。一个弱引用进人队列意味着这个键不再被他人使用， 并 且已经被收集起来。于是， WeakHashMap将删除对应的条目。


除了WeakHashMap使用了弱引用，ThreadLocal类中也是用了弱引用。

虚引用

一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获取一个对象的实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。虚引用和弱引用对关联对象的回收都不会产生影响，如果只有虚引用活着弱引用关联着对象，那么这个对象就会被回收。它们的不同之处在于弱引用的get方法，虚引用的get方法始终返回null,弱引用可以使用ReferenceQueue,虚引用必须配合ReferenceQueue使用。



jdk中直接内存的回收就用到虚引用，由于jvm自动内存管理的范围是堆内存，而直接内存是在堆内存之外（其实是内存映射文件，自行去理解虚拟内存空间的相关概念），所以直接内存的分配和回收都是有Unsafe类去操作，java在申请一块直接内存之后，会在堆内存分配一个对象保存这个堆外内存的引用，这个对象被垃圾收集器管理，一旦这个对象被回收，相应的用户线程会收到通知并对直接内存进行清理工作。


 

Java引用数据类型（String）
引用数据类型概述
引用数据类型与基本数据类型的差别（举例说明）

引用数据类型概述
说到引用数据类型，那么何为引用数据类型？

引用类型，都可以用null值作为值，也就是说可以在初始化的时候赋值为null，String是引用类型，也就是说可以使用null作为值。


引用数据类型与基本数据类型的差别（举例说明）
使用基本数据类型：

int i1 = 1

int i2 = 1

这种是会在内存中存储两个1的值
但是，使用引用类型就不会！

String s  = “hello”

String s1 = “hello”

这种，是不会在内存中存在两个"hello"的，只存在一个"hello"。
假设"hello"的内存地址为xxxxxx,声明s变量时给s赋值"hello"实际上让s变量引用"hello"的内存地址xxxxxx;
当我们再次声明变量s1也赋值为"hello"的时候实际上也是直接把已经存在的"hello"的内存地址给了s1引用
此乃引用类型和基本数据类型的区别。
记录自己最近学习到的东西，做一个总结，希望大家喜欢，一起加油！