Java 8 แตกต่างกันตามคุณสมบัติ

ใน Java 8 ฉันจะกรองคอลเล็กชันโดยใช้StreamAPI ได้อย่างไรโดยตรวจสอบความแตกต่างของคุณสมบัติของแต่ละวัตถุ

ตัวอย่างเช่นฉันมีรายการPersonวัตถุและฉันต้องการลบคนที่มีชื่อเดียวกัน

persons.stream().distinct();

จะใช้การตรวจสอบความเท่าเทียมกันเริ่มต้นสำหรับPersonวัตถุดังนั้นฉันต้องการบางสิ่งเช่น

persons.stream().distinct(p -> p.getName());

น่าเสียดายที่distinct()วิธีการนี้ไม่มีการโอเวอร์โหลดดังกล่าว หากไม่มีการแก้ไขการตรวจสอบความเท่าเทียมกันในPersonชั้นเรียนเป็นไปได้ไหมที่จะทำอย่างรัดกุม?

พิจารณาdistinctที่จะเป็นตัวกรอง stateful นี่คือฟังก์ชั่นที่คืนค่าเพรดิเคตที่รักษาสถานะเกี่ยวกับสิ่งที่เห็นก่อนหน้านี้และคืนค่าว่าองค์ประกอบที่กำหนดนั้นถูกมองเห็นเป็นครั้งแรกหรือไม่:

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}

จากนั้นคุณสามารถเขียน:

persons.stream().filter(distinctByKey(Person::getName))

โปรดทราบว่าหากมีการสั่งซื้อสตรีมและดำเนินการแบบขนานสิ่งนี้จะรักษาองค์ประกอบโดยพลการจากข้อมูลที่ซ้ำกันแทนที่จะเป็นรายการแรกเช่นเดียวกับที่distinct()ทำ

(นี่เป็นหลักเหมือนกับคำตอบของฉันสำหรับคำถามนี้: Java Lambda Stream Distinct () บนคีย์ arbitrary? )

อีกทางเลือกหนึ่งคือการวางบุคคลในแผนที่โดยใช้ชื่อเป็นคีย์:

persons.collect(Collectors.toMap(Person::getName, p -> p, (p, q) -> p)).values();

โปรดทราบว่าบุคคลที่ถูกเก็บไว้ในกรณีของชื่อที่ซ้ำกันจะถูกระบุเป็นชื่อแรก

คุณสามารถล้อมวัตถุบุคคลไว้ในคลาสอื่นซึ่งจะเปรียบเทียบเฉพาะชื่อบุคคล หลังจากนั้นคุณแกะวัตถุที่ห่อไว้เพื่อให้ได้รับกระแสอีกครั้ง การดำเนินการสตรีมอาจมีลักษณะดังนี้:

persons.stream()
    .map(Wrapper::new)
    .distinct()
    .map(Wrapper::unwrap)
    ...;

ชั้นWrapperอาจมีลักษณะดังนี้:

class Wrapper {
    private final Person person;
    public Wrapper(Person person) {
        this.person = person;
    }
    public Person unwrap() {
        return person;
    }
    public boolean equals(Object other) {
        if (other instanceof Wrapper) {
            return ((Wrapper) other).person.getName().equals(person.getName());
        } else {
            return false;
        }
    }
    public int hashCode() {
        return person.getName().hashCode();
    }
}

Setทางออกก็ใช้ อาจไม่ใช่โซลูชันที่สมบูรณ์แบบ แต่ใช้งานได้

Set<String> set = new HashSet<>(persons.size());
persons.stream().filter(p -> set.add(p.getName())).collect(Collectors.toList());

หรือถ้าคุณสามารถปรับเปลี่ยนรายการเดิมคุณสามารถใช้removeIfวิธี

persons.removeIf(p -> !set.add(p.getName()));

มีวิธีที่ง่ายกว่าในการใช้ TreeSet พร้อมตัวเปรียบเทียบที่กำหนดเอง

persons.stream()
    .collect(Collectors.toCollection(
      () -> new TreeSet<Person>((p1, p2) -> p1.getName().compareTo(p2.getName())) 
));

เรายังสามารถใช้RxJava ( ไลบรารีส่วนขยายรีแอคทีฟที่มีประสิทธิภาพมาก)

Observable.from(persons).distinct(Person::getName)

หรือ

Observable.from(persons).distinct(p -> p.getName())

คุณสามารถใช้ตัวgroupingByสะสม:

persons.collect(Collectors.groupingBy(p -> p.getName())).values().forEach(t -> System.out.println(t.get(0).getId()));

หากคุณต้องการมีสตรีมอื่นคุณสามารถใช้:

persons.collect(Collectors.groupingBy(p -> p.getName())).values().stream().map(l -> (l.get(0)));

คุณสามารถใช้distinct(HashingStrategy)วิธีการในEclipse คอลเลกชัน

List<Person> persons = ...;
MutableList<Person> distinct =
    ListIterate.distinct(persons, HashingStrategies.fromFunction(Person::getName));

หากคุณสามารถ refactor personsเพื่อใช้อินเตอร์เฟส Eclipse Collections คุณสามารถเรียกเมธอดโดยตรงบนรายการ

MutableList<Person> persons = ...;
MutableList<Person> distinct =
    persons.distinct(HashingStrategies.fromFunction(Person::getName));

HashingStrategyเป็นเพียงส่วนต่อประสานกลยุทธ์ที่ช่วยให้คุณกำหนดการปรับใช้แบบกำหนดเองของ equals และ hashcode

public interface HashingStrategy<E>
{
    int computeHashCode(E object);
    boolean equals(E object1, E object2);
}

หมายเหตุ: ฉันเป็นคอมมิชชันสำหรับ Eclipse Collections

ฉันแนะนำให้ใช้Vavrถ้าทำได้ ด้วยห้องสมุดนี้คุณสามารถทำสิ่งต่อไปนี้:

io.vavr.collection.List.ofAll(persons)
                       .distinctBy(Person::getName)
                       .toJavaSet() // or any another Java 8 Collection

คุณสามารถใช้ไลบรารีStreamEx :

StreamEx.of(persons)
        .distinct(Person::getName)
        .toList()

การขยายคำตอบของ Stuart Marks สามารถทำได้ในวิธีที่สั้นกว่าและไม่มีแผนที่พร้อมกัน (ถ้าคุณไม่ต้องการกระแสข้อมูลแบบขนาน):

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    final Set<Object> seen = new HashSet<>();
    return t -> seen.add(keyExtractor.apply(t));
}

จากนั้นโทร:

persons.stream().filter(distinctByKey(p -> p.getName());

วิธีการที่คล้ายกันซึ่ง Saeed Zarinfam ใช้ แต่มีสไตล์ Java 8 มากกว่า :)

persons.collect(Collectors.groupingBy(p -> p.getName())).values().stream()
 .map(plans -> plans.stream().findFirst().get())
 .collect(toList());

ฉันทำรุ่นทั่วไป:

private <T, R> Collector<T, ?, Stream<T>> distinctByKey(Function<T, R> keyExtractor) {
    return Collectors.collectingAndThen(
            toMap(
                    keyExtractor,
                    t -> t,
                    (t1, t2) -> t1
            ),
            (Map<R, T> map) -> map.values().stream()
    );
}

ตัวอย่าง:

Stream.of(new Person("Jean"), 
          new Person("Jean"),
          new Person("Paul")
)
    .filter(...)
    .collect(distinctByKey(Person::getName)) // return a stream of Person with 2 elements, jean and Paul
    .map(...)
    .collect(toList())

ห้องสมุดอื่นที่รองรับสิ่งนี้คือjOOλและSeq.distinct(Function<T,U>)วิธีการ:

Seq.seq(persons).distinct(Person::getName).toList();

ภายใต้ฝากระโปรงก็ไม่จริงสิ่งเดียวกับคำตอบที่ได้รับการยอมรับแม้ว่า

Set<YourPropertyType> set = new HashSet<>();
list
        .stream()
        .filter(it -> set.add(it.getYourProperty()))
        .forEach(it -> ...);

วิธีการของฉันนี้คือการจัดกลุ่มวัตถุที่มีคุณสมบัติเดียวกันด้วยกันแล้วตัดสั้นกลุ่มกับขนาดของ 1 Listและแล้วในที่สุดการเก็บรวบรวมพวกเขาเป็น

  List<YourPersonClass> listWithDistinctPersons =   persons.stream()
            //operators to remove duplicates based on person name
            .collect(Collectors.groupingBy(p -> p.getName()))
            .values()
            .stream()
            //cut short the groups to size of 1
            .flatMap(group -> group.stream().limit(1))
            //collect distinct users as list
            .collect(Collectors.toList());

รายการวัตถุที่แตกต่างสามารถพบได้โดยใช้:

 List distinctPersons = persons.stream()
                    .collect(Collectors.collectingAndThen(
                            Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person:: getName))),
                            ArrayList::new));

วิธีที่ง่ายที่สุดในการใช้งานนี้คือการข้ามไปยังคุณลักษณะการจัดเรียงเนื่องจากมีตัวเลือกComparatorที่สามารถสร้างได้โดยใช้คุณสมบัติขององค์ประกอบ จากนั้นคุณต้องกรองรายการที่ซ้ำกันซึ่งสามารถทำได้โดยใช้ statefull Predicateซึ่งใช้ข้อเท็จจริงว่าสำหรับสตรีมที่เรียงลำดับอิลิเมนต์ที่เท่ากันทั้งหมดอยู่ติดกัน:

Comparator<Person> c=Comparator.comparing(Person::getName);
stream.sorted(c).filter(new Predicate<Person>() {
    Person previous;
    public boolean test(Person p) {
      if(previous!=null && c.compare(previous, p)==0)
        return false;
      previous=p;
      return true;
    }
})./* more stream operations here */;

แน่นอน statefull Predicateไม่ด้ายปลอดภัย แต่ถ้าว่าเป็นความต้องการของคุณคุณสามารถย้ายตรรกะนี้เป็นและให้ดูแลกระแสของหัวข้อความปลอดภัยเมื่อใช้ของคุณCollector Collectorขึ้นอยู่กับสิ่งที่คุณต้องการจะทำกับกระแสขององค์ประกอบที่แตกต่างที่คุณไม่ได้บอกเราในคำถามของคุณ

จากคำตอบของ @ josketres ฉันได้สร้างวิธีการใช้งานทั่วไป:

คุณอาจจะทำเรื่องนี้ให้มากขึ้น Java 8 ง่ายโดยการสร้างนักสะสม

public static <T> Set<T> removeDuplicates(Collection<T> input, Comparator<T> comparer) {
    return input.stream()
            .collect(toCollection(() -> new TreeSet<>(comparer)));
}


@Test
public void removeDuplicatesWithDuplicates() {
    ArrayList<C> input = new ArrayList<>();
    Collections.addAll(input, new C(7), new C(42), new C(42));
    Collection<C> result = removeDuplicates(input, (c1, c2) -> Integer.compare(c1.value, c2.value));
    assertEquals(2, result.size());
    assertTrue(result.stream().anyMatch(c -> c.value == 7));
    assertTrue(result.stream().anyMatch(c -> c.value == 42));
}

@Test
public void removeDuplicatesWithoutDuplicates() {
    ArrayList<C> input = new ArrayList<>();
    Collections.addAll(input, new C(1), new C(2), new C(3));
    Collection<C> result = removeDuplicates(input, (t1, t2) -> Integer.compare(t1.value, t2.value));
    assertEquals(3, result.size());
    assertTrue(result.stream().anyMatch(c -> c.value == 1));
    assertTrue(result.stream().anyMatch(c -> c.value == 2));
    assertTrue(result.stream().anyMatch(c -> c.value == 3));
}

private class C {
    public final int value;

    private C(int value) {
        this.value = value;
    }
}

อาจจะมีประโยชน์สำหรับใครบางคน ฉันมีข้อกำหนดอื่นอีกเล็กน้อย มีรายชื่อวัตถุAจากบุคคลที่สามลบทั้งหมดที่มีA.bเขตข้อมูลเดียวกันสำหรับเดียวกันA.id( AวัตถุหลายA.idรายการในรายการเดียวกัน) พาร์ทิชันกระแสตอบโดยTagir Valeevแรงบันดาลใจให้ผมใช้กำหนดเองซึ่งผลตอบแทนCollector Map<A.id, List<A>>ง่ายๆflatMapจะทำส่วนที่เหลือ

 public static <T, K, K2> Collector<T, ?, Map<K, List<T>>> groupingDistinctBy(Function<T, K> keyFunction, Function<T, K2> distinctFunction) {
    return groupingBy(keyFunction, Collector.of((Supplier<Map<K2, T>>) HashMap::new,
            (map, error) -> map.putIfAbsent(distinctFunction.apply(error), error),
            (left, right) -> {
                left.putAll(right);
                return left;
            }, map -> new ArrayList<>(map.values()),
            Collector.Characteristics.UNORDERED)); }

ฉันมีสถานการณ์ที่ฉันควรจะได้รับองค์ประกอบที่แตกต่างจากรายการตาม 2 ปุ่ม หากคุณต้องการให้แตกต่างกันโดยขึ้นอยู่กับสองปุ่มหรืออาจจะเป็นคีย์ผสมให้ลองทำสิ่งนี้

class Person{
    int rollno;
    String name;
}
List<Person> personList;


Function<Person, List<Object>> compositeKey = personList->
        Arrays.<Object>asList(personList.getName(), personList.getRollno());

Map<Object, List<Person>> map = personList.stream().collect(Collectors.groupingBy(compositeKey, Collectors.toList()));

List<Object> duplicateEntrys = map.entrySet().stream()`enter code here`
        .filter(settingMap ->
                settingMap.getValue().size() > 1)
        .collect(Collectors.toList());

ในกรณีของฉันฉันต้องการควบคุมสิ่งที่เป็นองค์ประกอบก่อนหน้า จากนั้นฉันก็สร้างภาคแสดงสถานะที่ฉันควบคุมถ้าองค์ประกอบก่อนหน้านั้นแตกต่างจากองค์ประกอบปัจจุบันในกรณีนั้นฉันเก็บไว้

public List<Log> fetchLogById(Long id) {
    return this.findLogById(id).stream()
        .filter(new LogPredicate())
        .collect(Collectors.toList());
}

public class LogPredicate implements Predicate<Log> {

    private Log previous;

    public boolean test(Log atual) {
        boolean isDifferent = previouws == null || verifyIfDifferentLog(current, previous);

        if (isDifferent) {
            previous = current;
        }
        return isDifferent;
    }

    private boolean verifyIfDifferentLog(Log current, Log previous) {
        return !current.getId().equals(previous.getId());
    }

}

โซลูชันของฉันในรายการนี้:

List<HolderEntry> result ....

List<HolderEntry> dto3s = new ArrayList<>(result.stream().collect(toMap(
            HolderEntry::getId,
            holder -> holder,  //or Function.identity() if you want
            (holder1, holder2) -> holder1 
    )).values());

ในสถานการณ์ของฉันฉันต้องการค้นหาค่าที่แตกต่างและใส่ไว้ในรายการ

ในขณะที่คำตอบ upvoted ที่สูงที่สุดคือคำตอบที่ดีที่สุดอย่างแน่นอน wrt Java 8 แต่ในเวลาเดียวกันนั้นแย่ที่สุดในแง่ของประสิทธิภาพ หากคุณต้องการแอปพลิเคชั่นที่มีประสิทธิภาพต่ำให้ใช้งานต่อไป ความต้องการง่าย ๆ ในการแยกชุดชื่อบุคคลที่ไม่ซ้ำกันจะทำได้โดยเพียง "ต่อคน" และ "ตั้ง" สิ่งต่าง ๆ ยิ่งแย่ลงถ้ารายการมีขนาดใหญ่กว่า 10

พิจารณาว่าคุณมีคอลเลกชันวัตถุ 20 ชนิดดังนี้:

public static final List<SimpleEvent> testList = Arrays.asList(
            new SimpleEvent("Tom"), new SimpleEvent("Dick"),new SimpleEvent("Harry"),new SimpleEvent("Tom"),
            new SimpleEvent("Dick"),new SimpleEvent("Huckle"),new SimpleEvent("Berry"),new SimpleEvent("Tom"),
            new SimpleEvent("Dick"),new SimpleEvent("Moses"),new SimpleEvent("Chiku"),new SimpleEvent("Cherry"),
            new SimpleEvent("Roses"),new SimpleEvent("Moses"),new SimpleEvent("Chiku"),new SimpleEvent("gotya"),
            new SimpleEvent("Gotye"),new SimpleEvent("Nibble"),new SimpleEvent("Berry"),new SimpleEvent("Jibble"));

ตำแหน่งที่คุณคัดค้านSimpleEventมีลักษณะดังนี้:

public class SimpleEvent {

private String name;
private String type;

public SimpleEvent(String name) {
    this.name = name;
    this.type = "type_"+name;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getType() {
    return type;
}

public void setType(String type) {
    this.type = type;
}
}

และเพื่อทดสอบคุณมีJMHรหัสเช่นนี้ (โปรดทราบ im ใช้เดียวกันdistinctByKeyกริยาที่กล่าวถึงในคำตอบที่ได้รับการยอมรับ):

@Benchmark
@OutputTimeUnit(TimeUnit.SECONDS)
public void aStreamBasedUniqueSet(Blackhole blackhole) throws Exception{

    Set<String> uniqueNames = testList
            .stream()
            .filter(distinctByKey(SimpleEvent::getName))
            .map(SimpleEvent::getName)
            .collect(Collectors.toSet());
    blackhole.consume(uniqueNames);
}

@Benchmark
@OutputTimeUnit(TimeUnit.SECONDS)
public void aForEachBasedUniqueSet(Blackhole blackhole) throws Exception{
    Set<String> uniqueNames = new HashSet<>();

    for (SimpleEvent event : testList) {
        uniqueNames.add(event.getName());
    }
    blackhole.consume(uniqueNames);
}

public static void main(String[] args) throws RunnerException {
    Options opt = new OptionsBuilder()
            .include(MyBenchmark.class.getSimpleName())
            .forks(1)
            .mode(Mode.Throughput)
            .warmupBatchSize(3)
            .warmupIterations(3)
            .measurementIterations(3)
            .build();

    new Runner(opt).run();
}

จากนั้นคุณจะได้ผลลัพธ์มาตรฐานดังนี้:

Benchmark                                  Mode  Samples        Score  Score error  Units
c.s.MyBenchmark.aForEachBasedUniqueSet    thrpt        3  2635199.952  1663320.718  ops/s
c.s.MyBenchmark.aStreamBasedUniqueSet     thrpt        3   729134.695   895825.697  ops/s

และอย่างที่คุณเห็นการเรียบง่ายสำหรับแต่ละรายการจะดีกว่า 3 เท่าในปริมาณงานและคะแนนข้อผิดพลาดน้อยกว่าเมื่อเปรียบเทียบกับ Java 8 Stream

ที่สูงขึ้นผ่านที่ดีกว่าผลการดำเนินงาน

Here is the example
public class PayRoll {

    private int payRollId;
    private int id;
    private String name;
    private String dept;
    private int salary;


    public PayRoll(int payRollId, int id, String name, String dept, int salary) {
        super();
        this.payRollId = payRollId;
        this.id = id;
        this.name = name;
        this.dept = dept;
        this.salary = salary;
    }
} 

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class Prac {
    public static void main(String[] args) {

        int salary=70000;
        PayRoll payRoll=new PayRoll(1311, 1, "A", "HR", salary);
        PayRoll payRoll2=new PayRoll(1411, 2    , "B", "Technical", salary);
        PayRoll payRoll3=new PayRoll(1511, 1, "C", "HR", salary);
        PayRoll payRoll4=new PayRoll(1611, 1, "D", "Technical", salary);
        PayRoll payRoll5=new PayRoll(711, 3,"E", "Technical", salary);
        PayRoll payRoll6=new PayRoll(1811, 3, "F", "Technical", salary);
        List<PayRoll>list=new ArrayList<PayRoll>();
        list.add(payRoll);
        list.add(payRoll2);
        list.add(payRoll3);
        list.add(payRoll4);
        list.add(payRoll5);
        list.add(payRoll6);


        Map<Object, Optional<PayRoll>> k = list.stream().collect(Collectors.groupingBy(p->p.getId()+"|"+p.getDept(),Collectors.maxBy(Comparator.comparingInt(PayRoll::getPayRollId))));


        k.entrySet().forEach(p->
        {
            if(p.getValue().isPresent())
            {
                System.out.println(p.getValue().get());
            }
        });



    }
}

Output:

PayRoll [payRollId=1611, id=1, name=D, dept=Technical, salary=70000]
PayRoll [payRollId=1811, id=3, name=F, dept=Technical, salary=70000]
PayRoll [payRollId=1411, id=2, name=B, dept=Technical, salary=70000]
PayRoll [payRollId=1511, id=1, name=C, dept=HR, salary=70000]

หากคุณต้องการรายชื่อบุคคลต่อไปนี้จะเป็นวิธีที่ง่าย

Set<String> set = new HashSet<>(persons.size());
persons.stream().filter(p -> set.add(p.getName())).collect(Collectors.toList());

นอกจากนี้หากคุณต้องการที่จะหาที่แตกต่างกันหรือไม่ซ้ำกันรายชื่อ , ไม่ได้เป็นคนที่คุณสามารถทำได้โดยใช้วิธีการต่อไปนี้ทั้งสองได้เป็นอย่างดี

วิธีที่ 1: ใช้ distinct

persons.stream().map(x->x.getName()).distinct.collect(Collectors.toList());

วิธีที่ 2: ใช้ HashSet

Set<E> set = new HashSet<>();
set.addAll(person.stream().map(x->x.getName()).collect(Collectors.toList()));

รหัสที่ง่ายที่สุดที่คุณเขียนได้:

    persons.stream().map(x-> x.getName()).distinct().collect(Collectors.toList());