精华内容
下载资源
问答
  • 各位高手,请教一个mediawiki的问题,在mediawiki中如何通过引用分类,实现自动在页面上显示当前分类中最新几个页面的列表,万分感谢
  • MFC工程源码,引用libcaffe分类;实现功能:图像分类、性别判断、年龄估算
  • Java引用类型分类以及详解

    千次阅读 2018-06-11 00:10:46
    Java引用类型分类以及详解 - Java引用类型概述 在JVM之中再好的算法,也敌不过一个好烂的程序员。一个程序要想写好有两点:按照开发标准进行、请写有用代码。 而对于垃圾的产生与回收的处理之中,要想进行更好...

    Java引用类型分类以及详解

    - Java引用类型概述

    在JVM之中再好的算法,也敌不过一个好烂的程序员。一个程序要想写好有两点:按照开发标准进行、请写有用代码。
    而对于垃圾的产生与回收的处理之中,要想进行更好的控制,就必须清楚的掌握Java中的四种引用方式。
    强引用(Strong Reference):即使进行了多次的GC回收,即使JVM真的已经不够用了,即使JVM最终不得已抛出了OOM错误,那么该引用继续抢占;
    软引用(Soft Reference):当内存空间不足时,可以回收此内存空间。如果充足则不回收,可以用其完成缓存的一些处理操作开发。
    缓存:保证数据更快的操作(读取)。是不重要的数据。可以作为牺牲来释放空间。
    弱引用(Weak Reference):不管内存是否紧张,只要一出现GC处理,则立即回收。
    幽灵引用(Phantom Reference):和没有引用是一样的。
    比如HashMap根据key取得值,设置key值为null和不设置key值的效果是一样的。

    • 强引用

    强引用是Java默认支持的一种操作模式,也就是说在引用的处理其间,即使出现有GC,即使内存不足,该引用的数据也不会被回收。

    范例:观察强引用:

    这里写图片描述
    这个流程就叫做强引用。在之前所编写的所有操作都属于强引用,而强引用只有全部的对象都断开连接之后,才可能称为垃圾空间,才有可能被回收。而即使有一个对象引用此空间,那么该对象也不会被回收。
    在多线程状态下,即使产生多个引用对象,空间也不会被回收。

    这里写图片描述
    每个线程都会出现OOM
    强引用并不是造成OOM的关键性因素,正常来讲,你每一个用户(线程)操作完成后,该对象都可以被很容易的进行回收,不必强制性进行回收。

    • 软引用
      软引用指的是当内存不足的时候才进行GC的空间释放,但是如果要想使用软引用必须单独使用特殊的处理类:
      java.lang.ref.SoftReference,该类的定义如下:

    这里写图片描述
    除了强引用,其它引用必须借助特殊类来完成。

    这里写图片描述
    软引用的类继承了Reference的引用父类。
    这个类下有三个引用:
    这里写图片描述

    在软引用之中如果想要进行引用的处理操作,则可以使用如下的方法完成:

    1.构造方法:public SoftReference(T reference);
    2.取得引用的数据:public T get();

    范例:观察软引用:
    这里写图片描述
    软引用与强引用相比,最大的特点在于:软引用中保存的内容如果在内存富裕的时候会继续保留,内存不足会作为第一批的丢弃者进行垃圾空间的释放。
    在开发中,可以利用软引用可以实现高速缓存组件。
    缓存处理好了,你的程序写的才能达到高性能的第一步

    • 弱引用
      弱引用最大的特点就是一旦发生了GC的处理操作,则保存的引用内容将立即释放。弱引用使用“WeakReference”类来完成。
      java.lang.ref.WeakReference

    范例:弱引用处理
    这里写图片描述

    因为不执行GC,所以弱引用的对象并没有被释放。输出依然有值。
    这里写图片描述
    输出为null;
    一旦执行了GC,那么就需要进行内存空间的释放,在类集里面有一个与弱引用功能相似的Map集合WeakHashMap,它属于弱引用的一个实现。

    这里写图片描述

    这里写图片描述

    whm中存放的都是匿名对象。
    个人觉得使用WeakHashMap最大的好处是可以用它保存一些共享数据,这些共享数据如果长时间不使用,可以将其清空。

    • 引用队列
      在之前使用软引用和弱引用的时候都会发现有这样一个构造方法:
      SoftReference:
      这里写图片描述
      WeakReference:
      这里写图片描述
      java.lang.ref包中一共五各类:一个父类,三个子类,另外一个就是引用队列。

    引用队列:待被砍掉的对象的集合点
    如果要清楚引用队列,则首先必须知道对象的引用的强度。如果说按照现在的理解来讲:强引用的强度大于软引用,软引用大于弱引用。

    这里写图片描述
    通过以上的图形分析可以发现,如果要想找到“对象5”,那么一共有两条对象的可及性的路径:
    这里写图片描述

    在以上给出的引用的路径上,1到5是最强引用,但是由于其本身存在一个软引用,所以对象5对于整个的程序就属于软可及对象。
    在java里面,如果某一个对象不属于强引用,那么就需要有一个专门的机制来清除那些不具有存在价值的对象(强对象才有价值)
    所以这个时候如果保存有太多的无价值对象就会造成内存泄漏,那么为专门提供有一个引用队列,当某一个对象被垃圾回收后,则该对象会被保存到引用队列之中。

    范例:观察引用队列的处理操作;
    这里写图片描述
    在发生GC内存清理之前,此时引用队列中为null;
    这里写图片描述
    此处必须断开强引用
    执行完GC之后引用队列有内容。

    引用队列里面保存的就是一个要准备被回收的对象的信息。

    • 幽灵引用(虚引用)
      幽灵引用指的是什么都不保存,但是又看起来像是保存了一样。
      这个的处理类java.lang.ref.PhantomReference。

    范例:观察幽灵引用:
    幽灵引用直接就把要保存的内容保存在了引用队列之中
    这里写图片描述

    需要发生引用但是又不需要引用占用空间的时候。—采用幽灵引用。

    展开全文
  • 本文给大家介绍php引用传递,如何通过引用出的思想实现无限分类,代码超简单,需要的朋友可以借鉴下
  • 基于深度学习的科技论文引用关系分类模型.pdf
  • 主要介绍了PHP实现无限极分类的两种方式,结合实例形式分析了php基于递归和引用方式进行数组遍历的相关操作技巧,需要的朋友可以参考下
  • Java中的引用类型分类以及使用场景

    千次阅读 2016-10-27 20:13:21
    (1)强引用  如果一个对象具有强引用的话,垃圾回收器不会回收这个对象,即使内存空间不足的时候也不会回收具有强引用类型的对象,平时通过new创建一个对象赋值给一个变量(Aa = new A()),这种方式就是强引用,强...

    (1)强引用

        如果一个对象具有强引用的话,垃圾回收器不会回收这个对象,即使内存空间不足的时候也不会回收具有强引用类型的对象,平时通过new创建一个对象赋值给一个变量(Aa = new A()),这种方式就是强引用,强引用类型的对象,在不使用时要赋值为null,才能被垃圾回收器回收。

    (2)软引用

        如果一个对象只具有软引用,内存空间足够,垃圾回收器就不会回收它,如果内存空间不足,就会回收这些对象的内存。只要垃圾回收器没有回收软引用类型的对象,程序就一直可以使用该对象。适用于网页缓存、图片缓存,防止内存溢出,在内存充足的时候,缓存对象会一直存在,在内存不足的时候,缓存对象占用的内存会被垃圾收集器回收。

        定义一个HashMap,保存软引用的Bitmap对象,防止oom


    (3) 弱引用

        弱引用(WeakReference),具有弱引用的对象的生命周期更短,垃圾回收器在扫描的时候,一旦发现只具有弱引用的对象,不管内存空间是否足够,都会回收它的内存。



    单例类持有一个activity引用时,会造成内存泄露,把activity声明为弱引用,在activity销毁后,垃圾收集器扫描到activity对象时,会回收activity对象的内存。



    单例类持有activity的this引用,在activity销毁后,activity对象占用的内存不能被及时回收,因为单例对象持有这个activity实例的引用,造成内存泄露。解决办法:换成getApplicationContext(),getApplicationContext()返回的是Application对象的Context,Application本身就是全局的对象。



    或者将mContext对象声明为弱引用,弱引用在垃圾收集器扫描到的时候,不管内存充裕不充裕,都要回收弱引用占用的内存。



    注意:在回收activity对象占用的内存时,不会回调任何生命周期方法,生命周期方法和activity对象的回收没有任何关系。

    (4)虚引用

    虚引用并不会决定对象的生命周期,如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。



    展开全文
  • 最近做的一个项目涉及到无限分类的问题,现在总结...涉及无限极分类的问题建表时,都会有一个专门的分类表,表中有一个pid字段默认为0,属于一级分类,pid字段关联当前分类表的id,用来标明当前分类所属的上级分类,...

    最近做的一个项目涉及到无限分类的问题,现在总结如下,代码使用PHP语言实现,因为使用了TP3的框架,所以一些方法的使用上,直接使用了TP3现有的方法。

    想要根据分类id查找所有所属父级分类信息请往后拉,这部分在最后实现!!!

    建表:

    涉及无限极分类的问题建表时,都会有一个专门的分类表,表中有一个pid字段默认为0,属于一级分类,pid字段关联当前分类表的id,用来标明当前分类所属的上级分类,例如建一个问题分类表的语句如下:

    CREATE TABLE `quescate` (
      `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '问题分类id',
      `title` varchar(250) NOT NULL COMMENT '问题分类标题',
      `pid` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '所属问题id',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='问题分类表';
    

    一、无限极分类的实现

    接下来取出各级分类及分类下的子分类,自己做时用了最笨的办法:

    (1)先查找一级分类(pid=0)

    (2)通过上级分类查找的id作为pid,来查找下一级分类

    (3)重复步骤(2)

    代码实现如下:

    <?PHP 
        $cate = array();
        // 一级分类
        $cate_0 = $this->where('pid = 0')->select();
        if (!empty($cate_0)){
            // 二级分类
            $ids_1 = array_map('reset', $cate_0); // 使用array_column()更简单,但是需要>=PHP5.5.0的版本
            $map_1['pid'] = array('in', $ids_1);
            $cate_1 = $this->where($map_1)->select();
            if(!empty($cate_1)){
                // 三级分类
                $ids_2 = array_map('reset', $cate_1);
                $map_2['pid'] = array('in', $ids_2);
                $cate_2 = $this->where($map_2)->select();
            }
            $cate = array(0=>$cate_0, 1=>$cate_1, 2=>$cate_2);
        }
        unset($ids_1, $map_1, $ids_2, $map_2);
    
        return $cate;
    ?>

    但是这样的办法,有几级分类就要查找几次,太过麻烦,也会造成代码冗余。根据上述步骤很轻易看出,这其实就是一个递归。于是在优化代码的过程中,可以通过递归实现无限极分类,通过查找资料还找到了引用,栈的实现方法,下面一一介绍,为了更直观,使用的数据如下:

    <?php 
        $res = array(
            array('id' => 8, 'title' => '美国', 'pid' => 0),
            array('id' => 9, 'title' => '纽约', 'pid' => 8),
            array('id' => 10, 'title' => '韩国', 'pid' => 0),
            array('id' => 11, 'title' => '日本', 'pid' => 0),
            array('id' => 12, 'title' => '加拿大', 'pid' => 0),
            array('id' => 13, 'title' => '中国', 'pid' => 0),
            array('id' => 14, 'title' => '华盛顿', 'pid' => 8),
            array('id' => 16, 'title' => '洛杉矶', 'pid' => 8),
            array('id' => 17, 'title' => '北京', 'pid' => 13),
            array('id' => 18, 'title' => '上海', 'pid' => 13),
            array('id' => 19, 'title' => '广东', 'pid' => 13),
            array('id' => 20, 'title' => '深圳', 'pid' => 13),
            array('id' => 21, 'title' => '杭州', 'pid' => 13)
        );
    ?>
    1. 递归,实现无限极分类。递归应该是最容易想到的方法了。其实递归函数也是借助于栈的机制实现的,但是底层对于栈的处理对于程序员来说都是透明的,程序员只需要关心应用的实现逻辑。所以说使用递归处理上述问题理解起来比较容易,代码也比较简洁。在我看来,最容易理解的方法应该是使用栈的方式实现无限极分类了(可以参考以下的第三种方法)
    主要参考博客:
    php实现无限级分类查询(递归、非递归)中开头部分递归与栈的讲解
    PHP实现无限极分类的两种方式,递归和引用中的递归方法
    <?php 
        /**
         * 递归实现无限极分类
         * @param array $array 分类数据
         * @param Int $pid 父ID
         * @param Int $level 分类级别
         * @return Array $list 分好类的数组 直接遍历即可 $level可以用来遍历缩进
         */
        function getTree($array, $pid =0, $level = 0){
            //声明静态数组,避免递归调用时,多次声明导致数组覆盖
            static $list = [];
            foreach ($array as $key => $value){
                //第一次遍历,找到父节点为根节点的节点 也就是pid=0的节点
                if ($value['pid'] == $pid){
                    //父节点为根节点的节点,级别为0,也就是第一级
                    $value['level'] = $level;
                    //把数组放到list中
                    $list[] = $value;
                    //把这个节点从数组中移除,减少后续递归消耗
                    unset($array[$key]);
                    //开始递归,查找父ID为该节点ID的节点,级别则为原级别+1
                    $this->getTree($array, $value['id'], $level+1);
                }
            }
            return $list;
        }
    
        // 无限极分类的第一种方法:递归
        $list = getTree($res, 0, 1);
        /*
        * 以下是根据自己需要对分好类的数据进行的处理,这里为了保持与上边需要的数据形式一致
        */
        foreach ($list as $key=>$value){
            if ($value['level'] == 1){
                $cate[0][] = $value; // 一级分类
            }elseif ($value['level'] == 2){
                $cate[1][] = $value; // 二级分类
            }
        }
    
        return $cate;
    ?>

    2. 引用,实现无限极分类。此方法非常巧用引用。如果不了解引用,对下面方法的理解是困难的,建议参考PHP手册引用一章

    主要参考博客:PHP无限极分类实现中的方法一,里面的方法二只是判断将三目运算符改成了if判断,喜欢的可以看看

    <?php 
        /**
         * 将数据格式转换成树形结构数组
         * @param array $items 要进行转换的数组
         * @return array $items 转换完成的数组
         */
        function arrayToTree(Array $items) {
            foreach ($items as $key=>$item) {
                $items[$item['pid']]['son'][$key] = &$items[$key];
            }
            return isset($items[0]['son']) ? $items[0]['son'] : array();
        }
    
        $cate[1] = array(); // 预定义二级分类为空
        // 将数组索引改为id值
        $res = array_reduce($res, create_function('$res, $val', '$res[$val["id"]] = $val; return $res;'));
        $list = $this->arrayToTree($res);
        /*
        * 以下是根据自己需要对分好类的数据进行的处理,这里为了保持与上边需要的数据形式一致
        */
        foreach ($list as $ke=>$val){
            if (isset($val['son'])){
                $cate[1] += $val['son']; // 二级菜单
                unset($val['son']); // 从二级菜单中去除一级菜单
            }
            $cate[0][] = $val; // 一级菜单
        }
    
        return $cate;
    ?>

    3. 栈,实现无限极分类。栈的实现方式应该算是最容易理解的了,当然栈的核心:“先进后出”是必须要知道才能理解好下面的方法的。有关于栈,有兴趣的可以查一查《数据结构(C语言版)》中对于栈的讲解。

    主要参考博客:php实现无限级分类查询(递归、非递归)中的“非递归,即使用栈机制实现无限级栏目的查询”

    <?php 
        /**
         * 非递归,即使用栈机制实现无限级栏目的查询
         * 其实栈的核心机制也就四个字:先进后出。
         * 在这对于栈的机制不多说,主要说一下如何借助栈实现无限级栏目查询:
         * 1. 首先将顶级栏目压入栈中
         * 2. 将栈顶元素出栈
         * 3. 将出栈元素存入数组中,标记其深度(其深度就是在其父栏目的深度上面加1)
         * 4. 以出栈的元素为父栏目,查找其子栏目
         * 5. 将查找到的子栏目入栈,重复步骤2
         * 6. 判断栈为空的话,流程结束;
         * @param Array $array 要进行栈操作的数组
         * @return Array $list 分好类的数组
        */
        // 自定义入栈函数
        function pushStack(&$stack, $channel, $dep)
        {
            $channel['dep'] = $dep;
            array_push($stack, $channel);
        }
        // 自定义出栈函数
        function popStack(&$stack)
        {
            return array_pop($stack);
        }
        function getStack($array)
        {
            $stack = array(); //定义一个空栈
            $list = array();  //用来保存各个栏目之间的关系以及该栏目的深度
            /*
             * 首先将顶级栏目压入栈中
             * */
            foreach ($array as $key => $val) {
                if ($val['pid'] == 0)
                    pushStack($stack, $val, 1);
            }
            /*
             * 将栈中的元素出栈,查找其子栏目
             * */
            do {
                $par = popStack($stack); //将栈顶元素出栈
                /*
                 * 查找以此栏目为父级栏目的id,将这些栏目入栈
                 * */
                foreach ($array as $key=>$value){
                    if ($value['pid'] == $par['id']){
                        pushStack($stack, $value, $par['dep']+1);
                    }
                }
                // 将出栈的栏目以及该栏目的深度保存到数组中
                $list[] = $par;
            } while (count($stack) > 0);
    
            return $list;
        }
    
        //$res = $this->order('id desc')->select(); // 因为栈先进后出的特点,分类完后的数据会是原数据的倒序排序。这可以在处理数据前,将数据先倒序输出,这样得到的数据就是正序的。
        $res = array_reverse($res);
        $list = getStack($res);
        foreach ($list as $key=>$value){
            if ($value['dep'] == 1){
                $cate[0][] = $value; // 一级分类
            }elseif ($value['dep'] == 2){
                $cate[1][] = $value; // 二级分类
            }
        }
    
        return $cate;
    ?>

    总结:通过以上三种方法可以发现:递归会是最容易想到也最常用到的一种方式,比较容易理解使用方便;引用使用非常巧妙而且代码简洁但是不太好理解;栈的实现最容易理解,但要理解并注意栈的特点:先进后出。

    二、根据分类id倒着查找所有的所属父分类信息

    本来想将这部分放在下一篇博客讲解的,但想趁热打铁,索性放在一篇博客里总结完。

    项目中有时候需要根据分类的id倒回去查找所有所属的父级分类信息,比如面包屑,前端菜单栏里只允许展示有具体信息的分类时,我们就要涉及到这个查找。同样的这个查找也需要用到递归的实现。下面是两种递归的实现方法,但大同小异,基本原理都一样。

    主要参考博文:php实现无限极分类中的“根据子类id查找出所有父级分类信息”

    1. 方法一:Yii2框架中的方法

    <?php 
        /**
         * Yii2框架中,根据子类id查找所有父级分类的方法
         * @param  array $arr 所有分类列表
         * @param  Int  $id 父级分类id
         * @return array $list 所有父级分类信息
        */
        function get_parent_list($arr,$id){
            static $list=array();
            foreach($arr as $u){
    
                if($u['id']== $id){//父级分类id等于所查找的id
                    $list[]=$u;
    
                    if($u['pid']>0){
                        get_parent_list($arr,$u['pid']);
    
                    }
                }
            }
            return $list;
        }
    
        $cate = get_parent_list($res, $pid); // 此处$pid根据查到的具体分类信息中的pid传值查询所属上级分类
        $cate = array_reverse($cate); // 此处根据自己需要做处理,我这里为了页面展示方便做了数组倒序处理
    ?>

    2. 方法二:递归查询分类信息,与方法一大同小异

    <?php 
        function get_parents($id){
            static $list = [];
            $cateModel = new QuescateModel();
            $cate = $cateModel->where('id = '.$id)->find(); // 此处就是查询分类表中一条语句
    
            if($cate){
                $list[] = $cate;
                $id = $cate['pid'];
                if($cate['pid'] > 0){
                    self::get_parents($id);
                }
            }
    
            return $list;
        }
    
        $cate = get_parents($pid); // 根据需要查要查询分级分类的分类id
        $cate = array_reverse($cate); // 此处我是根据自己前端展示分方便最数组做了倒序处理
    ?>

     

    展开全文
  • 行业分类-作业装置-基于引用计数法的新型垃圾回收算法.7z
  • 行业分类-电器装置-低硬度高速电梯曳引用钢丝绳.zip
  • 行业分类-物理装置-文件引用策略的确定方法、装置、设备及存储介质.zip
  • PHP无限极分类巧用引用生成树

    千次阅读 2014-04-24 21:39:34
    上面这种无限极分类数据树形结构化的方法值得借鉴。但是我觉得这段代码实际用途并不明显啊,你想取出格式化的树形数据还是要递归啊: /** * 如何取数据格式化的树形数据 */ $tree = generateTree($items); ...

    首先看代码实现

    function generateTree($items){
        $tree = array();
        foreach($items as $item){
            if(isset($items[$item['pid']])){
                $items[$item['pid']]['son'][] = &$items[$item['id']];
            }else{
                $tree[] = &$items[$item['id']];
            }
        }
        return $tree;
    }
    $items = array(
        1 => array('id' => 1, 'pid' => 0, 'name' => '安徽省'),
        2 => array('id' => 2, 'pid' => 0, 'name' => '浙江省'),
        3 => array('id' => 3, 'pid' => 1, 'name' => '合肥市'),
        4 => array('id' => 4, 'pid' => 3, 'name' => '长丰县'),
        5 => array('id' => 5, 'pid' => 1, 'name' => '安庆市'),
    );
    print_r(generateTree($items));
    

    输出结果

    Array
    (
        [0] => Array
            (
                [id] => 1
                [pid] => 0
                [name] => 安徽省
                [son] => Array
                    (
                        [0] => Array
                            (
                                [id] => 3
                                [pid] => 1
                                [name] => 合肥市
                                [son] => Array
                                    (
                                        [0] => Array
                                            (
                                                [id] => 4
                                                [pid] => 3
                                                [name] => 长丰县
                                            )
     
                                    )
     
                            )
     
                        [1] => Array
                            (
                                [id] => 5
                                [pid] => 1
                                [name] => 安庆市
                            )
     
                    )
     
            )
     
        [1] => Array
            (
                [id] => 2
                [pid] => 0
                [name] => 浙江省
            )
    
    )

    果然是厉害,代码简洁精炼,无需递归,执行速度快。这是我偶然在一个网站上看到的,觉得很实用就收藏下来,分享给大家。

    ------------------------------------ 下面方框里是上一个博主提出的问题,我没看懂什么意思 ,惭愧!-------------------------------------

    上面生成树方法还可以精简到5行:
    function generateTree($items){
        foreach($items as $item)
            $items[$item['pid']]['son'][$item['id']] = &$items[$item['id']];
        return isset($items[0]['son']) ? $items[0]['son'] : array();
    }
    上面这种无限极分类数据树形结构化的方法值得借鉴。但是我觉得这段代码实际用途并不明显啊,你想取出格式化的树形数据还是要递归啊:
    /**
     * 如何取数据格式化的树形数据
     */
    $tree = generateTree($items);
    function getTreeData($tree){
        foreach($tree as $t){
            echo $t['name'].'<br>';
            if(isset($t['son'])){
                getTreeData($t['son']);
            }
        }
    }
    getTreeData($tree);
    不明白为什么他还要递归取出,如果把generateTree()的返回值 输出为json给前端不好吗?

    展开全文
  • 引用: 这里是模仿新浪微博的评论回复区,一条评论下面全是回复的形式,也就是说不是无限级的,只有2级 function getChild ( $data ) { $tree = [ ] ; //返还的最终数组 $newdata = [ ] ; // ...
  • PHP实现无限级分类(递归+引用

    千次阅读 2018-09-10 15:52:07
    那么不是根节点的数据怎么处理呢,我们这里可以把它的地址放到他爹的儿子节点当中,这样的话就是一层层引用,最后所有的数据都被新数组引用了。 说了这么多,代码如下: function getChild($data) { $tree = []...
  • 行业分类-设备装置-便于在文档中创建引用的系统、方法和用户接口.zip
  • 行业分类-嵌入式设备-基于PDF交叉引用表的PDF文件信息嵌入和提取方法.zip
  • 行业分类-物理装置-一种第三方库引用的方法、装置及移动终端.zip
  • PHP实现无限极分类的两种方式,递归和引用

    万次阅读 多人点赞 2018-09-19 19:29:03
    说到无限极分类,比较常见的做法是在建表的时候,增加一个PID字段用来区别自己所属的分类  由于展示数据的时候,需要表达出这种所属关系,所以必然要在读取数据的时候进行一系列处理,由此就牵涉到了两种算法 国民...
  • $return[$v['pid']]['child'][$v['id']] = &$return[$k];
  • Java从1.2版本开始引入了4种引用,这4种引用的级别由高到低依次为: 强引用 > 软引用 > 弱引用 > 虚引用 ⑴强引用(StrongReference) 强引用是使用最普遍的引用。如果一个对象具...
  • 上一篇博客向大家非常详细的介绍了JNI的字段和方法,想必大家都对JNI与Jvm交互有了更深刻的认识。Android NDK(五):字段和方法 ...内容会以引用的类型逐一分析,JNI支持三种引用类型,大致分类如下:  1.
  • 关联引用

    千次阅读 2015-06-28 18:29:33
    关联引用允许开发者为任何对象附着键值数据。 这种能力有很多用法,一种常见的用法是: 1)让分类为属性添加方法。 考虑 Person 类这个例子,假设你要用分类添加一个新属性,叫做 emailAddress。可能其他程序也...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 282,118
精华内容 112,847
关键字:

引用分类