精华内容
下载资源
问答
  • 引用参考文献例子

    千次阅读 2017-12-25 18:11:28
    出版地:出版者,出版年(更新或修改日期)[引用日期].获取和访问路径  例:[10]杨家军.开放式研究性教学模式的研究与实践[EB/OL].北京:中国教育和科研计算机网, 2009[ 2009-12-8]. 开放式研究性教学模式的研究与...
    作者:毛编辑
    链接:https://www.zhihu.com/question/43510016/answer/96163671
    来源:知乎
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    1. 专著著录格式

      [序号]著者.书名[M].版本(第一版不写).出版地:出版者,出版年:起止页码

      例:[1]孙家广,杨长青.计算机图形学[M].北京:清华大学出版社,1995:26-28

      2. 期刊著录格式

      [序号]作者.题名[J].刊名,出版年份,卷号(期号):起止页码

      例:[3]李旭东,宗光华,毕树生,等.生物工程微操作机器人视觉系统的研究[J].北京航空航天大学学报,2002,28(3):249-252

      3. 论文集著录格式

      [序号]作者.题名[C]//主编.论文集名.出版地:出版者,出版年:起止页码

      例:[4]张佐光,张晓宏,仲伟虹,等.多相混杂纤维复合材料拉伸行为分析[C]//张为民.第九届全国复合材料学术会议论文集(下册).北京:世界图书出版公司,1996:410-416

      4. 学位论文著录格式

      [序号]作者.题名[D].保存地点:保存单位,年

      例:[6]金宏.导航系统的精度及容错性能的研究[D].北京:北京航空航天大学自动控制系,1998

      5. 电子文献著录格式

      [序号]作者.题名[文献类型标志/文献载体标志].出版地:出版者,出版年(更新或修改日期)[引用日期].获取和访问路径

      例:[10]杨家军.开放式研究性教学模式的研究与实践[EB/OL].北京:中国教育和科研计算机网, 2009[ 2009-12-8]. 开放式研究性教学模式的研究与实践

      说明

      (1)参考文献应是公开出版物,按在论著中出现的先后用阿拉伯数字连续排序.

      (2) 外国人名书写时一律姓前、名后,姓用全称,名可缩写为首字母(大写),不加缩写点.

      (3)参考文献中作者为3人或少于3人应全部列出,3人以上只列出前3人,后加“等”(见例3).

    展开全文
  • java中参数传值和传引用例子详解

    千次阅读 2018-10-11 16:07:56
    但是引用类型不同的地方在于真正的数据并没有在栈区的变量中保存,而是在堆区里面保存着,所以虽然也拷贝了一份,也是副本,但是二者指向的是同一块堆区。 引用数据类型就好比如说,两位同学使用的是同一份复习...

    1.当传参数为基本数据类型时,在方法体中对形参的修改不会影响到实参的数值
    set类:

    package hello;
     public class set {
          public  set(int a){
          a--;
          System.out.println("a的函数值为:"+a);
    }  //构造函数 
    }
    
    

    主函数:

    public class Hello {                                                                                            
        public static void main(String[] args) {
            // TODO code application logic here
            int a=50;
            //set(50);
            set ss=new set(a);
            System.out.println("a的真实值为:"+a);
        }
        
    }
    

    运行结果:在这里插入图片描述
    从a的真实值可以看出,参数传递的是数值传递,set函数调用结束后并没有影响a的真实值。
    2.当传参数为引用时,传递的是对象的值,也就是对象的首地址。就是把对象的地址赋值给形参。
    Battery类

    package example_1;
    public class Battery {
        int electcicityAmount;
        public Battery(int amount){
            electcicityAmount=amount;
        }    
    }
    

    Radio类

    package example_1;
    public class Radio {
        void openRadio(Battery battery){
            battery.electcicityAmount=  battery.electcicityAmount-10;
        }    
    }
    

    主函数:

    package example_1;
        public static void main(String[] args) {
            // TODO code application logic here
            Battery battery=new Battery(100);
            System.out.println("电池的存储电量是:"+battery.electcicityAmount);
            Radio radio=new Radio();
            System.out.println("收音机开始使用电池");
            radio.openRadio(battery);
            System.out.println("收音机使用后的电量为:"+battery.electcicityAmount);    
        }
    }
    

    在这里插入图片描述

    基本数据类型和引用数据类型作为参数的区别
    基本数据类型的变量中直接存放数据值本身,所以改的时候改的是数据值本身;
    但是引用类型不同的地方在于真正的数据并没有在栈区的变量中保存,而是在堆区里面保存着,所以虽然也拷贝了一份,也是副本,但是二者指向的是同一块堆区。

    引用数据类型就好比如说,两位同学使用的是同一份复习资料,其中一人把资料撕毁了,另一人当然也会受到影响。
    而基本数据类型就好比复印了一份,其中一人将自己的资料撕了,并不影响别人。

    总结:
    1).当使用基本数据类型作为方法的形参时,在方法体中对形参的修改不会影响到实参的数值
    2).当使用引用数据类型作为方法的形参时,若在方法体中修改形参指向的数据内容,则会

    • 对实参变量的数值产生影响,因为形参变量和实参变量共享同一块堆区
      3).当使用引用数据类型作为方法的形参时,若在方法体中修改形参变量的指向,此时不会
    • 对实参变量的数值产生影响,因此形参变量和实参变量分别指向不同的堆区

    原文:https://blog.csdn.net/xyphf/article/details/78117027?utm_source=copy
    在这里插入图片描述

    展开全文
  • 引用大佬的博客: 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);
    
    
    展开全文
  • 这是Qt的工程 是一个Windows下Qt引用FFMPEG的例子 FFMPEG的版本是2.5.2 关于代码的解释请看以下这篇文章: http://blog.yundiantech.com/?log=blog&id=7
  • 之前看到循环引用的时候,总是只能看到一个很简单的例子,我觉得挺没意思,因为没有实际的意义,就想找个好点的例子来分享。 所以,这篇文章将专注于展示一个更实际点的例子来说明实际工作中确实会碰到shared_ptr的...

    本文目标

    本文默认读者是已经了解了观察者模式智能指针的来龙去脉,智能指针的介绍可以参考我的博客:话说智能指针发展之路

    之前看到循环引用的时候,总是只能看到一个很简单的例子,比如这个c++ 智能指针及 循环引用问题,我觉得挺没意思,因为没有实际的意义,就想找个好点的例子来分享。

    所以,这篇文章将专注于展示一个更实际点的例子来说明实际工作中确实会碰到shared_ptr的循环引用的问题,然后再展示如何使用weak_ptr来解决。

    编译代码

    下文即将展示的代码,编译不需要boost库,只需要编译器支持C++11即可!比如我使用的g++就可以这样来编译:

    g++ -std=c++11 example.cpp -o out

    循环引用是如何形成的

    建议先看上面说到的那个简单的例子,然后再来看下面这个例子。循环引用形成的原因概括起来就是“你中有我,我中有你”。

    建议看代码的顺序为:main函数是怎么调用各个接口的,然后再看类的声明,接着再看接口的实现,最后结合输出,分析为什么!

    #include <iostream>
    #include <string>
    #include <memory>
    #include <vector>
    using namespace std;
    
    // 前向声明,以便Observer能够使用这个类型
    class Observable;
    
    // 观察者类
    class Observer {
    public:
        Observer(const char* str);
        void update();
        void observe(shared_ptr<Observable> so, shared_ptr<Observer> me);
        virtual ~Observer();
    
    private:
        string m_info;
        shared_ptr<Observable> m_observable;
    };
    
    
    // 被观察的物体类
    class Observable {
    public:
        void register_(shared_ptr<Observer> ob);
        void notify();
        ~Observable();
    
    private:
        vector<shared_ptr<Observer> > m_observers;
        typedef vector<shared_ptr<Observer> >::iterator Iterator;
    };
    
    
    int main() {
        // 假设我们必须用到shared_ptr来管理对象
        shared_ptr<Observable> p(new Observable());
    
        // 用花括号创建一个局部作用域
        {
            /*
            这三个局部shared_ptr对象,在离开作用域之后就会被销毁。
            由于还有一份被Observable对象引用了,还是不会马上析构。
            */
            shared_ptr<Observer> o1(new Observer("hello"));
            shared_ptr<Observer> o2(new Observer("hi"));
            shared_ptr<Observer> o3(new Observer("how are you"));
    
            o1->observe(p, o1);
            o2->observe(p, o2);
            o3->observe(p, o3);
    
            p->notify();
        }
    
        cout << "\nget out now...\n" << endl;
        p->notify();
        cout << "Observable's use_count is: " << p.use_count() << endl;
    
    
        return 0;
    }
    
    
    // Observable的接口实现
    void Observable::register_(shared_ptr<Observer> ob) {
        m_observers.push_back(ob);
    }
    
    
    void Observable::notify() {
        Iterator it = m_observers.begin();
        while (it != m_observers.end()) {
            cout << "notify, use_count = " << it->use_count() << endl;
            (*it)->update();
            ++it;
        }
    }
    
    Observable::~Observable() {
        cout << "~Observable()..." << endl;
    }
    
    
    // Observer的接口实现
    Observer::Observer(const char* str)
    : m_info(str) {}
    
    
    void Observer::update() {
        cout << "update: " << m_info << endl;
    }
    
    void Observer::observe(shared_ptr<Observable> so, shared_ptr<Observer> me) {
        so->register_(me);
        m_observable = so;
    }
    
    Observer::~Observer() {
        cout << "~Observer(): " << m_info << endl;
    }

    运行输出为:

    notify, use_count = 2
    update: hello
    notify, use_count = 2
    update: hi
    notify, use_count = 2
    update: how are you

    get out now…

    notify, use_count = 1
    update: hello
    notify, use_count = 1
    update: hi
    notify, use_count = 1
    update: how are you
    Observable’s use_count is: 4

    下面用几个自问自答的问题来分析这个输出:

    问题1:为什么第一次notify时的use_count是2?

    因为一份引用在main函数里,一份存在Observable对象的vector成员里。

    问题2:为什么第二次notify的use_count是1?

    因为main函数里的那份引用一旦出了局部的作用域,就析构了,所以shared_ptr的引用计数减少了1,而存在Observable对象里的那一份没有析构,所以计数为1。

    问题3:为什么最后Observable对象的use_count是4?

    因为main函数里有一个引用(shared_ptr的对象p),而o1,o2,o3这三个对象里分别有一个对同个对象的引用,所以总数是4。

    问题4:为什么直到程序结束,仍然没有调用析构函数?

    因为,Observable的引用计数是4,即使在离开main函数之前会析构掉其作用域内的shared_ptr<Observable>对象,计数值也只减少为3,所以它不会析构。
    而所有Observer对象的引用计数由于Observable对象没有析构,所以一直保留着一份在其中,引用计数为1,也不会析构。

    这样就死锁了嘛,A等B析构,B等A析构。所以谁都没成功析构掉,这就造成了内存泄露!!!至于内存泄露的危害,烦请自行检索资料。

    解决方法

    weak_ptr和shared_ptr搭配就可以完美解决循环引用的问题!!!
    怎么做到的呢?
    weak_ptr是一种弱引用,被它引用的资源,计数值不会因为它而改变。

    同上,先看示例代码,再来结合输出结果分析:

    #include <iostream>
    #include <string>
    #include <memory>
    #include <vector>
    using namespace std;
    
    // 前向声明,以便Observer能够使用这个类型
    class Observable;
    
    // 观察者类
    class Observer {
    public:
        Observer(const char* str);
        void update();
        void observe(shared_ptr<Observable> so, shared_ptr<Observer> me);
        virtual ~Observer();
    
    private:
        string m_info;
        shared_ptr<Observable> m_observable;
    };
    
    // 被观察的物体类
    class Observable {
    public:
        void register_(weak_ptr<Observer> ob);
        void notify();
        ~Observable();
    
    private:
        vector<weak_ptr<Observer> > m_observers;
        typedef vector<weak_ptr<Observer> >::iterator Iterator;
    };
    
    
    int main() {
        // 假设我们必须用到shared_ptr来管理对象
        shared_ptr<Observable> p(new Observable());
    
        // 用花括号创建一个局部作用域
        {
            /*
            这三个局部shared_ptr对象,在离开作用域之后就会被销毁。
            由于weak_ptr不参与计数,即使还有一份被Observable对象(弱)引用了,
            shared_ptr对象的计数值将降低为0,所以会马上析构。
            */
            shared_ptr<Observer> o1(new Observer("hello"));
            shared_ptr<Observer> o2(new Observer("hi"));
            shared_ptr<Observer> o3(new Observer("how are you"));
    
            o1->observe(p, o1);
            o2->observe(p, o2);
            o3->observe(p, o3);
    
            p->notify();
            cout << "Observable's use_count is: " << p.use_count() << endl;
        }
    
        cout << "\nget out now...\n" << endl;
        p->notify();
        cout << "Observable's use_count is: " << p.use_count() << endl;
    
        return 0;
    }
    
    // Observable的接口实现
    void Observable::register_(weak_ptr<Observer> ob) {
        m_observers.push_back(ob);
    }
    
    void Observable::notify() {
        Iterator it = m_observers.begin();
        while (it != m_observers.end()) {
            cout << "notify, use_count = " << it->use_count() << endl;
    
            /*
            先将weak_ptr提升为shared_ptr,而shared_ptr重载了bool
            操作符,所以直接用if (p)就可以判断所引用的内容是否已经失效。
            至于为何要提升为shared_ptr,是因为weak_ptr没有重载->操作符
            以及没有提供获取原始指针的接口,所以想要执行update操作,
            就得先转换为shared_ptr。
            */
            shared_ptr<Observer> p(it->lock());
            if (p) {
                p->update();
                ++it;
            } else {
                cout << "Erase when notify..." << endl;
                it = m_observers.erase(it);
            }
        }
    }
    
    // Observer的接口实现
    Observer::Observer(const char* str)
    : m_info(str) {}
    
    
    void Observer::update() {
        cout << "update: " << m_info << endl;
    }
    
    void Observer::observe(shared_ptr<Observable> so, shared_ptr<Observer> me) {
        so->register_(me);
        m_observable = so;
    }
    
    Observer::~Observer() {
        cout << "~Observer(): " << m_info << endl;
    }

    输出结果为:

    notify, use_count = 1
    update: hello
    notify, use_count = 1
    update: hi
    notify, use_count = 1
    update: how are you
    Observable’s use_count is: 4
    ~Observer(): how are you
    ~Observer(): hi
    ~Observer(): hello

    get out now…

    notify, use_count = 0
    Erase when notify…
    notify, use_count = 0
    Erase when notify…
    notify, use_count = 0
    Erase when notify…
    Observable’s use_count is: 1
    ~Observable()…

    还是几个自问自答的问题:

    问题1:为什么第一次notify时的use_count是1?

    因为一份引用在main函数里,而Observable对象里存放的是Observer对象的weak_ptr对象,不参与计数,所以计数值只是1。

    问题2:为什么离开作用域时,三个Observer对象就析构了?

    因为main函数里的那份引用一旦出了局部的作用域,就析构了,所以shared_ptr的引用计数减少了1,而存在Observable对象里的那一份是弱引用,没有参与计数,所以计数值降低为0(从输出也可以看出来,第二次notify时,use_count变为0了),自然就析构了。

    问题3:为什么第二次notify时都显示已经erase了?

    因为weak_ptr对象们所引用的资源都已经析构了,所以当它提升为shared_ptr后,程序判断该对象为空,表示资源已经失效了,自然就输出了Erase when notify...

    问题4:为什么程序结束时Observable对象能成功析构?

    因为,在离开局部作用域之前,Observable的引用计数是4;而离开局部作用域时,三个Observer对象都析构了,所以Observable的引用计数减少为1。

    然后最后程序结束,即将退出main函数之前,会析构掉其作用域内的Observable对象,所以其计数值减少为0,自然就真正析构了。


    综上,至此,很简洁地使用weak_ptr和shared_ptr搭配,避免了互相引用的双方都使用shared_ptr而造成的循环引用问题!

    参考

    1. 本例参考了陈硕在他的《Linux 多线程服务端编程:使用 muduo C++ 网络库》一书中的一个类似的例子,只不过他更侧重于在线程安全的角度来说明,并且代码需要依赖boost库,代码地址为:https://github.com/chenshuo/recipes/blob/master/thread/test/Observer_safe.cc
    2. cplusplus.com的api说明对学习智能指针很有帮助,因为你能快速全面了解其提供的接口,shared_ptrweak_ptr
    展开全文
  • VB做DLL并引用DLL最简单的例子,VBDLL 引用DLL vb例子
  • 深入理解引用传递 public class Main { public static void changeStrBuffer(StringBuffer sb1, StringBuffer sb2) { sb1.append(" World"); sb2 = sb1; } public static void main(String[...
  • 在周志明前辈的《深入理解Java虚拟机(第二版)》3.2.3节:再谈引用 中,介绍了Java中的几种引用: 在JDK 1.2以前,Java中的引用的定义很传统:如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址...
  • this 引用句柄例子大解析this 引用句柄例子大解析
  • java引用类型数据包括数组,接口,等等,当参数是引用类型时,“传值”传递的是变量中存放是“引用”,儿不是变量所引用的实体,下面有两个个很好的例子例子1: 首先写一个电池类,和收音机类package Example1; ...
  • Androidstudio自定义gradle插件并被其他项目引用
  • 解决循环引用的一个例子

    千次阅读 2012-08-29 23:57:44
    最近在讨论设计时注意到一个循环引用的问题。它是在使用引用计数指针时发生的。如下图所示: ClassA和ClassB分属两个不同的线程,ClassB通常由ClassA发起请求创建,并由ClassA使用,ClassB则会在必要时通知ClassA...
  • 演示c++ 引用 友员 模板 继承 类与对象基本概念用法的代码
  • VB6.0的“工程-引用”中有很多控件供用户使用,但有时需要自己编写dll文件以实现某些功能。本文介绍如何自己编写一个简单的dll文件,然后在win7 64位下使用regsvr32注册,并在VB6.0中引用,最后在标准EXE中调用实现...
  • C++引用&函数传递数组例子

    万次阅读 2018-04-30 09:56:44
    #include &lt;iostream&gt;using namespace std;/*排序*/void xll(int (&amp;ac)[5]);//排序函数int main(){ int a[5] = {1,8,5,6,3}; xll(a); return 0;}void xll(int (&... for(int i = ...
  • ThreadLocalMap里弱引用

    万次阅读 多人点赞 2018-03-29 17:20:56
    要回答ThreadLocalMap里弱引用,我们需要弄清者三个问题第一个问题,我们先来看看引用相关的。其实Java中一直有争论关于值传递与引用传递(就我看到的百度是这样的)。我们先来看看代码。public static void main...
  • ZooKeeper官方Java例子解读

    千次阅读 多人点赞 2018-10-22 22:55:15
    ZooKeeper官方提供了一个Java监听的例子,本文是我对该例子的学习笔记。可以做为帮助理解此例子的资料: 文档原文连接:http://zookeeper.apache.org/doc/current/javaExample.html#sc_completeSourceCode 翻译...
  • sed中的反向引用的小例子

    千次阅读 2018-07-22 09:19:10
    按次序排列,其他就可以使用反向引用中\2 \1 \3来排序,排列的结果就是"2016 2017 2018" [root@localhost #] echo -e "2017 2016 2018" | sed -e "s/\(.*\) \(.*\) \(.*\)/\2 \1 \3/g&...
  • javascript逆向引用的小例子

    万次阅读 2012-10-16 22:02:10
    javascript逆向引用的小例子: function isIP(strIP) { if (strIP=="") return false; var re=/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/g //匹配IP地址的正则表达式 if(re.test(strIP)) {//这里的$1,$2..就是后项引用 if( ...
  • 注意(子类实例赋给父类引用): 父类引用不能调用子类中特定方法; 父类引用调用的是子类重写或实现父类的方法,引用变量是子类对象的地址。 创建一个抽象类Teacher,包括name属性和TeachClass()方法; ...
  • 可能看起来有点枯燥,但引用是在JNI中最容易出错的一个点,如果使用不当,容易使程序造成内存溢出,程序崩溃等现象。所以讲得比较细,有些地方看起来可能比较啰嗦,还请轻啪!下一篇文章会写一个在Andro
  • const,vector,引用的使用例子

    千次阅读 2015-09-21 20:02:42
    const,vector,引用的使用例子 #include #include using namespace std; void print(vector a) { for(int i=0;i ;i++) { std::cout [i] ; } std::cout ; } //vector add(vector a,vect
  • 2.在解决方案资源管理器中右击项目(不是右击解决方案),然后点击“添加服务引用” 3.弹出一个对话框,输入wsdl文件的URL然后单击OK。单击OK后会提示错误,你要把“?wsdl”从URL里删掉。 4.
  • java中的各种引用介绍

    万次阅读 2016-09-25 10:49:11
    主要讲解软引用和弱引用的概念以及引用队列的用法,最后介绍了weakhashmap,关于自定义使用软引用结合hashmap构建缓存,可以看参考文章,以后有机会也会专门写一篇介绍。 java中各种引用存活周期强引用>软引用>弱...
  • 吃人的那些 Java 名词:对象、引用、堆、栈

    万次阅读 多人点赞 2019-09-05 15:57:09
    作为一个有着 8 年 Java 编程经验的 IT 老兵,说起来很惭愧,我被 Java 当中的四五个名词一直困扰着:**对象、引用、堆、栈、堆栈**(栈可同堆栈,因此是四个名词,也是五个名词)。每次我看到这几个名词,都隐隐...
  • 背景:收到公众投稿,《从面试题中看Java的Reference(引用)》,分析的很不错,总感觉少了实际的例子和应用场景。于是结合自己工作中场景,小总结一下。看下Agenda如下: 1、强引用 2、软引用 3、弱引用 4、什么时候...
  • 正则表达式——捕获组和反向引用

    千次阅读 2018-09-17 17:23:20
    正则表达式的捕获组和反向引用: 使用小括号指定一个子表达式后,匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其他程序中作进一步处理。默认情况下,每个分组会自动拥有一个组号,规则是:从...
  • 例子 @[toc](目录) # 一级标题 ## 二级标题 显示效果 2. 标题 共支持6级标题 例子 # 一级标题 ## 二级标题 ### 三级标题 显示效果 3. 强调 3.1 加粗 例子: **加粗的字** 显示效果: 加粗的字 3.2 键盘文本 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,003,239
精华内容 401,295
关键字:

引用的例子大全