Comparable和Comparator比较

合集下载

总结几种比较器的特点及应用

比较器是一种用于比较两个对象大小关系的工具。

在实际应用中，比较器广泛用于排序算法、集合的排序操作以及优先级队列等场景中。

本文将深入探讨几种常见的比较器，包括Comparator接口、Comparable接口、Collator类和String.CASE_INSENSITIVE_ORDER比较器，并介绍它们的特点及应用。

一、Comparator接口1.1 特点Comparator接口是Java集合框架中定义的一个用于比较对象的接口，它提供了两个方法：compare和equals。

其中，compare方法用于比较两个对象的大小关系，equals方法用于判断两个对象是否相等。

通过实现Comparator接口，我们可以根据自定义的比较规则对对象进行比较。

1.2 应用Comparator接口广泛应用于集合框架中的排序操作。

在集合类中，比如ArrayList、TreeSet等，如果需要对元素进行排序，可以通过传入自定义的Comparator对象来实现。

在实际开发中，我们可以根据不同的业务需求，实现不同的Comparator对象，来实现灵活的排序操作。

下面是一个示例代码，演示了如何使用Comparator接口对一个对象列表进行排序：List<Person> personList = new ArrayList<>();personList.add(new Person("Alice", 25));personList.add(new Person("Bob", 30));personList.add(new Person("Cathy", 20));Collections.sort(personList, new Comparator<Person>() {@Overridepublic int compare(Person p1, Person p2) {return p1.getAge() - p2.getAge();}});在上述代码中，我们自定义了一个Comparator对象，根据Person对象的年龄进行比较。

Comparable和Comparator的区别

Comparable和Comparator的区别parable和Comparator都是⽤于⽐较数据的⼤⼩的，实现Comparable接⼝需要重写compareTo⽅法，实现Comparator接⼝需要重写compare⽅法，这两个⽅法的返回值都是int，⽤int类型的值来确定⽐较结果，在Collections⼯具类中有⼀个排序⽅法sort，此⽅法可以之传⼀个集合，另⼀个重载版本是传⼊集合和⽐较器，前者默认使⽤的就是Comparable中的compareTo⽅法，后者使⽤的便是我们传⼊的⽐较器Comparator，java的很多类已经实现了Comparable接⼝，⽐如说String，Integer等类，⽽我们其实也是基于这些实现了Comparator或者Comparab接⼝的原⽣类来⽐较我们⾃⼰的类，⽐如说⾃定义⼀个类User，属性有name和age，俩个user之间的⽐较⽆⾮就是⽐较name和age的⼤⼩。

2.接⼝Comparable<T> API参数类型：T ---可以与此对象进⾏⽐较的那些对象的类型此接⼝强⾏对实现它的每个类的对象进⾏整体排序。

这种排序被称为类的⾃然排序，类的compareTo()⽅法被称为它的⾃然⽐较⽅法。

实现此接⼝的对象列表（和数组）可以通过（和）进⾏⾃动排序。

实现此接⼝的对象可以⽤作中的键或中的元素，⽆需指定。

Comparable也只有int compareTo(T object)⼀个⽅法。

⽐较此对象与指定对象的顺序。

如果该对象⼩于、等于或⼤于指定对象，则分别返回负整数、零或正整数。

3.接⼝ Comparator<T> API强⾏对某个对象 collection 进⾏整体排序的⽐较函数。

可以将 Comparator 传递给 sort ⽅法（如或），从⽽允许在排序顺序上实现精确控制。

还可以使⽤ Comparator 来控制某些数据结构（如或）的顺序，或者为那些没有的对象 collection 提供排序。

java sorted排序规则

题目：Java中的Sorted排序规则一、介绍在Java中，Sorted排序指的是对集合中的元素按照一定的规则进行排序。

在不同的集合类型中，排序规则可能会有所不同。

本文将对Java中Sorted排序的规则进行详细介绍，以帮助读者更好地理解和应用Java中的排序功能。

二、Comparable接口1. 在Java中，实现了Comparable接口的类可以使用Collections.sort()或Arrays.sort()进行排序。

2. Comparable接口定义了一pareTo()方法，用于确定两个对象的顺序。

3.pareTo()方法返回负数表示this对象小于参数对象，返回正数表示this对象大于参数对象，返回0表示两个对象相等。

三、Comparator接口1. 对于没有实现Comparable接口的类，也可以使用Comparator接口进行排序。

2. Comparator接口定义了一pare()方法，可以自定义排序规则。

3. 使用Comparator接口可以对同一类的对象根据不同的排序规则进行排序。

四、Arrays.sort()方法1. Arrays.sort()方法可以对数组进行排序。

2. 该方法有多个重载版本，可以通过传入不同的Comparator对象来实现不同的排序规则。

3. 通过Arrays.sort()方法，可以实现对数组中的元素进行快速排序。

五、Collections.sort()方法1. Collections.sort()方法可以对List集合进行排序。

2. 该方法也有多个重载版本，可以根据需要传入不同的Comparator对象来实现不同的排序规则。

3. 对于实现了Comparable接口的类，可以直接使用Collections.sort()方法进行排序。

六、排序规则1. 在排序规则的定义上，需要注意以下几点：- 对于基本数据类型，比较大小可以直接使用比较运算符（如<、>）进行比较。

Java中List排序的三种实现方法实例

Java中List排序的三种实现⽅法实例⽬录前⾔1.使⽤ Comparable 排序2.使⽤ Comparator 排序2.1 新建 Comparator ⽐较器2.2 匿名类⽐较器3.使⽤ Stream 流排序总结前⾔在某些特殊的场景下，我们需要在 Java 程序中对 List 集合进⾏排序操作。

⽐如从第三⽅接⼝中获取所有⽤户的列表，但列表默认是以⽤户编号从⼩到⼤进⾏排序的，⽽我们的系统需要按照⽤户的年龄从⼤到⼩进⾏排序，这个时候，我们就需要对 List 集合进⾏⾃定义排序操作了。

L ist 排序的常见⽅法有以下 3 种：1. 使⽤ Comparable 进⾏排序；2. 使⽤ Comparator 进⾏排序；3. 如果是 JDK 8 以上的环境，也可以使⽤ Stream 流进⾏排序。

下⾯我们分别来看各种排序⽅法的具体实现。

1.使⽤ Comparable 排序按照本⽂设计的场景，我们需要创建⼀个包含了⽤户列表的 List 集合，并按⽤户的年龄从⼤到⼩进⾏排序，具体实现代码如下：public class ListSortExample {public static void main(String[] args) {// 创建并初始化 ListList<Person> list = new ArrayList<Person>() {{add(new Person(1, 30, "北京"));add(new Person(2, 20, "西安"));add(new Person(3, 40, "上海"));}};// 使⽤ Comparable ⾃定的规则进⾏排序Collections.sort(list);// 打印 list 集合list.forEach(p -> {System.out.println(p);});}}// 以下 set/get/toString 使⽤的是 lombok 的注解@Getter@Setter@ToStringclass Person implements Comparable<Person> {private int id;private int age;private String name;public Person(int id, int age, String name) {this.id = id;this.age = age; = name;}@Overridepublic int compareTo(Person p) {return p.getAge() - this.getAge();}}以上代码的执⾏结果，如下图所⽰：本⽅法的核⼼代码如下：2.使⽤ Comparator 排序Comparable 是类内部的⽐较⽅法，⽽ Comparator 是排序类外部的⽐较器。

Comparator,Comparable接口区别

最近在做一个对象排序的功能,需要按不同规则排序.看了Arrays,Coll ections,的sort方法,
了解了Comparator,Comparable两个接口,找到了适用于自己的排序办法,下面把自己的
理解和收集到的我认为很经典的解释整理如下:
comparable是通用的接口，用户可以实现它来完成自己特定的比较，而comparator可以看成一种算法的实现，在需要容器集合co llection需要比较功能的时候，来指定这个比较器，这可以看出一种设计模式，将算法和数据分离，就像C++ STL中的函数对象一样。

前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。

可以说前者属于“静态绑定”，而后者可以“动态绑定”。

一个类实现了Camparable接口表明这个类的对象之间是可以相互比较的。

如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。

这样，这个类对象组成的集合就可以使用Sort方法排序了。

而Comparator的作用有两个：
1. 如果类的设计师没有考虑到Compare的问题而没有实现Co mparable接口，可以通过Comparator来实现比较算法进行排序
2. 为了使用不同的排序标准做准备，比如：升序、降序或其他什么序。

Comparable与Comparator的区别

java的Comparator和Comparable当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。

一、Comparator强行对某个对象collection进行整体排序的比较函数，可以将Comparator传递给Collections.sort或Arrays.sort。

接口方法：/*** @return o1小于、等于或大于o2，分别返回负整数、零或正整数。

*/int compare(Object o1, Object o2);案例：import java.util.Arrays;import parator;public class SampleComparator implements Comparator<String> {public int compare(String o1, String o2) {return toInt(o1) - toInt(o2);}private int toInt(String str) {str = str.replaceAll("一", "1");str = str.replaceAll("二", "2");str = str.replaceAll("三", "3");return Integer.parseInt(str);}/*** 测试方法*/public static void main(String[] args) {String[] array = new String[] { "一二", "三", "二" };Arrays.sort(array, new SampleComparator());for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}}}二、Comparable强行对实现它的每个类的对象进行整体排序，实现此接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。

Java进阶知识

Java进阶知识常见异常：空指针异常NullPointerException，调⽤了未经初始化的对象或不存在的对象，或访问或修改了null对象的属性或⽅法;找不到类名异常ClassNotFoundException，的确不存在，开发环境进⾏了调整或，如类的根⽬录结构、编译运⾏时发⽣变化的等;类名不合法异常IllegalAgreementException，向⽅法传递了不合法或不正确的参数；输⼊不匹配异常InputMismatchException，由scanner抛出表获取内容与期望类型的模式不⼀致或内容超出预期；IllegalAccessException，应⽤程序试图创建⼀个实例、设置或获取⼀个属性，或调⽤⼀个⽅法，但当前正在执⾏的⽅法⽆法访问指定类、属性、⽅法或构造⽅法的定义时；ClassCastExceptiom,当试图将对象转换为不是实例的⼦类时抛出;SQLException，数据库访问或其他错误信息的异常;IOException，发⽣某种I/O异常。

运⾏时异常和检查时异常的区别：运⾏时异常，不要求程序在编译时对异常进⾏处理，也能编译通过；检查时异常⼜称⾮运⾏异常，要求程序员必须在编译时进⾏处理，否则编译不通过。

【企业⾯试常考】ArrayList和LinkList的区别：前者采⽤数组进⾏顺序存储，在插⼊或删除数据时，需要批量移动数据元素，故性能较差；在查询数据元素时，因为数组是是连续存储的，可以通过下标进⾏访问，故在遍历元素或随机访问元素时效率⾼。

LinkList则相反。

顺序存储结构和链式存储结构的优缺点：前者优点：节省存储空间（分配的存储单元全⽤来存放节点的数据，节点间逻辑关系没有占⽤额外的存储空间）；增加访问速度（存储单元存放可实现节点的随机存取）；查找速度快。

缺点：插删慢后者优点：插删快。

缺点：占⽤空间⼤（每个节点都由数据域和指针域组成）；查找速度慢（通过指针逐个查找）。

栈和队列两种数据结构特点：栈Stack:先进后出或后进先出；只能在⼀端进⾏插⼊和删除操作的特殊的线性表。

Java对象数组排序的三种方法-comparable，comparator，lambda表达式

Java对象数组排序的三种⽅法-comparable，comparator，lambda表达式以Employee为例，实现对象数组Employee[] employees的排序1.类实现comparable⼀个对象数组若要使⽤Arrays.sort(Object[] objects)⽅法来排序，那么该对象类需要实现comparable接⼝public class Employee implements Comparable<Employee>{private String name;private double salary;public Employee(){name="Employee";salary=0;}public Employee(String name,double salary){=name;this.salary=salary;}...省略代码...public double getSalary(){return salary;}public void setSalary(double salary){this.salary=salary;}@Overridepublic int compareTo(Employee o){//return pare(salary,o.salary);return pare(this.getSalary(),o.getSalary());}}//1.Employee实现Comparable接⼝Arrays.sort(employees);2.往Arrays.sort()⽅法中传⼊Comparator对象来规定排序规则class EmployeeComparator implements Comparator<Employee>{@Overridepublic int compare(Employee o1,Employee o2){return pare(o1.getSalary(),o2.getSalary());}}//2.使⽤Comparator⽐较器Comparator comparator=new EmployeeComparator();3.往Arrays.sort()⽅法传⼊lambda表达式//3.使⽤Lambada表达式Arrays.sort(employees,(o1,o2)->{if(o1.getSalary()>o2.getSalary())return 1;else return -1;});。

Java中Comparable讲解

Java中Comparable讲解Comparable是排序接⼝；若⼀个类实现了Comparable接⼝，就意味着“该类⽀持排序”。

可以使⽤Arrays.sort()对改类进⾏排序。

讲解parable接⼝使⽤场景：假如说我们有这样⼀个需求，需要设计⼀个Person类，有两个属性：姓名（name）、年龄（age），按照年龄的⼤⼩进⾏排序，那么实现可以这样package com.ikos.web;import java.util.Arrays;class Person implements Comparable<Person>{int age;String name;public Person(String name,int age){ = name;this.age = age;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn"姓名:"+name+","+"年龄:"+age+";";}@Overridepublic int compareTo(Person o) {// TODO Auto-generated method stubif(this.age>o.age){return1;}else if(this.age<o.age){return -1;}//当然也可以这样实现// return pare(this.age, o.age);return0;}public static void main(String[] args) {Person []persons = new Person[]{new Person("张三",15),new Person("李四",25),new Person("王五",20)};Arrays.sort(persons);System.out.println(Arrays.toString(persons));System.out.println(persons[0]==persons[1]);System.out.println(persons[0].equals(persons[1]));}}结果：注意细节：Comparable<T>接⼝⾥⾯有⼀个泛型T，T的选择为可以与之⽐较的对象的类型，⼀般就是实现该接⼝类的本⾝，可以这样想和Person类⽐较的当然是Person本⾝了。

hashset排序规则

hashset排序规则HashSet是Java集合框架中的一种数据结构，它实现了Set接口，可以存储不重复的元素。

HashSet中的元素没有特定的顺序，但是可以使用Comparator接口或Comparable接口来指定排序规则。

1. Comparator接口Comparator接口是Java集合框架中用于比较两个对象的接口。

通过实现Comparator接口并重写compare方法，可以指定HashSet中元素的排序规则。

compare方法返回一个整数值，表示两个对象之间的大小关系。

如果返回值小于0，则表示第一个对象比第二个对象小；如果返回值等于0，则表示两个对象相等；如果返回值大于0，则表示第一个对象比第二个对象大。

例如，假设我们有一个Student类，其中包含学生姓名和年龄两个属性。

我们可以定义一个按照学生年龄从小到大排序的Comparator：```public class AgeComparator implements Comparator<Student> {@Overridepublic int compare(Student s1, Student s2) {return s1.getAge() - s2.getAge();}}```然后，在创建HashSet时，将该Comparator作为参数传递给构造函数：```Set<Student> set = new HashSet<>(new AgeComparator()); ```这样，在添加元素时，HashSet会根据AgeComparator指定的排序规则将元素插入到正确的位置。

2. Comparable接口除了使用Comparator外，还可以在元素类中实现Comparable接口来指定排序规则。

通过实现Comparable接口并重写compareTo方法，可以定义元素之间的自然排序规则。

java 多参数对比方法

java 多参数对比方法在Java中，如果你想比较多个参数，你可以使用一些比较方法，比如`Comparator` 或者 `Comparable`。

以下是一个使用 `Comparator` 的例子：```javaimport ;public class Main {public static void main(String[] args) {Integer a = 10;Integer b = 20;Integer c = 30;Comparator<Integer> compare = new Comparator<Integer>() { Overridepublic int compare(Integer o1, Integer o2) {return o1 - o2;}};((a, b)); // 输出 -10，表示 a 小于 b((b, c)); // 输出 -10，表示 b 小于 c}}```在上述代码中，我们定义了一个新的比较器，然后使用这个比较器去比较`a` 和 `b`，以及 `b` 和 `c`。

这个比较器会返回一个整数，如果第一个参数小于第二个参数，那么就返回负数；如果两个参数相等，就返回0；如果第一个参数大于第二个参数，就返回正数。

请注意，Java 8 引入了 lambda 表达式，使得创建比较器变得更简单：```javaComparator<Integer> compare = (o1, o2) -> o1 - o2;```此外，如果你正在处理自定义对象，并且想要定义对象的比较方式，那么你可能需要让你的类实现 `Comparable` 接口，并重写 `compareTo` 方法。

英文三个连续比较大小的表达方式

英文中有很多不同的表达方式来比较大小，这些表达方式可以帮助我们描述事物之间的差异和优劣。

在英语写作中，适当地使用这些比较表达方式可以使文章更加生动有趣。

接下来，我将对英文中三个连续比较大小的表达方式进行全面评估和讨论。

1. 比较级（Comparative）比较级是英文中表示两者之间差异的一种形式。

通常情况下，比较级是以"-er"结尾，如"bigger"、"faster"等，或者在形容词前加上"more"，如"more beautiful"、"more interesting"等。

在写作中，使用比较级可以帮助我们突出两者之间的差异，形成对比，使文章更加生动。

2. 最高级（Superlative）最高级用于比较三者或三者以上的差异，表示某个事物在同类中处于最高位置，是最好、最坏或最具某种特质的。

最高级的构成形式通常是在形容词前加上"the most"，如"the most beautiful"、"the most interesting"等。

在写作中，使用最高级可以帮助我们强调某个事物在同类中的优劣，加强文章的逻辑性和说服力。

3. 级数词（Numerical Order）级数词用于对事物进行排序或排列，表示它们在一定范围内的位置次序。

"the first, the second, the third"等。

在英文写作中，使用级数词可以帮助我们对事物进行清晰的排列和描述，使读者更容易理解事物之间的先后顺序和逻辑关系。

总结回顾：通过对比较级、最高级和级数词这三种表达方式的全面评估，我们可以看到它们在英语写作中的重要性和灵活性。

比较级能够突出两者之间的差异，最高级能够强调某个事物在同类中的优劣，级数词能够对事物进行清晰的排列和描述。

Comparable和Comparator的区别

Comparable和Comparator的区别 Comparable 和 Comparator 都是接⼝，均为⽐较器 Comparable相当于“内⽐较器”，⽽Comparator相当于“外⽐较器” 实现Comparable的类，该类就具有⾃⾝⽐较的功能；Comparator的实现，是⼀个外部⽐较⼯具器注意Comparable 和 Comparator 同时实现时，则以Comparator为主Comparable接⼝ Comparable 被认为是内⽐较器，也是⾃然排序，实现该接⼝的类，会有⾃⾝⽐较的功能，则依赖compareTo⽅法的实现 CompareTo⽅法的返回值是int,有三种情况： 1、⽐较者⼤于被⽐较者，那么返回正整数 2、⽐较者等于被⽐较者，那么返回0 3、⽐较者⼩于被⽐较者，那么返回负整数// Comparable 接⼝的定义public interface Comparable<T>{public int compareTo(T o);}例⼦：String 本⾝就以实现Comparable ，所以可以调⽤它的compareTo⽅法进⾏⽐较class Person implements Comparable{// 其他属性@Overridepublic int compareTo(Person p){int temp = this.age - p.age;return temp == 0 ? pareTo() : temp;}}Comparator接⼝ Comparator 被认为是外⽐较器，我们如果需要控制某个类的次序，⽽该类本⾝不⽀持排序(即没有实现Comparable接⼝)，那么我们就可以建⽴⼀个“该类的⽐较器”来进⾏排序，这个“⽐较器”只需要实现Comparator接⼝覆盖compare(T o1, T o2)⽅法，即可，然后通过这个⽐较器对类进⾏⽐较且排序 compare(T o1, T o2)⽅法，int返回值有三种情况： 1、o1⼤于o2，返回正整数 2、o1等于o2，返回0 3、o1⼩于o3，返回负整数有两种场景可以使⽤实现Comparator接⼝的⽅式: 1、⼀个对象不⽀持⾃⼰和⾃⼰⽐较（没有实现Comparable接⼝），但是⼜想对两个对象进⾏⽐较 2、⼀个对象实现了Comparable接⼝，但是开发者认为compareTo⽅法中的⽐较⽅式并不是如他所愿例⼦：public class PersonComparator implements Comparator<Person>{@Overridepublic int compare(Person p1, Person p2){ int temp = p1.getName().compareTo(p2.getName);return temp == 0 ? p1.getAge() - p2.getAge() : temp;}}。

java求两个集合的交集和并集，比较器

java求两个集合的交集和并集，⽐较器求连个集合的交集：import java.util.ArrayList;import java.util.List;public class TestCollection {public static void main(String[] args) {List<String> strList = new ArrayList<String>();List<String> strList2 = new ArrayList<String>();for(int i = 0; i < 10; i ++) {strList.add("aaa>>" + i);strList2.add("aaa>>" + (10 - i));}//求出交集strList2.retainAll(strList);System.out.println("交集⼤⼩：" + strList2.size());for(int i = 0; i < strList2.size(); i++) {System.out.println(strList2.get(i));}}}求两个集合的并集：import java.util.ArrayList;import java.util.List;public class TestCollection {public static void main(String[] args) {List<String> strList = new ArrayList<String>();List<String> strList2 = new ArrayList<String>();for(int i = 0; i < 10; i ++) {strList.add("aaa>>" + i);strList2.add("aaa>>" + (10 - i));}//求出并集strList2.removeAll(strList);strList2.addAll(strList);System.out.println("并集⼤⼩：" + strList2.size());for(int i = 0; i < strList2.size(); i++) {System.out.println(strList2.get(i));}}}3.差集：由属于A⼜不属于B的元素组成的叫差集list1.remove(list2);4.去重并排序package twolist;import java.util.Collections;import parator;import java.util.HashMap;import java.util.HashSet;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.Set;public class ListMapSort {/*** @param args*/public static void main(String[] args) {// TODO ⾃动⽣成⽅法存根List<Map<String,Object>> listMap1 = new LinkedList<Map<String,Object>>();Map<String,Object> map = new HashMap<String, Object>();map.put("date", 20121010);listMap1.add(map);map = new HashMap<String, Object>();map.put("date", 20011213);listMap1.add(map);listMap1.add(map);map = new HashMap<String, Object>();map.put("date", 20130502);listMap1.add(map);System.out.println("原始"+listMap1);List<Map<String,Object>> listMap2 = new LinkedList<Map<String,Object>>();Set<Map> setMap = new HashSet<Map>();for(Map<String,Object> map1 : listMap1){if(setMap.add(map1)){listMap2.add(map1);}}System.out.println("去重"+listMap2);Collections.sort(listMap2, new Comparator<Map<String,Object>>(){public int compare(Map<String,Object> o1,Map<String,Object> o2){return o1.get("date").toString().compareTo(o2.get("date").toString());}});System.out.println("排序:"+listMap2);}}通常对象之间的⽐较可以从两个⽅⾯去看：第⼀个⽅⾯：对象的地址是否⼀样，也就是是否引⽤⾃同⼀个对象。

Comparable和Comparator的区别

Comparable和Comparator的区别前⾔初次碰到这个问题是之前有⼀次电话⾯试，问了⼀个⼩时的问题，其中有⼀个问题就问到Comparable和Comparator的区别，当时没答出来。

之后是公司⼊职时候做的⼀套Java编程题，⾥⾯⽤JUnit跑⽤例的时候也⽤到了Comparator接⼝，再加上JDK的⼤量的类包括常见的String、Byte、Char、Date等都实现了Comparable接⼝，因此要学习⼀下这两个类的区别以及⽤法。

ComparableComparable可以认为是⼀个内⽐较器，实现了Comparable接⼝的类有⼀个特点，就是这些类是可以和⾃⼰⽐较的，⾄于具体和另⼀个实现了Comparable接⼝的类如何⽐较，则依赖compareTo⽅法的实现，compareTo⽅法也被称为⾃然⽐较⽅法。

如果开发者add进⼊⼀个Collection的对象想要Collections的sort⽅法帮你⾃动进⾏排序的话，那么这个对象必须实现Comparable接⼝。

compareTo⽅法的返回值是int，有三种情况：1、⽐较者⼤于被⽐较者（也就是compareTo⽅法⾥⾯的对象），那么返回正整数2、⽐较者等于被⽐较者，那么返回03、⽐较者⼩于被⽐较者，那么返回负整数写个很简单的例⼦：public class Domain implements Comparable<Domain>{private String str;public Domain(String str){this.str = str;}public int compareTo(Domain domain){if (pareTo(domain.str) > 0)return 1;else if (pareTo(domain.str) == 0)return 0;elsereturn -1;}public String getStr(){return str;}}public static void main(String[] args){Domain d1 = new Domain("c");Domain d2 = new Domain("c");Domain d3 = new Domain("b");Domain d4 = new Domain("d");System.out.println(pareTo(d2));System.out.println(pareTo(d3));System.out.println(pareTo(d4));}运⾏结果为：1-1注意⼀下，前⾯说实现Comparable接⼝的类是可以⽀持和⾃⼰⽐较的，但是其实代码⾥⾯Comparable的泛型未必就⼀定要是Domain，将泛型指定为String或者指定为其他任何任何类型都可以----只要开发者指定了具体的⽐较算法就⾏。

Comparable和Comparator的区别

Comparable和Comparator的区别ComparableComparable 是排序接⼝。

若⼀个类实现了Comparable接⼝，就意味着“该类⽀持排序”。

即然实现Comparable接⼝的类⽀持排序，假设现在存在“实现Comparable接⼝的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进⾏排序。

“实现Comparable接⼝的类的对象”可以⽤作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素，⽽不需要指定⽐较器。

Comparable接⼝中定义了⼀个⽅法：public interface Comparable<T> {public int compareTo(T o);}假设我们通过 pareTo(y) 来“⽐较x和y的⼤⼩”。

若返回“负数”，意味着“x⽐y⼩”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x⼤于y”。

举例：public class Girl implements Comparable<Object> {private String name;private int age;public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Girl(String name, int age) {super(); = name;this.age = age;}@Overridepublic String toString() {return "Girl [name=" + name + ", age=" + age + "]";}@Overridepublic int compareTo(Object o) {Girl g = (Girl)o;return this.age - g.getAge();}}public static void main(String[] args) {List<Girl> list = new ArrayList<>(100);Girl girl;for (int i=0; i<75; i++) {girl = new Girl("girl " + i, i);list.add(girl);}Collections.shuffle(list);Collections.sort(list);list.stream().forEach(System.out::println);}ComparatorComparator 是⽐较器接⼝。

Comparable和Comparator比较

Comparable和Comparator比较在“集合框架”中有两种比较接口：Comparable接口和Comparator接口。

像String和Integer等Java内建类实现Comparable接口以提供一定排序方式，但这样只能实现该接口一次。

对于那些没有实现Comparable接口的类、或者自定义的类，您可以通过Comparator接口来定义您自己的比较方式。

Comparable接口在ng包中，Comparable接口适用于一个类有自然顺序的时候。

假定对象集合是同一类型，该接口允许您把集合排序成自然顺序。

int compareTo(Object o): 比较当前实例对象与对象o，如果位于对象o之前，返回负值，如果两个对象在排序中位置相同，则返回0，如果位于对象o后面，则返回正值Comparator接口若一个类不能用于实现parable，或者您不喜欢缺省的Comparable行为并想提供自己的排序顺序(可能多种排序方式)，你可以实现Comparator接口，从而定义一个比较器。

(1) int compare(Object o1, Object o2):对两个对象o1和o2进行比较，如果o1位于o2的前面，则返回负值，如果在排序顺序中认为o1和o2是相同的，返回0，如果o1位于o2的后面，则返回正值(2) boolean equals(Object obj):指示对象obj是否和比较器相等“与Comparable相似，0返回值不表示元素相等。

一个0返回值只是表示两个对象排在同一位置。

由Comparator用户决定如何处理。

如果两个不相等的元素比较的结果为零，您首先应该确信那就是您要的结果，然后记录行为。

”1、自然排序——Comparable在JDK类库中，有一部分类实现了Comparable接口,如Integer Double和String 等。

Comparable接口有一个comparTo(Object o)方法,它返回整数类型。

java中比较大小的函数

java中比较大小的函数在Java中，比较大小的函数是程序员经常使用的功能之一。

Java提供了许多比较操作的方法，包括在基本数据类型和对象之间的比较方法。

在本文中，我将介绍一些常见的Java比较大小函数及其用法。

一、基本数据类型的比较1.1. 整型的比较在Java中，我们可以使用“>”、“<”、“>=”、“<=”、“==”和“!=”等操作符对整型数值进行比较。

其中，“==”和“!=”代表相等和不相等关系，而其他操作符则表示大小关系。

例如：int a = 10;int b = 20;if (a < b) {System.out.println("a is less than b");}输出结果是“a is less than b”。

1.2. 浮点型的比较浮点数值的比较需要特别注意。

由于浮点数值是近似值，而不是精确值，因此使用等于操作符“==”来比较浮点数值可能会导致错误的结果。

我们应该使用Java提供的pare(double d1, double d2)或pare(float f1, float f2)方法来比较浮点型数值的大小。

例如：double d1 = 1.23;double d2 = 2.34;int result = pare(d1, d2);if (result < 0) {System.out.println("d1 is less than d2");}输出结果是“d1 is less than d2”。

二、对象之间的比较2.1. 比较器在Java中，我们可以使用Comparable或Comparator接口来比较对象之间的大小。

Comparable接口是在对象内部实现的，而Comparator接口是在外部实现的。

如果我们要比较的对象已经实现了Comparable接口，那么我们可以直接使用compareTo方法来比较它们的大小。

Java当中自定义排序函数

Java当中⾃定义排序函数
⼀、实现Comparator接⼝
⽅法类似中介绍的，包括了有名类和匿名类两种⽅式
具体使⽤：
排序：
Collections.sort(容器，comparator)
Queue q = new PriorityQueue(capacity,comparator)
⼆、comparable 抽象类
对于comparable的介绍可以参考下⾯的引⽤
概括⼀下comparable和comparator的区别：
从名字上理解，comparable代表了⼀种能⼒，是⼀种性质，所以他是和⼀个类型绑定在⼀起的。

comparator实现了数据和算法的分离，从⽽对于sort函数，PriorityQueue等就可以使⽤不同的算法实现，具有更⼤的灵活性。

⽽且对于数据类型没有提供⽐较函数的情况也可以添加⼀个实现，⽽不需要修改原来的代码。

当然comparable的好处也很明显啦，将这个⽐较函数放到数据定义当中，不见使代码简介，⽽且更加集中，容易管理。

comparable： public int compareTo()
comparator: public int compare()。