Сортировка потока Java после суммирования - PullRequest
Новая
       22

Сортировка потока Java после суммирования

0 голосов
/ 17 декабря 2018 
list
.parallelStream()
.sorted(Comparator.comparingDouble(r -> r.getA() + r.getB()).reversed())

получить ошибку компиляции, cannot resolve method r.getA(), но 

list
.parallelStream()                                    
.sorted(Comparator.comparingDouble(r -> r.getA() + r.getB())

в порядке,

так как я могу сделать сортировку по r -> r.getA ()+ r.getB () и получить его в обратном порядке?

Ответы [ 2 ]

0 голосов
/ 17 декабря 2018

Вот три решения одной и той же проблемы.

Класс бобов

Item.java 

public Item {

double lPrice;
double hPrice;

/**
 * @param lPrice
 * @param hPrice
 */
public Item(double lPrice, double hPrice) {
    super();
    this.lPrice = lPrice;
    this.hPrice = hPrice;
}

public double getlPrice() {
    return lPrice;
}

public void setlPrice(double lPrice) {
    this.lPrice = lPrice;
}

public double gethPrice() {
    return hPrice;
}

public void sethPrice(double hPrice) {
    this.hPrice = hPrice;
}

@Override
public String toString() {
    return "Item [lPrice=" + lPrice + ", hPrice=" + hPrice + "]";
}
}

Класс драйвера 

public static void main(String[] args) {

    List<Item> list = new ArrayList<>();
    list.add(new Item(1.0, 0.0));       list.add(new Item(3.0, 0.0));       list.add(new Item(4.0, 0.0));
    list.add(new Item(6.0, 0.0));       list.add(new Item(5.0, 0.0));       list.add(new Item(7.0, 0.0));

    System.out.println("Without Sorting...");
    list.forEach(System.out::println);

    list.sort(Comparator.comparingDouble(i -> ((Item) i).getlPrice()+((Item) i).gethPrice() ).reversed());
    System.out.println("\n=== in descending order===");
    System.out.println("===Sort based on sum of lower price and higher price of item===");
    list.forEach(System.out::println);

    list.clear();
    list.add(new Item(1.0, 0.0));       list.add(new Item(3.0, 0.0));       list.add(new Item(4.0, 0.0));
    list.add(new Item(6.0, 0.0));       list.add(new Item(5.0, 0.0));       list.add(new Item(7.0, 0.0));

    list = list.parallelStream().sorted(Comparator.comparingDouble(i -> ((Item) i).getlPrice()+((Item) i).gethPrice() ).reversed()).collect(Collectors.toList());
    System.out.println("\n=== Another Sol'n in descending order===");
    System.out.println("===Sort based on sum of lower price and higher price of item===");
    list.forEach(System.out::println);

    list.clear();
    list.add(new Item(1.0, 0.0));       list.add(new Item(3.0, 0.0));       list.add(new Item(4.0, 0.0));
    list.add(new Item(6.0, 0.0));       list.add(new Item(5.0, 0.0));       list.add(new Item(7.0, 0.0));


    list.sort((a1,a2) -> {
        double item1 = a1.getlPrice()+a1.gethPrice();
        double item2 = a2.getlPrice()+a2.gethPrice();
        return -Double.compare(item1, item2);
    });
    System.out.println("\n===Here is one more Solution===");
    list.forEach(System.out::println);
 }

Вывод.

Без сортировки ...

Item [lPrice = 1.0, hPrice =0.0]

Item [lPrice = 3.0, hPrice = 0.0]

Item [lPrice = 4.0, hPrice = 0.0]

Item [lPrice = 6.0, hPrice = 0.0]

Item [lPrice = 5.0, hPrice = 0.0]

Item [lPrice = 7.0, hPrice = 0.0]

=== в порядке убывания ===

=== Сортировка на основе суммы более низкой цены и более высокой цены товара ===

Item [lPrice = 7.0, hPrice = 0.0]

Item [lPrice = 6.0, hPrice= 0.0]

Элемент [lPrice = 5.0, hPrice = 0.0]

Элемент [lPrice = 4.0, hPrice = 0.0]

Элемент [lPrice = 3.0, hPrice = 0.0]

Item [lPrice = 1.0, hPrice = 0.0]

=== Другой Sol'n в порядке убывания ===

=== Сортировать по суммеболее низкая цена и более высокая цена товара ===

пункт [lPrice = 7.0, hPrice = 0.0]

Элемент [lPrice = 6.0, hPrice = 0.0]

Item [lPrice = 5.0, hPrice = 0.0]

Item [lPrice =4.0, hPrice = 0.0]

Item [lPrice = 3.0, hPrice = 0.0]

Item [lPrice = 1.0, hPrice = 0.0]

=== Вот одинбольше решения ===

Item [lPrice = 7.0, hPrice = 0.0]

Item [lPrice = 6.0, hPrice = 0.0]

Item [lPrice = 5.0, hPrice= 0.0]

Элемент [lPrice = 4.0, hPrice = 0.0]

Элемент [lPrice = 3.0, hPrice = 0.0]

Элемент [lPrice = 1.0, hPrice = 0.0]

Вот полное изображение программы с выводом

0 голосов
/ 17 декабря 2018

Один из способов сделать это - набрать ToDoubleFunction как: 

list.parallelStream()
    .sorted(Comparator.comparingDouble((ToDoubleFunction<C>) r -> r.getA() + r.getB())
            .reversed());

Хотя я бы предпочел явно создать Comparator<C> как 

list.parallelStream()
        .sorted(((Comparator<C>) (o1, o2) -> Double.compare(o1.getA() + o1.getB(), o2.getA() + o2.getB()))
                .reversed());

Примечание : C - это тип вашего объекта, который также составляет рассматриваемый list.

...