精华内容
下载资源
问答
  • C# 对象比较(值类型、引用类型)

    千次阅读 2015-10-09 20:46:57
    /// /// 引用对象比较 /// /// /// /// public static bool CompareObject(object objA, object objB) { bool flag = false; if
            #region 引用对象比较
            /// <summary>
            /// 引用对象比较
            /// </summary>
            /// <param name="objA"></param>
            /// <param name="objB"></param>
            /// <returns></returns>
            public static bool CompareObject(object objA, object objB)
            {
                bool flag = false;
                if (objA == null || objB == null)
                {
                    flag = false;
                }
                else if (objA == DBNull.Value && objB != DBNull.Value)
                {
                    flag = false;
                }
                else if (objA != DBNull.Value && objB == DBNull.Value)
                {
                    flag = false;
                }
                else if (objA == DBNull.Value && objB == DBNull.Value)
                {
                    //objA objB 对应的列类型已经比较过 类型已判断 值一致
                    flag = true;
                }
                else if (objA.GetType() != objB.GetType())
                {
                    flag = false;
                }
                else if (objA is int || objA is short || objA is long || objA is float || objA is double || objA is decimal)
                {
                    //int 01与1      
                    if (objA is int)
                    {
                        if ((int)objA == (int)objB)
                        {
                            flag = true;
                        }
                    }
                    else if (objA is short)
                    {
                        if ((short)objA == (short)objB)
                        {
                            flag = true;
                        }
                    }
                    else if (objA is long)
                    {
                        if ((long)objA == (long)objB)
                        {
                            flag = true;
                        }
                    }
                    else if (objA is float)
                    {
                        if ((float)objA == (float)objB)
                        {
                            flag = true;
                        }
                    }
                    else if (objA is double)
                    {
                        if ((double)objA == (double)objB)
                        {
                            flag = true;
                        }
                    }
                    else if (objA is decimal)
                    {
                        if ((decimal)objA == (decimal)objB)
                        {
                            flag = true;
                        }
                    }
                }
                else
                {
                    string strA = MetadataXmlSerializer<object>.ToXMLString(objA);
                    string strB = MetadataXmlSerializer<object>.ToXMLString(objB);
                    if (strA == strB)
                    {
                        flag = true;
                    }
                }
                return flag;
            }
            #endregion



    小注:

    如果传入的两个值是dataRow中单元格的值,请先比较类型,类型一致再调用该方法

    深拷贝部分代码:

    C# 实体类序列化与反序列化一 (XmlSerializer)

    C# 实体类序列化与反序列化二 (DataContractSerializer)

    展开全文
  • js 基本类型 引用类型 简单赋值 对象引用 底层原理分析  本文转载自 http://segmentfault.com/a/1190000002789651 原作者版权所有,一直想写一篇这样的分析文章 ,再此感谢原作者! 推荐  收藏 1览 ...

     js 基本类型 引用类型 简单赋值 对象引用 底层原理分析


    本文转载自 http://segmentfault.com/a/1190000002789651 原作者版权所有,一直想写一篇这样的分析文章 ,
    再此感谢原作者!


    ECMAScirpt 变量有两种不同的数据类型:基本类型,引用类型。也有其他的叫法,

    比如原始类型和对象类型拥有方法的类型和不能拥有方法的类型

    还可以分为可变类型和不可变类型,其实这些叫法都是依据这两种的类型特点来命名的,

    大家爱叫啥就叫啥吧 o(╯□╰)o 。

    1.基本类型

    基本的数据类型有:`undefined,boolean,number,string,null.基本类型的访问是按值访问的,

    就是说你可以操作保存在变量中的实际的值。基本类型有以下几个特点:

    1.基本类型的值是不可变得:

    任何方法都无法改变一个基本类型的值,比如一个字符串:

    var name = 'jozo';
    name.toUpperCase(); // 输出 'JOZO'
    console.log(name); // 输出  'jozo'
    

    会发现原始的name并未发生改变,而是调用了toUpperCase()方法后返回的是一个新的字符串。
    再来看个:

    var person = 'jozo';
    person.age = 22;
    person.method = function(){//...};
    
    console.log(person.age); // undefined
    console.log(person.method); // undefined
    

    通过上面代码可知,我们不能给基本类型添加属性和方法,再次说明基本类型时不可变得;

    2.基本类型的比较是值的比较:

    只有在它们的值相等的时候它们才相等。
    但你可能会这样:

    var a = 1;
    var b = true;
    console.log(a == b);//true
    

    它们不是相等吗?其实这是类型转换和 == 运算符的知识了,也就是说在用==比较两个不同类型的变量时会进行

    一些类型转换。像上面的比较先会把true转换为数字1再和数字1进行比较,结果就是true了。 

    这是当比较的两个值的类型

    不同的时候==运算符会进行类型转换,但是当两个值的类型相同的时候,即使是==也相当于是===。

    var a = 'jozo';
    var b = 'jozo';
    console.log(a === b);//true
    

    3.基本类型的变量是存放在栈区的(栈区指内存里的栈内存)

    假如有以下几个基本类型的变量:

    var name = 'jozo';
    var city = 'guangzhou';
    var age = 22;
    

    那么它的存储结构如下图:

    clipboard.png

    栈区包括了 变量的标识符和变量的值。

    2.引用类型

    引用类型会比较好玩有趣一些。

    javascript中除了上面的基本类型(number,string,boolean,null,undefined)之外就是引用类型了,

    也可以说是就是对象了。

    对象是属性和方法的集合。也就是说引用类型可以拥有属性和方法,属性又可以包含基本类型和引用类型。

    来看看引用类型的一些特性:

    1.引用类型的值是可变的

    我们可为为引用类型添加属性和方法,也可以删除其属性和方法,如:

    var person = {};//创建个控对象 --引用类型
    person.name = 'jozo';
    person.age = 22;
    person.sayName = function(){console.log(person.name);} 
    person.sayName();// 'jozo'
    
    delete person.name; //删除person对象的name属性
    person.sayName(); // undefined
    

    上面代码说明引用类型可以拥有属性和方法,并且是可以动态改变的。

    2.引用类型的值是同时保存在栈内存和堆内存中的对象

    javascript和其他语言不同,其不允许直接访问内存中的位置,也就是说不能直接操作对象的内存空间,

    那我们操作啥呢?

     实际上,是操作对象的引用,所以引用类型的值是按引用访问的。
    准确地说,引用类型的存储需要内存的栈区和堆区(堆区是指内存里的堆内存)共同完成,

    栈区内存保存变量标识符和指向堆内存中该对象的指针,也可以说是该对象在堆内存的地址。
    假如有以下几个对象:

    var person1 = {name:'jozo'};
    var person2 = {name:'xiaom'};
    var person3 = {name:'xiaoq'};
    

    则这三个对象的在内存中保存的情况如下图:

    clipboard.png

    3.引用类型的比较是引用的比较

    var person1 = '{}';
    var person2 = '{}';
    console.log(person1 == person2); // true
    

    上面讲基本类型的比较的时候提到了当两个比较值的类型相同的时候,相当于是用 === ,所以输出是true了。

    再看看:

    var person1 = {};
    var person2 = {};
    console.log(person1 == person2); // false
    

    可能你已经看出破绽了,上面比较的是两个字符串,而下面比较的是两个对象,

    为什么长的一模一样的对象就不相等了呢?

    别忘了,引用类型时按引用访问的,换句话说就是比较两个对象的堆内存中的地址是否相同,

    那很明显,person1和person2在堆内存中地址是不同的:

    clipboard.png

    所以这两个是完全不同的对象,所以返回false;

    3.简单赋值

    在从一个变量向另一个变量赋值基本类型时,会在该变量上创建一个新值,

    然后再把该值复制到为新变量分配的位置上:

    var a = 10;
    var b = a;
    
    a ++ ;
    console.log(a); // 11
    console.log(b); // 10
    

    此时,a中保存的值为 10 ,当使用 a 来初始化 b 时,b 中保存的值也为10,但b中的10与a中的是完全独立的,

    该值只是a中的值的一个副本,此后,这两个变量可以参加任何操作而相互不受影响。

    clipboard.png

    也就是说基本类型在赋值操作后,两个变量是相互不受影响的。

    4.对象引用

    当从一个变量向另一个变量赋值引用类型的值时,

    同样也会将存储在变量中的对象的值复制一份放到为新变量分配的空间中。

    前面讲引用类型的时候提到,保存在变量中的是对象在堆内存中的地址,所以,与简单赋值不同,

    这个值的副本实际上是一个指针,而这个指针指向存储在堆内存的一个对象。那么赋值操作后,

    两个变量都保存了同一个对象地址,则这两个变量指向了同一个对象。因此,改变其中任何一个变量,

    都会相互影响:

    var a = {}; // a保存了一个空对象的实例
    var b = a;  // a和b都指向了这个空对象
    
    a.name = 'jozo';
    console.log(a.name); // 'jozo'
    console.log(b.name); // 'jozo'
    
    b.age = 22;
    console.log(b.age);// 22
    console.log(a.age);// 22
    
    console.log(a == b);// true
    

    它们的关系如下图:

    clipboard.png

    因此,引用类型的赋值其实是对象保存在栈区地址指针的赋值,因此两个变量指向同一个对象,

    任何的操作都会相互影响。

    展开全文
  • js基本类型 引用类型 简单赋值 对象引用,两个等号与三个等号的区别

    ECMAScirpt 变量有两种不同的数据类型:基本类型,引用类型。也有其他的叫法,比如原始类型和对象类型拥有方法的类型和不能拥有方法的类型,还可以分为可变类型和不可变类型,其实这些叫法都是依据这两种的类型特点来命名的,大家爱叫啥就叫啥吧 o(╯□╰)o 。

    1.基本类型

    基本的数据类型有:undefined,boolean,number,string,null.基本类型的访问是按值访问的,就是说你可以操作保存在变量中的实际的值。基本类型有以下几个特点:

    1.基本类型的值是不可变得:

    任何方法都无法改变一个基本类型的值,比如一个字符串:

    var name = 'jozo';
    name.toUpperCase(); // 输出 'JOZO'
    console.log(name); // 输出  'jozo'

    会发现原始的name并未发生改变,而是调用了toUpperCase()方法后返回的是一个新的字符串。 再来看个:

    var person = 'jozo';
    person.age = 22;
    person.method = function(){//...};
    
    console.log(person.age); // undefined
    console.log(person.method); // undefined

    通过上面代码可知,我们不能给基本类型添加属性和方法,再次说明基本类型时不可变得;

    2.基本类型的比较是值的比较:

    只有在它们的值相等的时候它们才相等。 但你可能会这样:

    var a = 1;
    var b = true;
    console.log(a == b);//true

    它们不是相等吗?其实这是类型转换和 ==运算符的知识了,也就是说在用==比较两个不同类型的变量时会进行一些类型转换。像上面的比较先会把true转换为数字1再和数字1进行比较,结果就是true了。 这是当比较的两个值的类型不同的时候==运算符会进行类型转换,但是当两个值的类型相同的时候,即使是==也相当于是===。

    var a = 'jozo';
    var b = 'jozo';
    console.log(a === b);//true

    3.基本类型的变量是存放在栈区的(栈区指内存里的栈内存)

    假如有以下几个基本类型的变量:

    var name = 'jozo';
    var city = 'guangzhou';
    var age = 22;

    那么它的存储结构如下图:

    这里写图片描述

    栈区包括了 变量的标识符和变量的值。

    2.引用类型

    引用类型会比较好玩有趣一些。

    javascript中除了上面的基本类型(number,string,boolean,null,undefined)之外就是引用类型了,也可以说是就是对象了。对象是属性和方法的集合。也就是说引用类型可以拥有属性和方法,属性又可以包含基本类型和引用类型。来看看引用类型的一些特性:

    1.引用类型的值是可变的

    我们可为为引用类型添加属性和方法,也可以删除其属性和方法,如:

    var person = {};//创建个控对象 --引用类型
    person.name = 'jozo';
    person.age = 22;
    person.sayName = function(){console.log(person.name);} 
    person.sayName();// 'jozo'
    
    delete person.name; //删除person对象的name属性
    person.sayName(); // undefined

    上面代码说明引用类型可以拥有属性和方法,并且是可以动态改变的。

    2.引用类型的值是同时保存在栈内存和堆内存中的对象

    javascript和其他语言不同,其不允许直接访问内存中的位置,也就是说不能直接操作对象的内存空间,那我们操作啥呢? 实际上,是操作对象的引用,所以引用类型的值是按引用访问的。
    准确地说,引用类型的存储需要内存的栈区和堆区(堆区是指内存里的堆内存)共同完成,栈区内存保存变量标识符和指向堆内存中该对象的指针,也可以说是该对象在堆内存的地址。
    假如有以下几个对象:

    var person1 = {name:'jozo'};
    var person2 = {name:'xiaom'};
    var person3 = {name:'xiaoq'};

    则这三个对象的在内存中保存的情况如下图:

    这里写图片描述

    3.引用类型的比较是引用的比较

    var person1 = '{}';
    var person2 = '{}';
    console.log(person1 == person2); // true

    上面讲基本类型的比较的时候提到了当两个比较值的类型相同的时候,相当于是用 === ,所以输出是true了。再看看:

    var person1 = {};
    var person2 = {};
    console.log(person1 == person2); // false

    可能你已经看出破绽了,上面比较的是两个字符串,而下面比较的是两个对象,为什么长的一模一样的对象就不相等了呢?

    别忘了,引用类型时按引用访问的,换句话说就是比较两个对象的堆内存中的地址是否相同,那很明显,person1和person2在堆内存中地址是不同的:
    这里写图片描述

    所以这两个是完全不同的对象,所以返回false;

    3.简单赋值

    在从一个变量向另一个变量赋值基本类型时,会在该变量上创建一个新值,然后再把该值复制到为新变量分配的位置上:

    var a = 10;
    var b = a;
    
    a ++ ;
    console.log(a); // 11
    console.log(b); // 10

    此时,a中保存的值为 10 ,当使用 a 来初始化 b 时,b 中保存的值也为10,但b中的10与a中的是完全独立的,该值只是a中的值的一个副本,此后,这两个变量可以参加任何操作而相互不受影响。
    这里写图片描述

    也就是说基本类型在赋值操作后,两个变量是相互不受影响的。

    4.对象引用

    当从一个变量向另一个变量赋值引用类型的值时,同样也会将存储在变量中的对象的值复制一份放到为新变量分配的空间中。前面讲引用类型的时候提到,保存在变量中的是对象在堆内存中的地址,所以,与简单赋值不同,这个值的副本实际上是一个指针,而这个指针指向存储在堆内存的一个对象。那么赋值操作后,两个变量都保存了同一个对象地址,则这两个变量指向了同一个对象。因此,改变其中任何一个变量,都会相互影响:

    var a = {}; // a保存了一个空对象的实例
    var b = a;  // a和b都指向了这个空对象
    
    a.name = 'jozo';
    console.log(a.name); // 'jozo'
    console.log(b.name); // 'jozo'
    
    b.age = 22;
    console.log(b.age);// 22
    console.log(a.age);// 22
    
    console.log(a == b);// true

    它们的关系如下图:

    这里写图片描述

    因此,引用类型的赋值其实是对象保存在栈区地址指针的赋值,因此两个变量指向同一个对象,任何的操作都会相互影响。

    5.进一步理解

    function Person(){}
    var p1 = new Person();
    p1.age = 25;
    var p2 = p1;
    p2.age = 51;
    document.write(p1.age); //51,证明是地址传值
    p2 = null;
    document.write(p1.age);  //51,why?

    var p1 = new Person();

    这个表达式做了什么?

    首先 new xxx() 就是在内存中创建了一个 object var p1 = xxx 那个 现在 p1 这个变量保存了
    这个object的地址

    到这里开始 访问 p1 就是访问这个object

    p1.age = 25; 这个 就是 object.age = 25

    var p2 = p1; //这个吧p1 的值 赋予 p2 (因为p1 是指向一个对象的变量 所以 p2 现在 也指向
    这个变量)

    p2.age = 51; 这个就是 object.age = 51

    一直到这里位置 现在内存有一个对象 object(new Person()创建的), 2个变量 p1 p2 都指向 那个 object

    p2 = null; 这里 p2 指向了null 但是p1 还是指向那个 object

    原文:
    [ JS 进阶 ] 基本类型 引用类型 简单赋值 对象引用
    JS将一个对象赋值给另外一个变量,是地址传值吗?

    展开全文
  • Java有 5种引用类型对象类型):类 接口 数组 枚举 标注 引用类型:底层结构和基本类型差别较大 JVM的内存空间: (1). Heap 堆空间:分配对象 new Student() (2). Stack 栈空间:临时变量 Student stu (3)...

    注意,不是JVM中的四种引用类型:强、软、弱、虚引用。
    详见我的另一篇文章《JVM中的四种引用类型》

    Java有 5种引用类型(对象类型):类 接口 数组 枚举 标注

    引用类型:底层结构和基本类型差别较大

    JVM的内存空间:
    (1). Heap 堆空间:分配对象 new Student()
    (2). Stack 栈空间:临时变量 Student stu
    (3).Code 代码区 :类的定义,静态资源 Student.class

    Student stu = new Student(); //new 在内存的堆空间创建对象
    stu.study();                   //把对象的地址赋给stu引用变量
    

    上例实现步骤:
    a.JVM加载Student.class 到Code区
    b.new Student()在堆空间分配空间并创建一个Student实例
    c.将此实例的地址赋值给引用stu, 栈空间

    基本数据类类型存的是数值本身,而引用类型变量在内存放的是数据的引用,并不是数据的本身,引用类型变量是以间接方式去获取数据。引用类型变量都属于对象类型,如:数组、类、字符串等都属于引用类型变量。所以,引用类型变量里面存放的是数据的地址。

    对于 引用变量的比较一般是有两个不同的方法
    1)比较两个变量是不是指向同一个对象,此时,需要比较 a b 中的地址是不是执行同一个值 ,因为此时比较的是 a b 中的地址值,要用 ==
    2)比较 a b 分别对应不同的对象,此时 a b 中的地址 一定是不同的了 ,此时比较的是对象的值 ,因此这里的比较只能用equals

    展开全文
  • JavaScript对象、内置对象、值类型和引用类型详解

    千次阅读 多人点赞 2021-06-13 22:56:28
    对象 JS中的对象是属性和行为的结合体,其中属性是对象的静态特征,行为又称方法,是对象的动态特征。 JavaScript中的对象主要分为三大类: 内置对象 由ES标准中定义的对象 在任何的ES的实现中都可以使用,比如Math...
  •  很多教科书判断对象是否存活的算法是这样的:给对象中添加一个引用计数器,每当有一个地方引用它时,计数器值加1;当引用失效时,计数器减1;任何时刻计数器都为0的对象就是不可能再被使用的。  (1)
  • //接口类型引用变量A 去接收对象地址 or ClassB A=new ClassB();//类类型引用变量A 去接收对象地址 先附上有关接口的相关知识 知乎 Java 中的接口有什么作用? 博客园 深入理解Java的接口和抽象类 我们.....
  • Java中的4种对象引用类型,按照级别从高到低分别为:强引用(StrongReference)、软引用(SoftReference)、弱引用(WeakReference)和虚引用(PlantomReference)
  • Java对象的四种引用类型

    万次阅读 2016-04-03 20:18:27
    参考博客:http://my.oschina.net/Bruce370/blog/511707在JDK 1.2...从JDK 1.2版本开始,把对象引用分为4种级别,从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为:强引用、软引用、弱引用和虚引
  • 先放结论:可以认为Java中的引用就是指针,是一种限制的指针,不能参与整数运行和指向任意位置的内存,并且不用显示回收对象。 作为一名程序员,我们应该对新知识和新技术刨根问底,而不应泛泛而谈。我未曾接触到...
  • 在JAVA 程序中我们往往需要给对象进行赋值操作,但是对于不同数据类型的赋值是有区别的,比如:对基本数据类型的赋值并非指向一个对象引用,所以在为其赋值的时候是直接将一个地方的值复制到另一个地方,所以对于...
  • java中基本数据类型与对象引用类型的默认初始化值学习 8种基本数据类型的所占存储空间大小,最大值,最小值,及两个高精度类型。
  • java基本类型与引用类型

    万次阅读 多人点赞 2018-01-04 17:30:32
    java基本类型与引用类型 目录 java基本类型与引用类型 目录 一基本数据类型 二引用类型 三基本类型与引用类型的区别 默认值 内存分配 自动装箱自动拆箱 自动装箱拆箱带来的问题 程序的性能 空指针异常 ...
  • Java中的对象类型引用还是指针,谁是谁非?作者:海枫地址:http://blog.csdn.net/linyt 作为一名程序员,我们应该对新知识和新技术刨根问底,而不应泛泛而谈。我未曾接触到Java的时候,我想听得最多的东西还是...
  • 对于刚接触不久面向对象的真小白童鞋来说,类的对象对象的实例,对象引用引用变量的问题以及莫过于没得对象虽然博主也没得对象,本文将逐个逐个讲解! 1.何谓对象? 在Java中有一句比较流行的话,叫做“万物皆...
  • 什么是Java的对象引用? Java中都有哪些类型对象引用? Java中提供的Java对象引用主要有什么目的? 通过本文,你就能很清楚得了解Java的对象引用
  • 定义对象的类  面向对象程序设计(OOP)就是使用对象进行程序设计。对象(object)代表现实世界中可以明确标识的一个实体。例如:一个学生、一张桌子、一个圆、一个按钮甚至一笔贷款都可以看做是一个对象,每个...
  • golang中的值类型和引用类型

    千次阅读 2019-08-20 20:48:29
    值类型与引用类型 值类型 值类型:这些类型的变量直接指向存在内存中的值,值类型的变量的值存储在栈中。当使用等号=将一个变量的值赋给另一个变量时,如 j = i ,实际上是在内存中将 i 的值进行了拷贝。可以通过 &...
  • 当我们需要将一个引用类型对象独立出来与原来的引用完全撇清关系时,可以使用这个方法。 /// <summary> /// 克隆一个对象 /// </summary> /// <typeparam name="T"></typeparam> /// <...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,379,764
精华内容 551,905
关键字:

对象类型是引用类型吗