Applying functions to decorated objects
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.