operacje na kolekcjach java 8

Jak za pomoca stream w java 8 znalezc z posrod listy najdrozsze ciasto

kod w linku: http://wklej.org/id/1930453/

o_O dla każdego ciasta liczysz ile kosztuje symując wartość składników a potem wybierasz maxa.

No tego momentu już doszedłem , natomiast nie wiem jak to zaimplementować

Jak juz zgadne jak wyglądają klasy których nie raczyłeś pokazać to napisze. Pokaż kod który juz masz.

Może:

cakes.stream().mapToInt(Cake::countIngredientsPrice).max();

Pełny kod

Klasa Cake
http://wklej.org/id/1930636/

Klasa Cakes
http://wklej.org/id/1930638/

Klasa Ingredient
http://wklej.org/id/1930640/

Klasa Helper - zadania do wykonania
http://wklej.org/id/1930641/

Ok no to po kolei. Mamy Cake które ma liste Ingredients. Najdroższe cake to takie które ma największą sumę wartości tych ingredientów.

        return ALL.stream()
                .max(Comparator.comparing(
                        cake -> cake.getIngredients()
                                .stream()
                                .mapToInt(i -> i.getPrice())
                                .sum()
                        )
                )
                .get();

edit: Wcześniej przekombinowałem :P

    private Cake get() {
        return ALL.stream().max(Comparator.comparing(cake -> cake.getIngredients().stream().mapToInt(i -> i.getPrice()).sum())).get();
    }

Dla porównania, kod w Scali:

def mostExpensiveCake(cakes: Seq[Cake]): Cake = cakes.maxBy(_.ingredients.map(_.price).sum)

;]

Ja bym to zrobił przez redukcję:

import java.util.List;
import java.util.LinkedList;
import java.util.Optional;

class Cake{
    public Integer price;
    public Cake(Integer _price){
        price=_price;
    }
    @Override
    public String toString(){
        return "cake "+price;
    }
}

public class HelloWorld{

     public static void main(String []args){
        List<Cake> cakes = new LinkedList<>();
        cakes.add( new Cake(5) );
        cakes.add( new Cake(12) );
        cakes.add( new Cake(9) );
        cakes.add( new Cake(8) );
        Optional<Cake> maks = cakes.stream().reduce( 
            (a,b)-> a.price>b.price?a:b
        );
        maks.ifPresent( System.out::println );
     }
}

EDIT:
w sumie to i tak wychodzi na to samo co z max, bo to też jest funkcja redukująca

Optional<Cake> maks = cakes.stream().max(
    (a,b)-> a.price-b.price
);

Najłatwiej to będzie po prostu zsumować, tzn.

Function<Cake, Integer> indSummator = (c -> c.getIngridients().stream().mapToInt().sum());

cakes.stream()
	.map(c -> new javafx.util.Pair<>(c, indSummator.apply(c))
	.sorted((p1, p2) -> p1.getValue().compareTo(p2.getValue())
	.findFirst().get();

@wartek01
Ale po co sortować, by wybrać maksa? Niepotrzebnie zwiększasz złożoność obliczeniową.

Blokuje temat bo autor żebra o gotowca i jeszcze kasuje treści swoich postów.