引用 订阅
引用是指在说话或写作中引用现成的话,如诗句、格言、成语等,以表达自己思想感情的修辞方法。引用可分为明引和暗引两种。明引指直接引用原文,并加上引号,或者是只引用原文大意,不加引号,但是都注明原文的出处。暗引指不说明引文出处,而将其编织在自已的话语中,或是引用原句,或是只引大意。运用引用辞格,既可使文章言简意赅,有助于说理抒情;又可增加文采,增强表现力。 [1] 展开全文
引用是指在说话或写作中引用现成的话,如诗句、格言、成语等,以表达自己思想感情的修辞方法。引用可分为明引和暗引两种。明引指直接引用原文,并加上引号,或者是只引用原文大意,不加引号,但是都注明原文的出处。暗引指不说明引文出处,而将其编织在自已的话语中,或是引用原句,或是只引大意。运用引用辞格,既可使文章言简意赅,有助于说理抒情;又可增加文采,增强表现力。 [1]
信息
拼    音
yǐn yòng
作    用
增添感染力,增加文采
中文名
引用
外文名
quote
引用基本解释
引用天下名士。 [2] 
收起全文
精华内容
下载资源
问答
  • java中的参数传递(只有值传递没有引用传递)

    万次阅读 多人点赞 2019-07-31 19:25:14
    Java中只有传值调用(值传递),没有传址调用(址传递或者引用传递)。所以在java方法中改变参数的值是不会改变原变量的值的,但为什么改变引用变量的属性值却可以呢?请看下面的解答。 java中的数据类型 Java中...

    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也不会被垃圾回收器进行回收 软引用 如果...

    引用大佬的博客: 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错误,使程序异常终止,也不会靠随意回收具有强引用 对象来解决内存不足...
    • 强引用

    强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾收器绝不会回收它。当内存空间不足,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详解

    万次阅读 2020-07-02 23:54:44
    Java引用数据类型(String)引用数据类型概述引用数据类型与基本数据类型的差别(举例说明) 引用数据类型概述 说到引用数据类型,那么何为引用数据类型? 引用类型,都可以用null值作为值,也就是说可以在初始化的...

    引用数据类型概述

    说到引用数据类型,那么何为引用数据类型?
    引用类型,都可以用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引用

    此乃引用类型和基本数据类型的区别。

    记录自己最近学习到的东西,做一个总结,希望大家喜欢,一起加油!

    展开全文
  • 吃人的那些 Java 名词:对象、引用、堆、栈

    万次阅读 多人点赞 2019-09-05 15:57:09
    作为一个有着 8 年 Java 编程经验的 IT 老兵,说起来很惭愧,我被 Java 当中的四五个名词一直困扰着:**对象、引用、堆、栈、堆栈**(栈可同堆栈,因此是四个名词,也是五个名词)。每次我看到这几个名词,都隐隐...
  • Java基础篇 - 强引用、弱引用、软引用和虚引用

    万次阅读 多人点赞 2018-09-09 08:58:21
    引用计数:Java堆中每一个对象都有一个引用计数属性,引用每新增1次计数加1,引用每释放1次计数减1。 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象...
  • Java:强引用,软引用,弱引用和虚引用

    万次阅读 多人点赞 2019-01-02 16:56:19
    一、强引用 二、软引用 三、弱引用 四、虚引用 五、总结 在JDK1.2以前的版本中,当一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及状态,程序才能使用它。这就像在商店...
  • C++11 右值引用&&

    万次阅读 多人点赞 2017-11-13 14:43:33
    右值引用 (Rvalue Referene) 是 C++ 新标准 (C++11, 11 代表 2011 年 ) 中引入的新特性 , 它实现了转移语义 (Move Sementics) 和精确传递 (Perfect Forwarding)。它的主要目的有两个方面: 1. 消除两个对象交互时...
  • JAVA 四中引用类型

    万次阅读 2019-07-09 12:22:12
    常见的java引用有四种:强引用、软引用、弱引用、虚引用; 下面分别来介绍一下各种引用: 1、强引用 在Java 中最常见的就是强引用,把一个对象赋给一个引用变量,这个引用变量就是一个强引用。当一个对象被强引用...
  • 用了Java怎么长时间一直不知道原来Java还有四种引用类型,这个引用类型和我们平常说的可不一样。这里的引用类型不是指数据类型的一种,而是指Java中的引用所分的四种类型。强引用: Java中的引用,有点像C++的指针。...
  • 引用,软引用,弱引用

    千次阅读 2019-06-26 13:48:27
    一、软引用和弱引用的用法 软引用(SoftReference)的含义是,如果一个对象只具有软引用,而当前虚拟机堆内存空间足够,那么垃圾回收器就不会回收它,反之就会回收这些软引用指向的对象。 弱引用(WeakReference)...
  • 引用、软引用、弱引用、虚引用

    万次阅读 2016-07-02 10:34:22
    强引、软引用、弱引用、虚引用
  • 引用,软引用,弱引用,虚引用

    千次阅读 2015-04-21 14:44:38
    引用,软引用,弱引用,虚引用 强引用: 我们一般使用的就是强引用。垃圾回收器绝不会回收它。 当内存空间不足时Java虚拟机宁愿抛出OutOfMemoryError错误使程序异常终止,也不会回收具有强引用的对象来解决内存不足...
  • 这四种级别由高到低依次为:强引用、软引用、弱引用和虚引用。 1、强引用(Strong Reference) 强引用就是我们经常使用的引用,其写法如下: Object&nbsp;o&nbsp;=&nbsp;new&nbsp;Object(); 只要...
  • 引用、const引用和非const引用

    千次阅读 2018-02-18 17:22:01
    引用 引用构造了对象的一个同义词,是C++对象的另一个名字。在实际程序中,引用的主要作用是作函数的形参。 什么是引用 引用是一种复合类型1,它通过在变量名前添加“&amp;”来定义。在使用引用的情况下,...
  • layui在线引用地址

    万次阅读 2018-08-29 16:17:57
    2.4.3版本layui在线引用地址(永久有效) layui.js:https://heerey525.github.io/layui-v2.4.3/layui/layui.js layui.css:https://heerey525.github.io/layui-v2.4.3/layui/css/layui.css 2.4.4版本layui在线...
  • 一、概述: 众所周知,Java中是JVM负责内存的分配和回收,这是它的优点(使用方便,程序不用再像使用c那样操心内存),但同时也是...在JDK1.2以前的版本中,当一个对象不被任何变量引用,那么程序就无法再使用这个...
  • C/C++ 引用作为函数的返回值

    万次阅读 多人点赞 2018-08-04 13:19:48
    1.引用作为函数的返回值时,必须在定义函数时在函数名前将&amp; 2.用引用作函数的返回值的最大的好处是在内存中不产生返回值的副本 //代码来源:RUNOOB #include&lt;iostream&gt; using namespace ...
  • 背景:收到公众投稿,《从面试题中看Java的Reference(引用)》,分析的很不错,总感觉少了实际的例子和应用场景。于是结合自己工作中场景,小总结一下。看下Agenda如下: 1、强引用 2、软引用 3、弱引用 4、什么时候...
  • java引用

    千次阅读 2020-05-07 10:50:02
    引用: String str = “abc”; list.add(str); 软引用: 如果弱引用对象回收完之后,内存还是报警,继续回收软引用对象 SoftReference<A> sr = new SoftReference<A>(a); 弱引用: ...
  • 早在JDK1.2就把对象引用分为四种级别,从而使程序能更灵活控制它的生命周期,级别由高到底依次为:强 >软 > 弱 > 虚引用。而GC垃圾回收器(Garbage Collection)对不同的类型有着不同的处理方法,了解这些...
  • java内存管理分为内存分配和内存回收,都不需要程序员负责,垃圾回收的机制主要是看对象是否有引用指向该对象。 java对象的四种引用 包括: 强引用,软引用,弱引用,虚引用   Java中提供这四种引用类型主要有两个...
  • 在周志明前辈的《深入理解Java虚拟机(第二版)》3.2.3节:再谈引用 中,介绍了Java中的几种引用: 在JDK 1.2以前,Java中的引用的定义很传统:如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址...
  • Java中值传递和引用传递的理解

    万次阅读 多人点赞 2018-05-09 11:21:58
    一、基本类型和引用类型的理解Java中的数据类型分为两种为基本类型和引用类型。1、基本类型的变量保存原始值,所以变量就是数据本身。常见的基本类型:byte,short,int,long,char,float,double,Boolean,returnAddress...
  • JVM符号引用与直接引用

    千次阅读 2020-03-27 20:11:38
    符号引用: 符号引用是以一组符号来描述所引用的目标,符号中的字面量可以是任何形式的,只要可以无歧义的定位到目标即可。符号引用与虚拟机实现的内存布局是无关的。各个不同的虚拟机实现的内存布局可以是不一样的...
  • Java虽然有内存管理机制,但仍应该警惕内存泄露的问题。例如对象池、缓存中的过期对象都有...这几种引用级别由高到低分别为:强引用、软引用、弱引用和虚引用。 强引用:平时我们编程的时候例如:Object object=new
  • Java 7之基础 - 强引用、弱引用、软引用、虚引用

    万次阅读 多人点赞 2014-02-23 10:36:21
    1、强引用(StrongReference) 强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强...
  • 对于刚接触不久面向对象的真小白童鞋来说,类的对象,对象的实例,对象的引用引用变量的问题以及莫过于没得对象虽然博主也没得对象,本文将逐个逐个讲解! 1.何谓对象? 在Java中有一句比较流行的话,叫做“万物皆...
  • 引用、弱引用和虚引用处理

    千次阅读 2017-12-27 00:18:19
    从而认识了弱引用、软引用、虚引用。今天发现Kotlin 在Android 上Anko库里的async, uiThread 里面居然做了在异步执行过程中Activity销毁了uiThread则不会调用,防止内存泄漏。正是采用了弱引用,先温习一下。Java中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 678,388
精华内容 271,355
关键字:

引用