wake-up-neo.net

java 8 So erhalten Sie eine eindeutige Liste für mehrere Eigenschaften

Wie kann man aus einer Liste von Objekten die eindeutige (aus zwei Eigenschaften bestehende) Liste abrufen. Zum Beispiel gibt es eine Liste von Objekten mit Namen und Preis der Eigenschaft .. Wie kann ich nun eine Liste mit eindeutigem Namen erhalten? oder Preis.
annehmen 

list<xyz> l1 = getlist(); // getlist will return the list.

Nun hat l1 folgende Eigenschaften (Name, Preis): -
n1, p1
n1, p2
n2, p1
n2, p3 

Nach dem Filter sollte die Liste nun
n1, p1
n2, p3

Ich habe versucht, so zu lösen -

public List<xyz> getFilteredList(List<xyz> l1) {

        return l1
                .stream()
                .filter(distinctByKey(xyz::getName))
                .filter(distinctByKey(xyz::getPrice))
                .collect(Collectors.toList());
    }

    private static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

Jetzt ist das Problem, wenn ich nach Namen filtern würde, würde die Liste zurückkehren -
n1, p1
n2, p1

und dann hätte es Filter auf den Preis laufen lassen, die zurückkehren -
n1, p1

das ist nicht das erwartete Ergebnis.

8
rcipher222

Fast wörtlich aus Antwort von Stuart Marks :

import Java.util.Arrays;
import Java.util.List;
import Java.util.Map;
import Java.util.concurrent.ConcurrentHashMap;
import Java.util.function.Function;
import Java.util.function.Predicate;
import Java.util.stream.Collectors;

class Class {

  public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
    Map<Object, Boolean> seen = new ConcurrentHashMap<>();
    return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
  }

  private static List<Pojo> getList() {
    return Arrays.asList(
      new Pojo("123", 100),
      new Pojo("123", 100),
      new Pojo("123", 100),
      new Pojo("456", 200)
    );
  }

  public static void main(String[] args) {

    System.out.println(getList().stream()
      // extract a key for each Pojo in here. 
      // concatenating name and price together works as an example
      .filter(distinctByKey(p -> p.getName() + p.getPrice()))
      .collect(Collectors.toList()));
  }

}

class Pojo {
  private final String name;
  private final Integer price;

  public Pojo(final String name, final Integer price) {
    this.name = name;
    this.price = price;
  }

  public String getName() {
    return name;
  }

  public Integer getPrice() {
    return price;
  }

  @Override
  public String toString() {
    final StringBuilder sb = new StringBuilder("Pojo{");
    sb.append("name='").append(name).append('\'');
    sb.append(", price=").append(price);
    sb.append('}');
    return sb.toString();
  }
}

Diese Hauptmethode ergibt: 

[Pojo {Name = '123', Preis = 100}, Pojo {Name = '456', Preis = 200}]

Bearbeiten

Der Preis wurde int je nach Aufforderung von Eugene gemacht.

Anmerkung: Sie könnten etwas interessanteres als Schlüssel verwenden, wenn Sie es ausarbeiten möchten:

import Java.util.Arrays;
import Java.util.List;
import Java.util.Map;
import Java.util.concurrent.ConcurrentHashMap;
import Java.util.function.Function;
import Java.util.function.Predicate;
import Java.util.stream.Collectors;

class Class {

  public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
    Map<Object, Boolean> seen = new ConcurrentHashMap<>();
    return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
  }

  private static List<Pojo> getList() {
    return Arrays.asList(
      new Pojo("123", 100),
      new Pojo("123", 100),
      new Pojo("123", 100),
      new Pojo("456", 200)
    );
  }

  private static class NameAndPricePojoKey {
    final String name;
    final int price;

    public NameAndPricePojoKey(final Pojo pojo) {
      this.name = pojo.getName();
      this.price = pojo.getPrice();
    }

    @Override
    public boolean equals(final Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;

      final NameAndPricePojoKey that = (NameAndPricePojoKey) o;

      if (price != that.price) return false;
      return name != null ? name.equals(that.name) : that.name == null;

    }

    @Override
    public int hashCode() {
      int result = name != null ? name.hashCode() : 0;
      result = 31 * result + price;
      return result;
    }
  }

  public static void main(String[] args) {

    System.out.println(getList().stream()
      // extract a key for each Pojo in here. 
      .filter(distinctByKey(NameAndPricePojoKey::new))
      .collect(Collectors.toList()));
  }

}

class Pojo {
  private String name;
  private Integer price;
  private Object otherField1;
  private Object otherField2;

  public Pojo(final String name, final Integer price) {
    this.name = name;
    this.price = price;
  }

  public String getName() {
    return name;
  }

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

  public Integer getPrice() {
    return price;
  }

  public void setPrice(final Integer price) {
    this.price = price;
  }

  public Object getOtherField1() {
    return otherField1;
  }

  public void setOtherField1(final Object otherField1) {
    this.otherField1 = otherField1;
  }

  public Object getOtherField2() {
    return otherField2;
  }

  public void setOtherField2(final Object otherField2) {
    this.otherField2 = otherField2;
  }

  @Override
  public boolean equals(final Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    final Pojo pojo = (Pojo) o;

    if (name != null ? !name.equals(pojo.name) : pojo.name != null) return false;
    if (price != null ? !price.equals(pojo.price) : pojo.price != null) return false;
    if (otherField1 != null ? !otherField1.equals(pojo.otherField1) : pojo.otherField1 != null) return false;
    return otherField2 != null ? otherField2.equals(pojo.otherField2) : pojo.otherField2 == null;

  }

  @Override
  public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + (price != null ? price.hashCode() : 0);
    result = 31 * result + (otherField1 != null ? otherField1.hashCode() : 0);
    result = 31 * result + (otherField2 != null ? otherField2.hashCode() : 0);
    return result;
  }

  @Override
  public String toString() {
    final StringBuilder sb = new StringBuilder("Pojo{");
    sb.append("name='").append(name).append('\'');
    sb.append(", price=").append(price);
    sb.append(", otherField1=").append(otherField1);
    sb.append(", otherField2=").append(otherField2);
    sb.append('}');
    return sb.toString();
  }
}
3
Andreas

Ich würde für etwas wie dieses gehen, das ziemlich einfach und flexibel ist und auf Ihrem Beispiel aufbaut:

public static <T> List<T> distinctList(List<T> list, Function<? super T, ?>... keyExtractors) {

    return list
        .stream()
        .filter(distinctByKeys(keyExtractors))
        .collect(Collectors.toList());
}

private static <T> Predicate<T> distinctByKeys(Function<? super T, ?>... keyExtractors) {

    final Map<List<?>, Boolean> seen = new ConcurrentHashMap<>();

    return t -> {

        final List<?> keys = Arrays.stream(keyExtractors)
            .map(ke -> ke.apply(t))
            .collect(Collectors.toList());

        return seen.putIfAbsent(keys, Boolean.TRUE) == null;

    };

}

Dies kann dann auf folgende Weise aufgerufen werden:

final List<Xyz> distinct = distinctList(list, Xyz::getName, Xyz::getPrice)
2
lukens

Hier ist meine Lösung basierend auf der Klasse Item, die eine name und eine price definiert:

public class Item {

    public String name;
    public double price;

    Item(String name, double price) {
        this.name = name;
        this.price = price;
    }
}

Die Anforderung besteht darin, nur Items von einem bestimmten List<Item> zu erhalten, die unterschiedliche names und verschiedene prices in der Reihenfolge haben, in der sie vorkommen.

Ich fange diese Anforderung, durch eine Klasse unterschieden zu werden, ItemWrapper:

public class ItemWrapper {

    Item item;

    ItemWrapper(Item item) {
        this.item = item;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof ItemWrapper)) return false;
        ItemWrapper other = (ItemWrapper) obj;
        return  Objects.equals(item.name, other.item.name) ||
                item.price == other.item.price;
    }

    @Override
    public int hashCode() {
        return 1;
    }
}

Jetzt haben wir alles, um einen bestimmten List<Item> von Artikeln zu filtern:

List<Item> items = Arrays.asList(
        new Item("name-1", 100.00),
        new Item("name-1", 555.00),
        new Item("name-2", 100.00),
        new Item("name-2", 999.99),
        new Item("name-3", 100.00),
        new Item("name-4", 555.00),
        new Item("name-5", 999.99)
);

wie folgt:

items.stream()
     .map(item -> new ItemWrapper(item))
     .distinct()
     .map(wrapper -> wrapper.item)
     .collect(Collectors.toList());
}

Die erfassten Gegenstände sind:

  • name = name-1, preis = 100.0
  • name = name-2, preis = 999,99
  • name = name-4, preis = 555.0
2
Harmlezz