精华内容
下载资源
问答
  • 什么所有对象都是Object实例 首先 我们要知道一个概念,js语法中Object是所有对象(包括函数)爹,instanceof 运算符 A instanceof B 其实就是判断 A.proto 是否指向B.prototype,也就是A.prototype === B....

    为什么所有对象都是Object的实例

    首先 我们要知道一个概念,js语法中Object是所有对象(包括函数)的爹,instanceof 运算符 A instanceof B 其实就是判断 A.proto 是否指向B.prototype,也就是A.prototype === B.prototype,如果相等 返回true,
    换言之,如下代码

    	var Fun = function(){
    	console.log('我是构造函数Fun')
    	}
    	var fun = new Fun()
    	console.log(fun instanceof Fun)//true
     	console.log(fun instanceof Object)//true
     	console.log(Fun instanceof Object)//true
     	cosole.log(Object instanceif Object)//true
    

    我们可以通过画图来解释 为啥都是true 图如下所示
    在这里插入图片描述
    第一: var Fun = function(){
    console.log(‘我是构造函数Fun’)
    }
    var fun = new Fun()
    console.log(fun instanceof Fun)//true
    这一部分中 fun.proto 指向了 Fun.prototype 所以 instanceof返回的true
    第二: console.log(fun instanceof Object)//true
    fun.proto.__proto__指向Object.prototype,也就是说__proto__会一直向下传递,一直找到原型链的尽头,
    第三: console.log(Fun instanceof Object)//true
    这个比较难理解,Fun.proto 指向的Function.prototype Function本身是个函数,函数的prototype是Object对象,Object对象的__proto__指向Object.prototype,所以,
    Fun.proto === Function.prototype, //true
    Function.prototype.proto === Object.prototype,//true
    Fun.proto.proto === Object.prototype//true
    第四 : cosole.log(Object instanceif Object)//true

    这个也和第三个一样 
    Object.__proto === Function.prototype//true
    Object.__proto__.__proto__ === Function.prototype.__proto__ === Object.prototype//true
    

    记住三句话:
    1.所有函数的显示原型(prototype) 就是 引用对象的隐式原型(proto),
    2.所有函数(Object构造函数除外)的显示原型(prototype)就是一个Object类型的对象,
    3.Object类型对象的隐式原型(proto)指向Object构造函数的显示原型(prototype)

    展开全文
  • 3----是不是所有hash有关类,要比较相等要重写hashcode方法??? 4----总结下我问题,其实就是hashmap中 equals() hashcode() == 这三者用处各是什么,哪里用到?????????[/size][/color]
  • Python中字典key可以是什么

    万次阅读 多人点赞 2018-07-24 22:04:07
    所以所有python自带类型中,除了list、dict、set和内部至少带有上述三种类型之一tuple之外,其余对象能当key。 比如数值/字符串/完全不可变元祖/函数(内建或自定义)/类(内建或自定义)/方法/包等等你能拿出...

     答:一个对象能不能作为字典的key,就取决于其有没有__hash__方法。所以所有python自带类型中,除了list、dict、set和内部至少带有上述三种类型之一的tuple之外,其余的对象都能当key。

    比如数值/字符串/完全不可变的元祖/函数(内建或自定义)/类(内建或自定义)/方法/包等等你能拿出手的,不过有的实际意义不高。还有数值型要注意,因为两个不同的相等数字可以有相同的哈希值,比如1和1.0。

    解释:

    代码版本:3.6.3;文档版本:3.6.6

    Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys, which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like append()and extend().

    •  字典的键可以是任意不可变类型,需要注意的是tuple元组作为键时,其中不能以任何方式包含可变对象。

     那。。到底什么样的是不可变类型呢?不可能给对象专门标注一个属性是可变类型还是不可变类型啊,这没有任何其他意义,一定是通过其他途径实现的。把list当做键试一下

    a = [1, 2, 3]
    d = {a: a}
    
    
    # 第二行报错:
    # TypeError: unhashable type: 'list'
    

    报错说list类型是不可哈希的,噢,原来是靠能不能hash来判断的,另外文档下面接着说同一字典中每个键都是唯一的,正好每个对象的哈希值也是唯一的,对应的很好。

    It is best to think of a dictionary as an unordered set of key: value pairs, with the requirement that the keys are unique (within one dictionary).

    查看源代码可以看到object对象是定义了__hash__方法的,

    而list、set和dict都把__hash__赋值为None了

    # 部分源码
    
    class object:
        """ The most base type """
    
        def __hash__(self, *args, **kwargs):  # real signature unknown
            """ Return hash(self). """
            pass
    
    
    class list(object):
        __hash__ = None
    
    
    class set(object):
        __hash__ = None
    
    
    class dict(object):
        __hash__ = None

    那这样的话。。。我给他加一个hash不就能当字典的key了,key不就是可变的了。注意:此处只是我跟着想法随便试,真的应用场景不要用可变类型作为字典的key。

    class MyList(list):
        """比普通的list多一个__hash__方法"""
    
        def __hash__(self):
            # 不能返回hash(self)
            # hash(self)会调用self的本方法,再调用回去,那就没完了(RecursionError)
            # 用的时候要注意实例中至少有一个元素,不然0怎么取(IndexError)
            return hash(self[0])
    
    
    l1 = MyList([1, 2])  # print(l1) -> [1, 2]
    d = {l1: 'Can?'}
    print(d)  # -->  {[1, 2]: 'Can?'}
    l1.append(3)
    print(d)  # {[1, 2, 3]: 'Can?'}
    print(d[l1])  # -->  Can?
    

    到这里就可以肯定的说,一个对象能不能作为字典的key,就取决于其有没有__hash__方法。所以所有python自带类型中,目前我已知的除了list、dict、set和内部带有以上三种类型的tuple之外,其余的对象都能当key。而我们自己定义的类,一般情况下都直接间接的和object有关,都带有__hash__方法。

    另外我想到,既然字典的键是唯一的,而哈希值也是唯一的,这么巧,键的唯一性不会就是用哈希值来确定的吧?我上一个例子中__hash__方法返回的是0号元素的哈希值,那我直接用相同哈希值的对象是不是就能改变那本来不属于它的字典值呢?

    class MyList(list):
        def __hash__(self):
            return hash(self[0])
    
    
    l1 = MyList([1, 2])  # print(l1) -> [1, 2]
    d = {}
    d[l1] = l1
    print(d)  # {[1, 2]: [1, 2]}
    d[1] = 1
    print(d)  # {[1, 2]: [1, 2], 1: 1}

    竟然没有改成功而是新添加了一个键值对,可self[0]就是1啊,哈希值一样啊,怎么会不一样呢?难道要键的值一样才能判断是同一个键吗?重写__eq__方法试一下。

    class MyList(list):
        def __hash__(self):
            return hash(self[0])
    
        def __eq__(self, other):
            return self[0] == other
    
    
    l1 = MyList([1, 2])  # print(l1) -> [1, 2]
    d = {}
    d[l1] = l1
    print(d)  # {[1, 2]: [1, 2]}
    d[1] = 1
    print(d)  # {[1, 2]: 1}

    这回成功了,那就是__hash__返回值相等,且eq判断也相等,才会被认为是同一个键。那这两个先判断哪个呢?加个代码试一下

    class MyList(list):
        def __hash__(self):
            print('hash is run')
            return hash(self[0])
    
        def __eq__(self, other):
            print('eq is run')
            return self[0] == other
    
    
    l1 = MyList([1, 2])  # print(l1) -> [1, 2]
    d = {}
    d[1] = 1
    d[l1] = 'l1'
    print(d)
    
    
    # 结果:
    # hash is run
    # eq is run
    # {1: 'l1'}
    

    __hash__先执行,另外字典在内存中存储数据的位置和键的hash也是有关的,逻辑上也像印证。先计算hash,找到相对应的那片内存空间,里面没有值的话就直接写入,对于字典来说就是新增键值对;如果里面已经有值了,那就判断新来的键和原来的那里的键是不是相等,相等就认为是一个键,对于字典来说就是更新值,不相等就再开空间,相当于字典新增键值对。

    在你验证自己想法的时候可能遇到__hash__和__eq__的一些想不到的麻烦,可以看这里:__hash__和__eq__的继承使用问题

    展开全文
  • 其中就是```$reply[0].username eq $Think.session.username```和判断无法成立,可显示在页面上数据都是一样,而且没有空格什么的,也应该都是字符串格式。 实在是搞不懂了。。取到的所有变量都没问题,而且其他...
  • 1.类每个实例本质上都是唯一,对于代表活动实体而不是值类确实如此,例如Thread.2.不关心类是否提供了“逻辑相等测试功能3.超类已经覆盖了equals,从超类继承过来行为对子类也是合适4.类是私有或者包...

    第八条 在改写equals的时候请遵守通用约定

    一般以下几种情况,不适宜覆盖equals方法
    1.类的每个实例本质上都是唯一的,对于代表活动实体而不是值的类确实如此,例如Thread.

    2.不关心类是否提供了“逻辑相等”的测试功能

    3.超类已经覆盖了equals,从超类继承过来的行为对子类也是合适的

    4.类是私有的或者包级私有的,可以确定它的equals方法永远不会被调用。

    那什么情况应该覆盖Object.equals呢?如果类具有自己特有的“逻辑相等”的概念(不同于对象等同的概念),而且超类没有覆盖equals以实现期望的行为,就需要进行覆盖,这通常属于“值类”的情形,例如Integer和Date。当使用equals来比较对象, 是希望他们在逻辑上是否相等, 而不是指向同一对象, 或者用来作为Map的key以及集合Set中的元素时, 就必须复写equals方法.

    实例受控,确保“每个值最多只存在一个对象”的类,枚举通常属于这种类型。对于枚举类型来说, 逻辑相等与对象相等是同一回事, 因此不需要覆盖equals方法。

    equals的改写规范:
    1)自反性:对于任何非null的引用值x,x.equals(x)一定为true
    2)对称性:对于任何非null的引用值x和y,当且仅当x.dquals(y)为true;那么y.equals(x)也必须为true
    3)传递性:对于任何非null的引用值x和y和z,如果x.equals(y)为true,y.equals(z);那么x.equals(x)也必须为true
    4)一致性:对于任何非null的引用值x和y,如果用于equals比较的对象信息没有被修改的话,那么多次调用x.dquals(y)返回的值是一致的
    5)对于非null引用值x,x.equals(null)一定返回false

    接下来是逐一解析上面几个原则:
    2)对称性

    public final class CaseInsensitiveString {
        private final String s;
    
        public CaseInsensitiveString(String s) {
            if (s == null)
                throw new NullPointerException();
            this.s = s;
        }
    
        // Broken - violates symmetry!
        @Override
        public boolean equals(Object o) {
            if (o instanceof CaseInsensitiveString)
                return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
            if (o instanceof String) // One-way interoperability!
                return s.equalsIgnoreCase((String) o);
            return false;
        }
    
        // This version is correct.
        // @Override public boolean equals(Object o) {
        // return o instanceof CaseInsensitiveString &&
        // ((CaseInsensitiveString) o).s.equalsIgnoreCase(s);
        // }
    
        public static void main(String[] args) {
            CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
            String s = "polish";
            System.out.println(cis.equals(s) + "  " + s.equals(cis));
        }
    }
    

    上面代码中的equals企图和String进行比较操作,假设我们有一个不区分大小的字符串和一个普通的字符串:

      CaseInsensitiveString cis = new CaseInsensitiveString("Test");
            String s = "test";

    此时cis.equals(s)会返回true,CaseInsensitiveString 类中做了兼容大小写的处理,但是String 的equals方法是不知道要不区分大小写1的,所以s.equals(cis)会返回false,违反了自反性

    假如你把CaseInsensitiveString 放到一个集合中

    List<CaseInsensitiveString> list = new ArrayList<>();
            list.add(cis);
            list.contains(s);

    list.contains(s)有可能返回true,也可能是false,甚至会抛出RumtimeException

    为了解决这个问题,只要企图与String互操作的这段代码从equals去掉即可

    @Override
        public boolean equals(Object o) {
            return o instanceof CaseInsensitiveString&&s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
    
        }

    3)传递性:
    首先以一个简单不可变的二维整形Point类作为开始

    展开全文
  • 第1部分 equals() 的作用 equals() 的作用用来判断两个对象是否相等。 equals() 定义在JDK的Object...既然Object.java中定义了equals()方法,这就意味着所有的Java类实现了equals()方法,所有的可以通过equa.

    第1部分 equals() 的作用

    equals() 的作用是 用来判断两个对象是否相等

    equals() 定义在JDK的Object.java中。通过判断两个对象的地址是否相等(即,是否是同一个对象)来区分它们是否相等。源码如下:

    public boolean equals(Object obj) {
        return (this == obj);
    }

    既然Object.java中定义了equals()方法,这就意味着所有的Java类都实现了equals()方法,所有的类都可以通过equals()去比较两个对象是否相等。 但是,我们已经说过,使用默认的“equals()”方法,等价于“==”方法。因此,我们通常会重写equals()方法:若两个对象的内容相等,则equals()方法返回true;否则,返回fasle。  

    下面根据“类是否覆盖equals()方法”,将它分为2类。
    (01) 若某个类没有覆盖equals()方法,当它的通过equals()比较两个对象时,实际上是比较两个对象是不是同一个对象。这时,等价于通过“==”去比较这两个对象。
    (02) 我们可以覆盖类的equals()方法,来让equals()通过其它方式比较两个对象是否相等。通常的做法是:若两个对象的内容相等,则equals()方法返回true;否则,返回fasle。

    假设,String a = new String ("abc"); 

               String b = new String ("abc");   如果我们使用没有覆盖过的方法,那么相当于== ,也就说他们比较的是 他们的内存地址,那么明显不一样。但是我们实际上要做的是比较它们的值。所以要使用覆盖过的方法。

    展开全文
  • 1、equals()方法用来比较的是两个对象的内容是否相等,由于所有的都是继承自java.lang.Object类的,所以适用于所有对象,如果没有对该方法进行覆盖的话,调用的仍然是Object类中的方法,而Object中的equals方法...
  • 第三章 对所有对象都通用方法8、 覆盖equals时请遵守通用约定在什么情况下可以不覆盖equals方法,这些情况下,类每个实例只与自身相等: 类每个实例本质上都是唯一。 不关心类是否提供了“逻辑相等测试...
  • 所有对象通用的方法也一般指的Object类里的方法,包含equals,...首先我们需要知道什么时候要覆盖equals,一些人可能认为可以用==代替equals,但是==比较两个对象的地址是否相等的。而当类需要具有自己...
  • 什么是==? 等于比较运算符。...但是我们知道所有的继承Object,而且Object中的equals()方法没有使用final关键字修饰,那么当我们使用equal()方法进行比较的时候,我们需要关注的就是这个类有没有重写Object中的
  • 类没有必要提供“逻辑相等测试功能。 超类已经覆盖了equals,超类行为对于这个类也合适。 类私有,或者包级私有,可以确定它equals方法永远不会被调用。 Equals方法实现了等价关系,其属性如下...
  • String类型如何判断相等

    千次阅读 2019-04-29 23:01:59
    String类型如何判断相等,String类型为什么不能使用==,String为什么要使用equals方法。 一般情况下,我们使用的都是基本数据类型,所以可以使用==直接判断,但...不要以为所有的String类型都是这样,因为绝大数的...
  • BTree,B-Tree,B+Tree,B*Tree都是什么

    千次阅读 2010-06-09 14:13:00
    B树、B-树、B+树、B*树都是什么B树 即二叉搜索树:  1.所有非叶子结点至多拥有两个儿子(Left和Right);  2.所有结点存储一个关键字;  3.非叶子结点左指针指向小于其关键字子树,右指针指向大于其关键字...
  • 文章目录第八条:覆盖equals时请遵守通用约定 第八条:覆盖equals时请遵守通用约定 Object类中默认equals如下: public boolean equals(Object obj) { return (this == obj);...类每个实例本质上都是...
  • B树、B-树、B+树、B*树都是什么B树 即二叉搜索树:  1.所有非叶子结点至多拥有两个儿子(Left和Right);  2.所有结点存储一个关键字;  3.非叶子结点左指针指向小于其关键字子树,右指针指向大于其...
  • 图形变换三种方式1、平移平移,指在同一平面内,将一个图形上的所有按照某个直线方向做相同距离移动,这样图形运动叫做图形平移运动,简称平移。平移不改变图形形状和大小。图形经过平移,对应线段...
  • 知识点: 1.hashCode规范 2.为什么要覆盖hashCode 3.hashCode写法 4.Java类库中hashCode方法 1.hashCode规范 a.应用程序执行时候,如果equals方法比较操作...如果对象equals相等,hashCode也必须相等
  • 每个实例本质上都是唯一。 类不需要提供一个”逻辑相等(logical equality)”测试功能。 父类已经重写了 equals 方法,并且父类行为完全适合于该子类。 类是私有或包级私有,并且可以确定它 ...
  • 变量唯一性通过按位比较进行,所有基本类型唯一性判定都是通过这种方式进行。两个Object类型变量相等当且仅当保存位模式相同,这和比较两个int没什么不同。一个隐含前提是托管堆中...
  • 图形变换三种方式1、平移平移,指在同一平面内,将一个图形上的所有按照某个直线方向做相同距离移动,这样图形运动叫做图形平移运动,简称平移。平移不改变图形形状和大小。图形经过平移,对应线段...
  • 实例本质上都是唯一。 不关心类是否提供了"逻辑相等"测试功能。例如java.util.Random就不需要复写equals 超类已经覆盖了equals,从超类继承过来行为对于子类也是合适。 类是私有或是包级私有,可以...
  • 因为值类型默认的相等性比较会使用装箱和反射,所以性能很差根据业务需求,其实际相等意义和默认比较结果可能会不同,但是这种情况可能不较少所以建议所有供外部使用struct实现相等性。 实现步骤重写...
  • 因为值类型默认的相等性比较会使用装箱和反射,所以性能很差根据业务需求,其实际相等意义和默认比较结果可能会不同,但是这种情况可能不较少所以建议所有供外部使用struct实现相等性。 实现步骤重写...
  • 如果类具有自己特有“逻辑相等”概念(不同于对象等同概念),而且超类还没有覆盖equals以实现期望行为,这时就需要覆盖equals方法。(“值类”,仅仅表示一个值类,例如:Integer或者Date) ==与equals...
  • 什么是Object

    2017-03-22 10:26:25
    Object:所有类的直接或者间接父类,Java认为所有的对象具备一些基本的共性内容,这些内容可以不断的向上抽取,最终就抽取到了一个最顶层的类中的,该类中定义的就是所有对象具备的功能。 具体方法: 1,...
  • 语言定义中说明, 每一种指针类型有一个特殊值---``空指针"--- 它与同类型其它所有指针值不相同, 它``与任何对象或函数指针值相等"。也就是说, 取地址操作符&永远也不能得到空指针, 同样对malloc()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 509
精华内容 203
关键字:

所有的什么都是相等的