java8去重_Java8 按照类属性去重

测试po

package com.shiwulian.test.po;

public class Person {

private String id;

private String name;

private Integer age;

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

public Person() {

super();

// TODO Auto-generated constructor stub

}

public Person(String id, String name, Integer age) {

super();

this.id = id;

this.name = name;

this.age = age;

}

@Override

public String toString() {

return '['+id+','+name+','+age.toString()+']';

}

}

测试

package com.shiwulian.test.po;

import static java.util.Comparator.comparing;

import static java.util.stream.Collectors.collectingAndThen;

import static java.util.stream.Collectors.toCollection;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

import java.util.concurrent.ConcurrentHashMap;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.stream.Collectors;

public class PersonTest {

public static void main(String[] args) {

long beginTime = 0;

long endTime = 0;

long costTime = 0;

Person p1 = new Person("1", "jack",15);

Person p2 = new Person("2", "tom",15);

Person p3 = new Person("3", "lala",16);

Person p4 = new Person("4", "lala",16);

Person p5 = new Person("5", "rose",14);

List persons = new ArrayList<>();

for (int i = 0; i < 1000000; i++) {

int yushu = i%5;

if(yushu == 1){

persons.add(p1);

}

if(yushu == 2){

persons.add(p2);

}

if(yushu == 3){

persons.add(p3);

}

if(yushu == 4){

persons.add(p4);

}

if(yushu == 0){

persons.add(p5);

}

}

List personUnique = null;

//function1

beginTime = System.currentTimeMillis();

personUnique = removeDupliType1(persons);

endTime = System.currentTimeMillis();

costTime = endTime - beginTime;

System.out.println("function1 消耗时间："+costTime);

//function2

beginTime = System.currentTimeMillis();

personUnique = removeDupliType2(persons);

endTime = System.currentTimeMillis();

costTime = endTime - beginTime;

System.out.println("function2 消耗时间："+costTime);

//function3

beginTime = System.currentTimeMillis();

personUnique = removeDupliType3(persons);

endTime = System.currentTimeMillis();

costTime = endTime - beginTime;

System.out.println("function3 消耗时间："+costTime);

//function4

beginTime = System.currentTimeMillis();

personUnique = removeDupliType4(persons);

endTime = System.currentTimeMillis();

costTime = endTime - beginTime;

System.out.println("function4 消耗时间："+costTime);

}

//function1

public static List removeDupliType1(List persons) {

Set personUnique = new TreeSet<>((o1, o2) -> o1.getName().compareTo(o2.getName()));

personUnique.addAll(persons);

return new ArrayList<>(personUnique);

}

//function2

public static List removeDupliType2(List persons) {

Set nameSet = new HashSet<>();

List personUnique = persons.stream().filter(p -> nameSet.add(p.getName())).collect(Collectors.toList());

return personUnique;

}

//function3

public static List removeDupliType3(List persons) {

List personUnique = persons.stream().collect(collectingAndThen(

toCollection(() -> new TreeSet<>(comparing(Person::getName))), ArrayList::new)

);

return personUnique;

}

//function4

public static List removeDupliType4(List persons) {

List personUnique = persons.stream().filter(distinctByKey(p -> ((Person) p).getId())).collect(Collectors.toList());

return personUnique;

}

public static Predicate distinctByKey(Function super T, Object> keyExtractor) {

Map map = new ConcurrentHashMap<>();

return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;

}

}

1000000条数据测试结果

1000条数据测试

测试总结：数据量较大的情况下(>1000000) function2 较快

数据量较小的情况下(<1000) function4较快 但是区别不大

以上凭借网上小伙伴的智慧，自己加以总结，希望大家批评指正。