Java求两个集合的交集和并集,比较器

Java求两个集合的交集和并集,比较器

1.求两个集合的交集

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));
        }       
    }
}

2.求两个集合的并集

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.去重并排序

1.下面代码以自然序排序一个list

list.stream().sorted() 

2.自然序逆序元素,使用Comparator 提供的reverseOrder() 方法

list.stream().sorted(Comparator.reverseOrder()) 

3.使用Comparator 来排序一个list

list.stream().sorted(Comparator.comparing(Student::getAge)) 

4.把上面的元素逆序

list.stream().sorted(Comparator.comparing(Student::getAge).reversed()) 

5.当然还可以不用借助steam方式直接排序:

list.sort(Comparator.comparing(Integer::intValue));

list.sort(Comparator.comparing(Integer::intValue).reversed());(倒序)

list.sort(Comparator.comparing(Student::getAge));

list.sort(Comparator.comparing(Student::getAge).reversed());(倒序)
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);
    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);
  }
}

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

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

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

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

对于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)//将数组按指定的比较器以升序的顺序排序
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;
    }
}

你可能感兴趣的:(java,工具类,java,jvm,算法)