Поиск нескольких значений в классе данных в ArrayList

Хм, есть хитрый способ сделать это с помощью distinct, переопределяя hashCode и equals. Нужно заботиться об этом, когда нужен другой вид для вашего класса.

public class Test {
    public static void main(String[] args) {
        ArrayList<Customs> customsList = new ArrayList<Customs>();
        Customs c1 = new Customs(123L, "bad", 23d, 34d);
        Customs c2 = new Customs(122L, "bad", 23d, 34d);
        Customs c3 = new Customs(125L, "bad", 23d, 34d);
        Customs c4 = new Customs(122L, "bad", 23d, 34d);
        Customs c5 = new Customs(122L, "bad", 23d, 34d);
        Customs c6 = new Customs(123L, "bad", 23d, 34d);
        customsList.add(c1);
        customsList.add(c2);
        customsList.add(c3);
        customsList.add(c4);
        customsList.add(c5);
        customsList.add(c6);

        customsList.stream().distinct().collect(Collectors.toList()).forEach(t -> {
                    System.out.println(t.getUserId());
                    System.out.println(t.getItemPrice());
                    System.out.println(t.getWeight());
                }
        );
    }
}

class Customs {
    private long userId;

    private String customLabel;
    private Double itemPrice;
    private Double weight;

    public Customs(long userId, String customLabel, Double itemPrice, Double weight) {
        this.userId = userId;
        this.customLabel = customLabel;
        this.itemPrice = itemPrice;
        this.weight = weight;
    }

    public long getUserId() {
        return userId;
    }

    public void setUserId(long userId) {
        this.userId = userId;
    }

    public String getCustomLabel() {
        return customLabel;
    }

    public void setCustomLabel(String customLabel) {
        this.customLabel = customLabel;
    }

    public Double getItemPrice() {
        return itemPrice;
    }

    public void setItemPrice(Double itemPrice) {
        this.itemPrice = itemPrice;
    }

    public Double getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }

    @Override
    public boolean equals(Object o) { //Override equals method for distinct, at the same time add the weight and itemPrice, it's a tricky way. if you want to do that, you need to make sure, there will be no other sort need.
        if (!(o instanceof Customs)) {
            return false;
        }
        Customs c = (Customs) o;
        if (this.userId == c.userId) {
            c.itemPrice += this.itemPrice;
            c.weight += this.weight;
            return true;
        }
        return false;
    }

    @Override
    public int hashCode() { //Override hashCode for distinct
        return Long.valueOf(this.userId).hashCode();
    }


//getters and setters
}

Есть вероятно однострочник для Java 8, но я предпочитаю избегать его, если мне это нужно. Обратите внимание, что это решение предназначено исключительно для Java 8.

По сути, процесс, которому вы должны следовать:

• Разделите ваши элементы на соответствующие сегменты (по идентификатору пользователя)
• Соедините элементы вместе
• Возвращает новый список, содержащий отдельный элемент.

Вы не указываете, какой customLabel выигрывает в целом, но вот подход, который объединяет его с последним.

Добавьте этот метод в Customs:

public void combine(Customs another) {
    this.userId = another.getUserId();
    this.customLabel = another.getCustomLabel();
    this.itemPrice = null == this.itemPrice ? another.getItemPrice() : this.itemPrice + another.getItemPrice();
    this.weight = null == this.weight ? another.getWeight() : this.weight + another.getWeight();
}

Следующие строки кода разбивают описанные выше шаги. Я использую сборщик здесь, чтобы объединить элементы вместе на заключительном этапе. По мере продвижения я в основном добавляю элементы в другой список для окончательного разбора.

final Map<String, List<Customs>> groupedCustomsElements = customsList.stream()
                                                                     .collect(Collectors.groupingBy(Customs::getUserId));
final List<Customs> combinedResult = new ArrayList<>();
for (String s : groupedCustomsElements.keySet()) {
    combinedResult.add(groupedCustomsElements.get(s)
                                             .stream()
                                             .collect(Customs::new, Customs::combine, Customs::combine));
}

Более простым решением может быть создание собственного пользовательского списка, который расширяет ArrayList и дополняет метод add в соответствии с вашими потребностями.

class CustomCombiningList extends ArrayList<Customs> {

    @Override
    public boolean add(Customs e) {
        int idx = indexOf(e);
        if(idx != -1) {
            add(idx, get(idx).combineAndReturn(e));
            remove(idx + 1); // clean up unneeded object; worth a unit test
        } else {
            super.add(e);
        }
        return true;
    }
}

Для этого потребуются два новых метода — combineAndReturn, который фактически возвращает результат combine, и определение equals() для вашего элемента Customs. Это может быть красивее для чтения, чем запутанная лямбда.

Я не буду повторять ответ Макото о том, как это сделать в Java8. Вот как это сделать в Java 6:

    Map<String, Customs> groupedCustoms = new LinkedHashMap<String, Customs>();

    for (Customs custom : customs) {
        Customs aggrCustom = groupedCustoms.get(custom.getUserId());
        if (aggrCustom == null) {
            // create new aggregated record
            aggrCustom = new Customs(custom);
            groupedCustoms.put(custom.getUserId(), aggrCustom);
        } else {
            aggrCustom.aggregateWith(custom);
        }
    }

    List<Custom> results = new ArrayList<Customs>(groupedCustoms.values());

Я предполагаю, что исходные начальные Customs хранятся в List<Customs> customs. Также я предполагаю, что в Customs есть конструктор копирования, который принимает еще один Customs в качестве аргумента и копирует его поля (аналог clone), и метод aggregateWith, который принимает еще один Customs в качестве аргумента и добавляет свои метрические поля к текущему.

Использование LinkedHashMap для группировки записей необходимо для того, чтобы сделать группировку "стабильной", т.е. сохранить первоначальный порядок записей.