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

java中Comparable和Comparator兩種比較器的區別

通常對象之間的比較可以從兩個方面去看：

第一個方面：對象的地址是否一樣，也就是是否引用自同一個對象。這種方式可以直接使用“==“來完成。

第二個方面：以對象的某一個屬性的角度去比較。

 

對於JDK8而言，有三種實現對象比較的方法：

1、覆寫Object類的equals（）方法；

2、繼承Comparable接口，並實現compareTo（）方法；

3、定義一個單獨的對象比較器，繼承自Comparator接口，實現compare（）方法。

由於使用的排序方式的不同，具體選擇哪種方法來實現對象的比較也會有所不同。

Comparable和Comparator接口都是為了對類進行比較，眾所周知，諸如Integer，double等基本數據類型，java可以對他們進行比較，而對於類的比較，需要人工定義比較用到的字段比較邏輯。可以把Comparable理解為內部比較器，而Comparator是外部比較器，基本的寫法如下：

class Apple implements Comparable<Apple>{
    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<Apple>{

    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<T>接口

實現對象之間的比較有兩個方法，第一個方法就是實現Compatable接口。Comparable接口是java.lang包下的。該接口只有一個方法：

int compareTo(T o)//返回三種情況：負整數、0、正整數。分別表示小於、等於、大於

當我們想要比較兩個對象的大小時，由於棧中存的是對象的地址，所以無法比較。於是我們需要實現Comparable接口，並且重寫compareTo方法。其實，String類就是實現了Comparable接口，才有了compareTo()的方法。

比較器之Comparator<T>接口
實現對象的比較第二個方法是額外寫一個比較工具類，該工具類需要實現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<Dto> {
        private List<String> configValueList;

        public MyComparator(List<String> 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<Developer> listDevs = getDevelopers();

        Collections.sort(listDevs, new Comparator<Developer>() {
            @Override
            public int compare(Developer o1, Developer o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        for (Developer developer : listDevs) {
            System.out.println(developer);
        }
    }

    private static List<Developer> getDevelopers() {

        List<Developer> result = new ArrayList<Developer>();

        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<Developer> 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<Developer> getDevelopers() {

        List<Developer> result = new ArrayList<Developer>();

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