Özel karşılaştırıcıyla TreeSet'e toplamak için akışları kullanma

Java 8'de çalışıyorum, şöyle bir TreeSettanımım var :

private TreeSet<PositionReport> positionReports = 
        new TreeSet<>(Comparator.comparingLong(PositionReport::getTimestamp));

PositionReport şu şekilde tanımlanan oldukça basit bir sınıftır:

public static final class PositionReport implements Cloneable {
    private final long timestamp;
    private final Position position;

    public static PositionReport create(long timestamp, Position position) {
        return new PositionReport(timestamp, position);
    }

    private PositionReport(long timestamp, Position position) {
        this.timestamp = timestamp;
        this.position = position;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public Position getPosition() {
        return position;
    }
}

Bu iyi çalışıyor.

Şimdi girdileri bir değerden daha eski olan TreeSet positionReportsyerden kaldırmak istiyorum timestamp. Ancak bunu ifade etmek için doğru Java 8 sözdizimini bulamıyorum.

Bu girişim aslında derler, ancak bana TreeSettanımsız bir karşılaştırıcıyla yeni bir şey verir :

positionReports = positionReports
        .stream()
        .filter(p -> p.timestamp >= oldestKept)
        .collect(Collectors.toCollection(TreeSet::new))

TreeSetBir karşılaştırıcı ile toplamak istediğimi nasıl ifade ederim Comparator.comparingLong(PositionReport::getTimestamp)?

Şöyle bir şey düşünürdüm

positionReports = positionReports
        .stream()
        .filter(p -> p.timestamp >= oldestKept)
        .collect(
            Collectors.toCollection(
                TreeSet::TreeSet(Comparator.comparingLong(PositionReport::getTimestamp))
            )
        );

Ancak bu, yöntem referansları için geçerli sözdizimi derlemez / görünmez.

Yöntem referansları, tatmin etmeye çalıştığınız hedefin şekline zaten uyan bir yönteme (veya yapıcıya) sahip olduğunuz zamanlar içindir. Bu durumda bir yöntem referansı kullanamazsınız çünkü hedeflediğiniz şekil Supplierhiçbir argüman almayan ve bir koleksiyon döndüren bir şeklidir , ancak sahip TreeSetolduğunuz şey, argüman alan bir kurucu ve bu argümanı belirtmeniz gerekir. dır-dir. Bu nedenle, daha az özlü yaklaşımı benimsemeli ve bir lambda ifadesi kullanmalısınız:

TreeSet<Report> toTreeSet(Collection<Report> reports, long timestamp) {
    return reports.stream().filter(report -> report.timestamp() >= timestamp).collect(
        Collectors.toCollection(
            () -> new TreeSet<>(Comparator.comparingLong(Report::timestamp))
        )
    );
}

Bu çok kolay, sadece bir sonraki kodu kullanın:

    positionReports = positionReports
        .stream()
        .filter(p -> p.timestamp >= oldestKept)
        .collect(
            Collectors.toCollection(()->new TreeSet<>(Comparator.comparingLong(PositionReport::getTimestamp)
)));

Sonunda bir SortedSet'e dönüştürebilirsiniz (ek kopyayı önemsemediğiniz sürece).

positionReports = positionReports
                .stream()
                .filter(p -> p.getTimeStamp() >= oldestKept)
                .collect(Collectors.toSet());

return new TreeSet(positionReports);

Akışları kullanmak zorunda kalmadan bunun için Koleksiyonu'ndan bir yöntem yoktur: default boolean removeIf(Predicate<? super E> filter). Görmek Javadoc .

Yani kodunuz şöyle görünebilir:

positionReports.removeIf(p -> p.timestamp < oldestKept);

TreeSet ile ilgili sorun, öğeleri sıralamak için istediğimiz karşılaştırıcının aynı zamanda sete öğe eklerken kopyaları tespit etmek için de kullanılmasıdır. Dolayısıyla, karşılaştırma işlevi iki öğe için 0 ise, birini yineleme olarak kabul ederek yanlışlıkla atar.

Yineleme tespiti, öğelerin ayrı bir doğru hashCode yöntemi ile yapılmalıdır. Tüm özellikleri (örnekteki id ve ad) dikkate alarak bir hashCode ile yinelemeleri önlemek için basit bir HashSet kullanmayı ve öğeleri alırken basit bir sıralı Liste döndürmeyi tercih ediyorum (örnekte yalnızca ada göre sıralama):

public class ProductAvailableFiltersDTO {

    private Set<FilterItem> category_ids = new HashSet<>();

    public List<FilterItem> getCategory_ids() {
        return category_ids.stream()
            .sorted(Comparator.comparing(FilterItem::getName))
            .collect(Collectors.toList());
    }

    public void setCategory_ids(List<FilterItem> category_ids) {
        this.category_ids.clear();
        if (CollectionUtils.isNotEmpty(category_ids)) {
            this.category_ids.addAll(category_ids);
        }
    }
}


public class FilterItem {
    private String id;
    private String name;

    public FilterItem(String id, String name) {
        this.id = id;
        this.name = name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof FilterItem)) return false;
        FilterItem that = (FilterItem) o;
        return Objects.equals(getId(), that.getId()) &&
                Objects.equals(getName(), that.getName());
    }

    @Override
    public int hashCode() {

        return Objects.hash(getId(), getName());
    }
}

positionReports = positionReports.stream()
                             .filter(p -> p.getTimeStamp() >= oldestKept)
                             .collect(Collectors.toCollection(() -> new 
TreeSet<PositionReport>(Comparator.comparingLong(PositionReport::getTimestamp))));