天道酬勤,学无止境

comparable和comparator区别

相同点:
1.comparable和comparator都是用来实现treeset等根据类的自然排序进行排序的集合容器中元素之间的比较,比较算法都是由比较器自己规定
不同点:
1.comparable是让集合元素自身具备比较性,让元素实现comparable接口,覆盖comparaeTo(T o)方法
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。
2.comparator是让集合具备比较性,在集合初始化时就有了比较放松,定义一个类,实现compare(T o1,T o2)方法
比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
将此类的对象作为参数传给treeset等根据类的自然排序进行排序的集合容器的构造函数
举例子:让人根据年龄排序,如果年龄一样根据姓名的自然顺序排序
通过comparable方式

import java.util.Iterator;
import java.util.TreeSet;

/**
 * @author WangShuang
 *
 */
public class Demo {
    public static void main(String[] args) {
        Person p0 = new Person("张三",3);
        Person p = new Person("张三",1);
        Person p1 = new Person("张三",2);
        Person p2 = new Person("张四",2);
        Person p3 = new Person("张四",2);

        TreeSet<Person> treeSet=new TreeSet<Person>();
        treeSet.add(p0);
        treeSet.add(p);
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);

        Iterator<Person> iterator = treeSet.iterator();
        while(iterator.hasNext()){
            Person next = iterator.next();
            System.out.println(next);
        }
    }
}
class Person implements Comparable<Person>{//该接口强制让人具有比较性
    private String name;
    private int age;
    public Person(String name,int age) {
        this.name = name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Person o) {
        if(this.age>o.age){
            return 1;
        }else if(this.age<o.age){
            return -1;
        }else{
            return this.name.compareTo(o.name);
        }
    }
    @Override
    public String toString() {
        return "Person [name=" + name +  ", age=" + age + "]";
    }
}

通过comparator方式

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 *  
 * @author WangShuang
 *
 */
public class Demo {
    public static void main(String[] args) {
        Person p0 = new Person("张三",3);
        Person p = new Person("张三",1);
        Person p1 = new Person("张三",2);
        Person p2 = new Person("张四",2);
        Person p3 = new Person("张四",2);

        TreeSet<Person> treeSet=new TreeSet<>(new Com());
        treeSet.add(p0);
        treeSet.add(p);
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);

        Iterator<Person> iterator = treeSet.iterator();
        while(iterator.hasNext()){
            Person next = iterator.next();
            System.out.println(next);
        }
    }
}
class Com implements Comparator<Person>{//该接口强制让集合具有比较性
    @Override
    public int compare(Person o1, Person o2) {
        if(o1.getAge()>o2.getAge()){
            return 1;
        }else if(o1.getAge()<o2.getAge()){
            return -1;
        }else{
            return o1.getName().compareTo(o2.getName());
        }
    }
}

class Person{
    private String name;
    private int age;
    public Person(String name,int age) {
        this.name = name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name +  ", age=" + age + "]";
    }
}

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • java中Comparable和Comparator的区别
    文章目录简介ComparableComparator举个例子 java中Comparable和Comparator的区别简介java.lang.Comparable和java.util.Comparator是两个容易混淆的接口,两者都带有比较的意思,那么两个接口到底有什么区别,分别在什么情况下使用呢?ComparableComparable是java.lang包下面的接口,lang包下面可以看做是java的基础语言接口。实际上Comparable接口只定义了一个方法: public int compareTo(T o);实现这个接口的类都需要实现compareTo方法,表示两个类之间的比较。这个比较排序之后的order,按照java的说法叫做natural ordering。这个order用在一些可排序的集合比如:SortedSet,SortedMap等等。当使用这些可排序的集合添加相应的对象时,就会调用compareTo方法来进行natural ordering的排序。几乎所有的数字类型对象:Integer, Long,Double等都实现了这个Comparable接口。ComparatorComparator是一个FunctionalInterface,需要实现compare方法:int compare(T o1, T o2);Comparator在java.util包中
  • compare()和compareTo()有什么区别?(What is the difference between compare() and compareTo()?)
    问题 Java的compare()和compareTo()方法有什么区别? 这些方法是否给出相同的答案? 回答1 从JavaNotes: a.compareTo(b) : 可比接口:比较值并返回一个整数,该整数告诉值比较的是小于,等于还是大于。 如果您的类对象具有自然顺序,请实现Comparable<T>接口并定义此方法。 具有自然顺序实现的所有Java类都实现Comparable<T> -示例: String ,包装器类, BigInteger compare(a, b) : 比较器界面:比较两个对象的值。 这是作为Comparator<T>接口的一部分实现的,通常的用途是定义一个或多个实现此功能的小型实用程序类,以传递给诸如sort()方法,或者通过对诸如TreeMap和TreeSet 。 您可能想要为以下对象创建一个Comparator对象: 多重比较。 提供几种不同的方式对事物进行排序。 例如,您可能想按名称,ID,年龄,身高……对Person类进行排序。您将为每个这些类定义一个Comparator,以传递给sort()方法。 系统类为您无法控制的类提供比较方法。 例如,您可以为字符串定义一个比较器,以按长度比较它们。 策略模式实施策略模式,在这种情况下,您希望将算法表示为对象,可以将其作为参数传递,保存在数据结构中,等等。 如果您的类对象具有自然排序顺序
  • 常考集合面试题-辅助工具(五)
    文章目录其他文章地址一、辅助工具类1、Array 和 ArrayList 有何区别?2、如何实现 Array 和 List 之间的转换?3、comparable 和 comparator的区别?4、Collection 和 Collections 有什么区别?5、TreeMap 和 TreeSet 在排序时如何比较元素?6、Collections 工具类中的 sort()方法如何比较元素?其他文章地址常考集合面试题(一)常考集合面试题-List接口(二)常考集合面试题之Set-Queue(三)常考集合面试题之Map(四)常考集合面试题-辅助工具(五)一、辅助工具类1、Array 和 ArrayList 有何区别?Array 可以存储基本数据类型和对象,ArrayList 只能存储对象。Array 是指定固定大小的,而 ArrayList 大小是自动扩展的。Array 内置方法没有 ArrayList 多,比如 addAll、removeAll、iteration 等方法只有 ArrayList 有。对于基本类型数据,集合使用自动装箱来减少编码工作量。但是,当处理固定大小的基本数据类型的时候,这种方式相对比较慢。2、如何实现 Array 和 List 之间的转换?Array 转 List: Arrays. asList(array) ;List 转 Array:List 的
  • Comparable 和 Comparator区别小结
    什么叫成熟,你妈没喊你,你就穿上秋裤了。什么叫青春,你妈一天念叨三回,你还是不穿秋裤— —所以到底秋裤是什么,秋装校服裤吗? 一、Comparable小结 Comparable是排序接口。若一个类实现了Comparable接口,就意味着该类支持排序。 实现了Comparable接口的类的对象的集合或数组,可以通过Collections.sort或Arrays.sort进行自动排序。 下面来举个栗子: 关于CompareTo()方法,如果返回的是this.age-s.age,则为升序排序;如果返回的是s.age-this.age,则为降序排序 public class Student implements Comparable<Student>{ private String name; private int age; public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age)
  • C ++字符串==和compare()之间的区别?(Differences between C++ string == and compare()?)
    问题 我刚刚阅读了有关使用的一些建议 std::string s = get_string(); std::string t = another_string(); if( !s.compare(t) ) { 代替 if( s == t ) { 我几乎总是使用最后一个,因为我已经习惯了它,并且感觉自然,可读性强。 我什至不知道有一个单独的比较功能。 更精确地说,我认为==会调用compare()。 有什么区别? 在哪种情况下应该偏爱另一种方式? 我只考虑需要知道一个字符串是否与另一个字符串相同的情况。 回答1 这是标准对operator== 21.4.8.2运算符== template<class charT, class traits, class Allocator> bool operator==(const basic_string<charT,traits,Allocator>& lhs, const basic_string<charT,traits,Allocator>& rhs) noexcept; 返回:lhs.compare(rhs)== 0。 似乎没有太大的区别! 回答2 std :: string :: compare()返回一个int : 如果s和t相等,则等于零, 如果s小于t ,则小于零, 如果s大于t则大于零。
  • Java基础易错面试题,初级程序员面试必看!(会不断更新)
    写在前面: 我是「扬帆向海」,这个昵称来源于我的名字以及女朋友的名字。我热爱技术、热爱开源、热爱编程。技术是开源的、知识是共享的。 这博客是对自己学习的一点点总结及记录,如果您对 Java、算法 感兴趣,可以关注我的动态,我们一起学习。 用知识改变命运,让我们的家人过上更好的生活。 相关文章: 20道你必须要背会的微服务面试题 文章目录 1、& 和 && 的区别2、重载和重写的区别3、== 和 equals 的区别4、final、finally、finalize 的区别5、接口和抽象类6、error 和exception 的区别7、throw 和 throws 的区别8、String 、StringBuilder 、StringBuffer 的区别9、ArrayList 和Linkedlist 区别10、Comparable 和 Comparator 的区别11、equals 和 hashcode 的区别 1、& 和 && 的区别 &:按位与,不管左边是true或false,右边都进行运算,不会短路; &&:逻辑与,如果左边为true,右边参与运算,如果左边为false,那么右边不参与运算,具有短路的功能 。 2、重载和重写的区别 重载:同一个类中的方法名相同而参数列表不同,与方法的修饰符、返回值类型没有关系 重写:需要遵循“两同两小一大”的原则。 两同:子类重写的方法 必须
  • 一个类何时应该是可比较的和/或可比较的?(When should a class be Comparable and/or Comparator?)
    问题 我已经看到了同时实现Comparable和Comparator的类。 这是什么意思? 为什么我要一个使用另一个? 回答1 下面的文字来自Comparator vs Comparable 可比 可比较的对象能够将自己与另一个对象进行比较。 该类本身必须实现java.lang.Comparable接口,以便能够比较其实例。 比较器 比较器对象能够比较两个不同的对象。 该类不是在比较其实例,而是在比较其他一些类的实例。 此比较器类必须实现java.util.Comparator接口。 回答2 实现Comparable意味着“我可以将自己与另一个对象进行比较。 ”当存在单个自然默认比较时,这通常很有用。 实现Comparator意思是“我可以比较两个其他对象。 ”当有多种方式比较一个类型的两个实例时,这通常非常有用-例如,您可以按年龄,姓名等比较人员。 回答3 Comparable让一个类实现自己的比较: 在同一个班级(通常是一个优势) 只能有一个实现(因此,如果需要两种不同的情况,则不能使用该实现) 相比之下,比较器是一个外部比较: 它通常在唯一的实例中(在同一个类中或在另一个地方) 您可以使用对事物进行排序的方式来命名每个实现您可以为您无法控制的类提供比较器即使第一个对象为null,该实现也是可用的 在这两种实现中,您仍然可以选择要比较的内容。 使用泛型,您可以声明为如此
  • Hadoop中的排序比较器和组比较器有什么区别?(What are the differences between Sort Comparator and Group Comparator in Hadoop?)
    问题 Hadoop中的排序比较器和组比较器有什么区别? 回答1 要了解GroupComparator ,请参阅我对这个问题的回答- hadoop map reduce中分组比较器的用途是什么 SortComparator :用于定义如何对地图输出键进行排序 Hadoop-权威指南摘录: 密钥的排序顺序如下: 如果显式或通过在Job上调用setSortComparatorClass()设置了属性mapred.output.key.comparator.class ,则将使用该类的实例。 (在旧的API中,等效方法是JobConf上的setOutputKeyComparatorClass() 。) 否则,键必须是WritableComparable的子类,并使用键类的已注册比较器。 如果没有注册的比较器,则使用RawComparator将要比较的字节流反序列化为对象,然后将其委托给WritableComparable的compareTo()方法。 在一个衬套中使用SortComparator与GroupComparator: SortComparator决定如何对地图输出键进行排序,而GroupComparator决定Reducer中的哪些地图输出键进入相同的reduce方法调用。 回答2 Group Comparator决定将哪些映射输出键组合(分组)为一个键,当然
  • lambda和方法引用在运行时级别之间有什么区别?(What is the difference between a lambda and a method reference at a runtime level?)
    问题 我遇到了使用方法引用而不是lambda发生的问题。 该代码如下: (Comparator<ObjectNode> & Serializable) SOME_COMPARATOR::compare 或者,用lambda, (Comparator<ObjectNode> & Serializable) (a, b) -> SOME_COMPARATOR.compare(a, b) 从语义上讲,它是严格相同的,但实际上与第一种情况不同,在一个Java序列化类中,我得到了一个例外。 我的问题不是关于此异常的,因为实际的代码正在更复杂的上下文中运行,事实证明序列化具有奇怪的行为,因此如果我提供更多详细信息,这将使回答变得太困难。 我想了解的是这两种创建Lambda表达式的方式之间的区别。 回答1 入门 为了对此进行调查,我们从以下类开始: import java.io.Serializable; import java.util.Comparator; public final class Generic { // Bad implementation, only used as an example. public static final Comparator<Integer> COMPARATOR = (a, b) -> (a > b) ? 1 : -1; public
  • java compare compareTo方法区别
    1,compareTo(Object o)方法是java.lang.Comparable<T>接口中的方法,当需要对某个类的对象进行排序时,该类需要实现Comparable<T>接口的,必须重写public int compareTo (T o)方法,比如MapReduce中Map函数和Reduce函数处理的<key,value>,其中需要根据key对键值对进行排序,所以,key实现了WritableComparable<T>接口,实现这个接口可同时用于序列化和反序列化。WritableComparable<T>接口(用于序列化和反序列化)是Writable接口和Comparable<T>接口的组合; 2,compare(Object o1,Object o2)方法是java.util.Comparator<T>接口的方法,它实际上用的是待比较对象的compareTo(Object o)方法。 下面我们写一来看看上面两个方法是怎么用的: 首先,写一个User类,代码如下: public class User implements Comparable<Object>{ int id; String name; public User(int id,String name){ this.id = id; this.name = name; } /* * Getters and
  • compare()和compareTo()区别
    compareTo a.compareTo(b):将此对象与指定的对象进行比较以进行排序。 Comparable接口:比较值并返回一个int,它告诉值是否比较小于,等于或大于。 如果您的类对象具有自然顺序,请实现该Comparable<T>接口并定义此方法。所有具有自然排序实现的Java类Comparable<T>- 示例:String,包装类,BigInteger compare compare(a, b):比较其两个参数的顺序。 比较器接口: 比较两个对象的值。这被实现为的一部分Comparator<T>界面,并且典型的使用是定义实现此的一个或多个小工具类,传递给方法,例如sort()或使用通过排序数据结构,例如TreeMap和TreeSet。您可能希望为以下内容创建Comparator对象: 两个标红的字段说明一个对象排序,一个是对传的参数进行排序。 compareTo和equal 在Java中我们常使用Comparable接口来实现排序,其中compareTo是实现该接口方法。我们知道compareTo返回0表示两个对象相等,返回正数表示大于,返回负数表示小于。同时我们也知道equals也可以判断两个对象是否相等。 下面的例子用age比较排序,用name比较是否相等 public class Student implements Comparable<Student> {
  • compareto方法_compare方法和compareTo方法区别
    字符串数组sort方法是默认按照字典顺序排序 对象数组 按照对象的某字段排序可以用compare和compareTo两种方法 对对象数组排序: 1.compare 方法得用一个单独继承java.util.comparator接口的类(并不是数组元素的类)进行重载,在方法里面写入比较特定字段的差值(比较条件)并返回,然后在创建一个继承comparator接口的类实例(比较器),用数组的sort方法按照特定字段进行默认升序 调用方式 :Arrays.sort(对象数组,比较器); (对象数组按照继承comparable接口的类中compare方法设置的比较条件排序) 例: 运行结果: 2.compareTo方法在继承Java.lang.Comparable接口的类(数组元素的类)中进行重载,在方法里面写入比较条件并返回,然后直接调用数组的sort方法按照特定字段进行默认升序 调用方式:Arrays.sort(对象数组); (对象数组按照比较器的比较条件进行排序) 例: 运行结果: 来源:https://blog.csdn.net/weixin_42349787/article/details/113052299
  • Java:可比vs比较器(Java : Comparable vs Comparator [duplicate])
    问题 这个问题已经在这里有了答案: 十年前关闭。 可能的重复项: compare()和compareTo()之间的区别 Java:实现Comparable和Comparator有什么区别? Comparable和Comparator之间的主要区别是什么。 在什么情况下,哪个比另一个优先? 谢谢 更新-很好的例子! http://www.digizol.com/2008/07/java-sorting-comparator-vs-comparable.html 回答1 当您的类实现Comparable时,该类的compareTo方法将定义该对象的“自然”顺序。 根据合同,该方法有义务(尽管不要求)与该对象上的其他方法保持一致,例如,当.equals()比较返回true时,应始终为该对象返回0。 比较器是它自己如何比较两个对象的定义,可用于以不符合自然顺序的方式比较对象。 例如,字符串通常按字母顺序进行比较。 因此, "a".compareTo("b")将使用字母比较。 如果要比较字符串的长度,则需要编写一个自定义比较器。 简而言之,没有太大的区别。 它们都是相似手段的目的。 在一般情况下,可实现与自然顺序可比的(自然顺序定义显然易于解释),并为其他排序或比较需求编写比较器。 回答2 Comparator为您提供了一种为您无法控制的类型提供自定义比较逻辑的方法。
  • 如何在github中的同一分支上比较两个不同的提交?(How to compare two different commits on the same branch in github?)
    问题 在同一个分支上比较历史对我来说在GitHub上非常令人困惑。 我经常为此苦苦挣扎: 如果我在GitHub存储库名称后面的URL中使用compare/master ,则可以根据下拉菜单中的选项与存储库中的其他分支进行比较。 https://help.github.com/en/articles/comparing-commits-across-time 但是,我通常要比较master上的几个提交。 如何轻松做到这一点? 我可以举一个更清晰的例子吗? 回答1 您可以使用以下URL结构来比较同一分支中的提交: github.com/<username>/<repo_name>/compare/<commit1>...<commit2> 替换username , repo_name , commit1和commit2 acc的值。 到您的项目。 两次提交之间的分隔符是...即3 dots 。 回答2 您可以使用Github Compare UI,它将为您生成URL。 用您的值替换ORG和REPO 。 UI仅列出分支,但是您也可以键入任何有效的Tag(例如v1.0.0 )或Commit ID(例如1a2b3c )。 https://github.com/ORG/REPO/compare/ 生成的URL就是这种格式。 您也可以使用REF手动编辑URL。 https://github
  • Collections.sort(list)和list.sort(Comparator)之间的区别(Difference between Collections.sort(list) and list.sort(Comparator))
    问题 有什么理由让我更喜欢Collections.sort(list)方法而不是简单地调用list.sort()吗? 无论如何,内部Collections.sort只是调用List类的sort方法。 几乎每个人都告诉我使用Collections.sort真是令人惊讶。 为什么? 回答1 您要引用的方法List.sort(comparator)是在Java 8中引入的,而实用程序方法Collections.sort从Java 1.2开始就已经存在。 这样,您会在Internet上找到很多提及该实用程序方法的参考,但这仅仅是因为它在JDK中已经存在了很长时间。 请注意, Collections.sort实现更改是在8u20中进行的。 回答2 这只是对API的更改。 对于像Java这样广泛采用的语言,通常会发生一段时间,而较旧的方法最好保留旧版支持。 在这段时间之后,较旧的API就会被弃用(或者可能不会,这两个API都可以无限期地保留在原处)。 在这段时间内,可能会对新API进行改进,使其功能与原始实现略有不同,从而鼓励开发人员采用它。 新API的要求/结果可能会略有不同,并且实现方式可能会发生巨大变化。 然后,最终,新的API接管了,不再需要和删除旧的API。 在像Java这样被广泛采用的语言中,这可能需要数年甚至数十年的时间。 开发人员可以有一个删除API的计划
  • 面试汇总——JavaSE——面向对象(二)
    根据牛客网的面试经验的题进行的汇总,里面的内容是看别人的博客或者其东西进行汇总的,将这些的知识总结一下,方便自己查看和复习用 牛客网 文章目录 面向对象(二)抽象类请你讲讲abstract class和interface有什么区别?接口和抽象类的区别是什么? JAVA多态请说明Overload和Override的区别,Overloaded的方法是否可以改变返回值的类型? final, finally, finalize请说明一下final, finally, finalize的区别。 JAVA特征请说明面向对象的特征有哪些方面 comparable接口请说明Comparable和Comparator接口的作用以及它们的区别。 JAVA多继承请说明Java是否支持多继承? 类请你谈谈如何通过反射创建对象? static变量请你说明是否可以在static环境中访问非static变量? JAVA泛型请解释一下extends 和super 泛型限定符请你讲讲什么是泛型? 面向对象(二) 抽象类 请你讲讲abstract class和interface有什么区别? 抽象类 有实现的方法体单继承由子类实现其抽象方法,如果不实现,也会变成抽象类 接口 没有实现的方法体可以实现多个接口成员默认修饰public static finalinstanceof 运算符可以用来决定某对象的类是否实现了接口
  • hashMap和treeMap区别
    hashMap和treeMap区别 参考网址: https://mp.weixin.qq.com/s/tHaw9w8h8buyjRx21XzB8g 提出问题 如何决定使用 HashMap 还是 TreeMap? hashMap和treeMap简介 TreeMap<K,V>的Key值是要求实现java.lang.Comparable,所以迭代的时候TreeMap默认是按照Key值升序排序的;TreeMap的实现是基于红黑树结构。适用于按自然顺序或自定义顺序遍历键(key)。 HashMap<K,V>的Key值实现散列hashCode(),分布是散列的、均匀的,不支持排序;数据结构主要是桶(数组),链表或红黑树。适用于在Map中插入、删除和定位元素。 HashMap 和 TreeMap 的实现 **HashMap:**基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()],为了优化HashMap空间的使用,您可以调优初始容量和负载因子。 HashMap(): 构建一个空的哈希映像HashMap(Map m): 构建一个哈希映像,并且添加映像m的所有映射HashMap(int initialCapacity): 构建一个拥有特定容量的空的哈希映像HashMap(int
  • Java中Comparable与Comparator的区别
    一、概述Comparable和Comparator都是用来实现集合中元素的比较、排序的。Comparable是在集合内部定义的方法实现的排序,位于java.lang下。Comparator是在集合外部实现的排序,位于java.util下。Comparable是一个对象本身就已经支持自比较所需要实现的接口,如String、Integer自己就实现了Comparable接口,可完成比较大小操作。自定义类要在加入list容器中后能够排序,也可以实现Comparable接口,在用Collections类的sort方法排序时若不指定Comparator,那就以自然顺序排序。所谓自然顺序就是实现Comparable接口设定的排序方式。Comparator是一个专用的比较器,当这个对象不支持自比较或者自比较函数不能满足要求时,可写一个比较器来完成两个对象之间大小的比较。Comparator体现了一种策略模式(strategy design pattern),就是不改变对象自身,而用一个策略对象(strategy object)来改变它的行为。总而言之Comparable是自已完成比较,Comparator是外部程序实现比较。以上部分是转载至:http://blog.csdn.net/woshixuye/article/details/22326981
  • 安全比较和简单==(=)有什么区别(What's the difference between a secure compare and a simple ==(=))
    问题 Github的安全webhooks页面说: 不建议使用普通==运算符。 诸如secure_compare类的方法执行“恒定时间”字符串比较,从而使其免受某些针对常规相等运算符的定时攻击的影响。 比较密码时bcrypt.compare('string', 'computed hash')我使用bcrypt.compare('string', 'computed hash') 。 是什么使它成为“安全比较”,我可以使用Node中的标准crypto库来做到这一点吗? 回答1 “恒定时间”字符串比较的意义在于,无论比较目标是什么(未知值),该比较将花费完全相同的时间量。 此“恒定时间”不会向攻击者显示有关未知目标值可能是什么的信息。 通常的解决方案是比较所有字符,即使在发现不匹配之后也是如此,因此无论在哪里发现不匹配,比较都将在相同的时间内运行。 当某些条件为真时,其他形式的比较可能会在较短的时间内返回答案,这使攻击者可以了解它们可能会丢失的内容。 例如,在典型的字符串比较中,一旦发现不相等的字符,该比较将返回false。 如果第一个字符不匹配,则比返回的时间短。 勤奋的攻击者可以使用此信息进行更聪明的暴力攻击。 “恒定时间”比较消除了这些额外的信息,因为无论两个字符串如何不相等,该函数都会在相同的时间内返回其值。 在查看nodejs v4加密库时
  • Python 2如何比较string和int? 为什么列表比较的结果大于数字,而元组的结果大于列表?(How does Python 2 compare string and int? Why do lists compare as greater than numbers, and tuples greater than lists?)
    问题 以下代码段带有输出注释(如ideone.com所示): print "100" < "2" # True print "5" > "9" # False print "100" < 2 # False print 100 < "2" # True print 5 > "9" # False print "5" > 9 # True print [] > float('inf') # True print () > [] # True 有人可以解释为什么这样的输出吗? 实施细节 语言规范规定了这种行为,还是由实施者决定? 任何主要的Python实现之间都有区别吗? Python语言的版本之间有区别吗? 回答1 从python 2手册: CPython实现细节:除数字外,其他类型的对象按其类型名称排序; 不支持正确比较的相同类型的对象按其地址排序。 当您对两个字符串或两个数字类型进行排序时,将以预期的方式进行排序(字符串的字典顺序,整数的数字顺序)。 订购数字类型和非数字类型时,数字类型优先。 >>> 5 < 'foo' True >>> 5 < (1, 2) True >>> 5 < {} True >>> 5 < [1, 2] True 当您订购两种都不兼容的不兼容类型时,它们都不是数字,它们按其名称的字母顺序排序: >>> [1, 2] > 'foo' # 'list' <