java中comparable比较_java中Comparable和Comparator两种比较器的区别

最新推荐文章于 2023-01-16 21:31:59 发布

蒋寻

最新推荐文章于 2023-01-16 21:31:59 发布

阅读量184

点赞数

文章标签： java中comparable比较

本文链接：https://blog.csdn.net/weixin_35811254/article/details/114614278

版权

求连个集合的交集：

import java.util.ArrayList;

import java.util.List;

public class TestCollection {

public static void main(String[] args) {

List strList = new ArrayList();

List strList2 = new ArrayList();

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 strList = new ArrayList();

List strList2 = new ArrayList();

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 java.util.Comparator;

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> listMap1 = new LinkedList>();

Map map = new HashMap();

map.put("date", 20121010);

listMap1.add(map);

map = new HashMap();

map.put("date", 20011213);

listMap1.add(map);

map = new HashMap();

map.put("date", 20130502);

listMap1.add(map);

System.out.println("原始"+listMap1);

List> listMap2 = new LinkedList>();

Set setMap = new HashSet();

for(Map map1 : listMap1){

if(setMap.add(map1)){

listMap2.add(map1);

}

System.out.println("去重"+listMap2);

Collections.sort(listMap2, new Comparator>(){

public int compare(Map o1,Map o2){

return o1.get("date").toString().compareTo(o2.get("date").toString());

}

});

System.out.println("排序:"+listMap2);

}

通常对象之间的比较可以从两个方面去看：

第一个方面：对象的地址是否一样，也就是是否引用自同一个对象。这种方式可以直接使用“==“来完成。

第二个方面：以对象的某一个属性的角度去比较。

对于JDK8而言，有三种实现对象比较的方法：

1、覆写Object类的equals()方法；

2、继承Comparable接口，并实现compareTo()方法；

3、定义一个单独的对象比较器，继承自Comparator接口，实现compare()方法。

由于使用的排序方式的不同，具体选择哪种方法来实现对象的比较也会有所不同。

Comparable和Comparator接口都是为了对类进行比较，众所周知，诸如Integer，double等基本数据类型，java可以对他们进行比较，而对于类的比较，需要人工定义比较用到的字段比较逻辑。可以把Comparable理解为内部比较器，而Comparator是外部比较器，基本的写法如下：

class Apple implements Comparable{

int id;

double price;

public Apple(int id, double price) {

this.id = id;

this.price = price;

}

public int compareTo(Apple o) {

//return Double.compare(this.getPrice(),o.getPrice());

if (Math.abs(this.price-o.price)<0.001)

return 0;

else

return (o.price-this.price)>0?1:-1;

}

@Override

public String toString() {

return "Apple{" +

"id=" + id +

", price=" + price +

'}';

}

class AESComparator implements Comparator{

public int compare(Apple o1, Apple o2) {

if (Math.abs(o1.price-o2.price)<0.001)

return 0;

else{

return (o1.price-o2.price)>0?1:-1;

}

实现了Comparable接口的类需要实现compareTo()方法，传入一个外部参数进行比对，实现了Comparator接口的方法需要实现compare()方法，对外部传入的两个类进行比较，从而让外部方法在比较时调用。

先了解一下Arrays和Collections.sort(list, new MyComparator());//传入list和比较器排序

了解比较器之前首先来了解一下java.util包下的Arrays类。这个类主要提供了各种操作数组的方法。最常用的几个方法：

Arrays.toString(T[] data) //将数组以字符串的形式返回

Arrays.sort(T[] data)//将数组按指定的比较规则以升序的顺序排序，T类需要实现Comparable接口

Arrays.sort(T[],Comparator super T>)//将数组按指定的比较器以升序的顺序排序

Arrays.fill(T[] data,T val)//数组的每一个元素赋值为val

比较器之Comparable接口

实现对象之间的比较有两个方法，第一个方法就是实现Compatable接口。Comparable接口是java.lang包下的。该接口只有一个方法：

int compareTo(T o)//返回三种情况：负整数、0、正整数。分别表示小于、等于、大于

当我们想要比较两个对象的大小时，由于栈中存的是对象的地址，所以无法比较。于是我们需要实现Comparable接口，并且重写compareTo方法。其实，String类就是实现了Comparable接口，才有了compareTo()的方法。

比较器之Comparator接口

实现对象的比较第二个方法是额外写一个比较工具类，该工具类需要实现Comparator接口。既然有了Comparable接口可以实现比较，为什么还要有Comparator接口呢？因为Comparable接口在类定义的时候就要实现好Comparable的compareTo()方法。假设我已经写好了City类，不想再改变改类的内部结构，这时我们就可以通过再写一个工具类来实现City类的比较。另外，通过多个工具类可以实现多种不同的比较方法。

public class A{

public xxxx fun(){

//业务逻辑

//xxxxxxxxxxxxxxxxxxx

//排序

Collections.sort(myList, new MyComparator(configValueList));

}

/**

*内部类实现排序

*configValueList 排序规则

*根据DtoList中的某一个字段，按照configValueList配置的规则来排序

*如configValueList ["a","b","c"]

*myList myList.get[0].getVal() = b，myList.get[1].getVal() = a，myList.get[2].getVal() = c

*那么排序后 myList.get[0].getVal() = a，myList.get[1].getVal() = b，myList.get[2].getVal() = c

class MyComparator implements Comparator {

private List configValueList;

public MyComparator(List configValueList) {

this.configValueList = configValueList;

}

@Override

public int compare(Dto dto1, Dto dto2) {

if(CollectionUtils.isEmpty(configValueList) || dto1 == null || dto2 == null){

return 0;

}

String val1 = dto1.getVal();

String val2 = dto2.getVal();

if(StringUtils.isBlank(val1) || StringUtils.isBlank(val2)){

return 0;

}

int sort1 = configValueList.indexOf(val1);

int sort2 = configValueList.indexOf(val2);

if(-1 == sort1 || -1 == sort2){

return 0;

}

return sort1 - sort2;

}

或者这样内部类

public class TestSorting {

public static void main(String[] args) {

List listDevs = getDevelopers();

Collections.sort(listDevs, new Comparator() {

@Override

public int compare(Developer o1, Developer o2) {

return o1.getAge() - o2.getAge();

}

});

for (Developer developer : listDevs) {

System.out.println(developer);

}

private static List getDevelopers() {

List result = new ArrayList();

result.add(new Developer("mkyong", new BigDecimal("70000"), 33));

result.add(new Developer("alvin", new BigDecimal("80000"), 20));

result.add(new Developer("jason", new BigDecimal("100000"), 10));

result.add(new Developer("iris", new BigDecimal("10000"), 23));

return result;

}

在Java8使用Lamdba排序

public class TestSortingLamdba {

public static void main(String[] args) {

List listDevs = getDevelopers();

listDevs.sort((Developer o1, Developer o2) -> o1.getAge() - o2.getAge());

listDevs.forEach(System.out::println);

System.out.println("----------------");

listDevs.sort((o1, o2) -> o1.getName().compareTo(o2.getName()));

listDevs.forEach(System.out::println);

System.out.println("----------------");

listDevs.sort(Comparator.comparing(Developer::getSalary));

listDevs.forEach(System.out::println);

System.out.println("----------------");

listDevs.sort(Comparator.comparing(Developer::getSalary).reversed());

listDevs.forEach(System.out::println);

}

private static List getDevelopers() {

List result = new ArrayList();

result.add(new Developer("mkyong", new BigDecimal("70000"), 33));

result.add(new Developer("alvin", new BigDecimal("80000"), 20));

result.add(new Developer("jason", new BigDecimal("100000"), 10));

result.add(new Developer("iris", new BigDecimal("10000"), 23));

return result;

}

来源：https://www.cnblogs.com/h-c-g/p/11082788.html

蒋寻

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java中comparable比较_java中Comparable和Comparator两种比较器的区别

求连个集合的交集：import java.util.ArrayList;import java.util.List;public class TestCollection {public static void main(String[] args) {List strList = new ArrayList();List strList2 = new ArrayList();for(int i ...
复制链接

扫一扫