Applying functions to decorated objects I have an interface Animal with a class that implements it, Cat.
public interface Animal {
    public int price();
    public Breed.BreedType breedType();
}

public class Cat implements Animal {

    private int price;
    private Breed.BreedType breedType;

    public Cat(int price) {
        this.price = price;
    }

    public Cat(int price, Breed.BreedType breedType) {
        this.price = price;
        this.breedType = breedType;
    }

    @Override
    public int price() {
        return price;
    }

    @Override
    public Breed.BreedType breedType() {
        return breedType;
    }
}

I have decorated the Animal class with the following interface, Breed.
import java.util.List;

public interface Breed {
    public enum BreedType {
        RARE,
        EXOTIC
    }

    public int calculatePrice(List&lt;Animal&gt; animals);
}

The concrete decorator class looks as follows:
import java.util.List;

public class Exotic implements Breed {

    @Override
    public int calculatePrice(List&lt;Animal&gt; animals) {
        return animals.stream()
                .mapToInt(Animal::price)
                .map(i -&gt; i * 2)
                .sum();
    }
}

Finally I iterate over a collection of animals and apply the decorator to them to work out their total cost of special breed animals.
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

    public static void main(String[] args) {
        Cat cat1 = new Cat(100);
        Cat cat2 = new Cat(100, Breed.BreedType.EXOTIC);
        Cat cat3 = new Cat(100, Breed.BreedType.EXOTIC);

        Map&lt;Breed.BreedType, List&lt;Animal&gt;&gt; map = Stream.of(cat1, cat2, cat3)
                .filter(animal -&gt; animal.breedType() != null)
                .collect(Collectors.groupingBy(Animal::breedType, Collectors.toList()));

        int total = 0;
        for(Breed.BreedType breedType : map.keySet()) {
            if(breedType.equals(Breed.BreedType.EXOTIC)) {
                total += new Exotic().calculatePrice(map.get(breedType));
            }
        }
        System.out.println(total);
    }
}

This does not seem particularly flexible as I will end up with a giant if statement as more breeds are added. Is there a better way to do this? My enum and the corresponding method for the Exotic breed seem a bit disconnected.
I'm not much of a stream fan and your code itself seems rather good, so I'll skip directly to your architecture.
One note, through:
total += new Exotic().calculatePrice(map.get(breedType))

a += b is not shorthand for a = a + b, it is shorthand for a = (TYPE_A)(a + b). This is something to keep in mind, as it might silently truncate data, for example if a is an int and b is a float, no warning will be emitted by the compiler.

Let's sum it up:
interface Breed
    enum BreedType

interface Animal

class Cat implements Animal

What is odd here is that you have a Breed type, then decide not to use it and instead use a specialized enum for representing the breed. So what I'd rather expect would be to have a Cat which has the property Breed. Additionally, your handling of the price of a cat is odd. The cat gets assigned a price, which is then changed afterwards based on the breed, which means it really is more of a &quot;base price&quot; then the actual price of this cat.
So what I'd expect is the following setup:
public interface Breed {}

public class Cat implements Animal {
    public Breed getBreed();
    public int getPrice();
}

With getPrice here returning the actual price of this single cat. Or, an alternative would be to have an extra price calculator:
public interface Breed {}

public class Cat implements Animal {
    public Breed getBreed();
}

public class CatPriceCalculator {
    public int calculatePrice(Cat cat);
}

Depending on what you're trying to achieve, both solutions might be viable. But let's go with the first for now. To mimic your original code, let's implement Breed:
public interface Breed {
    // TODO Note that we do not support fractions here.
    public int getPriceMultiplier();
}

public class RegularBreed implements Breed {
    public int getPriceMultiplier() {
        return 1;
    }
}
public class ExitocBreed implements Breed {
    public int getPriceMultiplier() {
        return 2;
    }
}

This will allow us to calculate the price of a single cat by doing cat.getBasePrice() * cat.getBreed().getPriceMultiplier(). We could also map breeds as enum, similar to how you've done it:
public enum Breed {
    EXOTIC(2),
    REGULAR(1);
    
    private int priceMultiplier;
    
    private Breed(int priceMultiplier) {
        this.priceMultiplier = priceMultiplier;
    }
     
    public int getPriceMultiplier() {
        return priceMultiplier;
    }
}

But this has the downside that it is not extensible from the outside, as enums cannot be extended. So I'd suggest to stick with the interface for this one.
Looking again at my second suggestion to use an extra price calculator, this would have the upside that you can map the price of a single cat base on more properties, for example weight, color and so forth:
public class Cat extends Animal {
    public int getAge();
    public Breed getBreed();
    public Color getFurColor();
    public Quality getFurQuality();
    public int getWeight();
}

Now if we have an extra calculator class, all these properties can be weighted in there. Having an extra class for this might for example be necessary if we plan to support different markets. For example, a market of a cat-show will assess fur and color higher than other properties. On the other side, a meat market will assess age and weight higher than other properties. So decoupling the price calculation from your model classes might be preferable.