尝试重用现有的同类对象--享元模式

定义：尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。主要用于减少创建对象的数量，以减少内存占用和提高性能。

举个栗子：

现在有一种类：狗子，它有三个属性：颜色、颜值、运动量。有一个获取指定颜色的狗的工厂。这样，就可以定义一个容器，将狗存储起来，根据狗的颜色来获取对象。

1、狗：为了属性全面一点，就设置颜值和运动量为随机值，并重写toString方法。

public class Dog {

    // 永远产生随机数
    private static final Random RANDOM = new Random();

    /** 颜色 */
    private String color;

    /** 颜值 */
    private Integer faceScore = RANDOM.nextInt(100);

    /** 运动量 */
    private Integer exerciseVolume = RANDOM.nextInt(100);

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Integer getFaceScore() {
        return faceScore;
    }

    public void setFaceScore(Integer faceScore) {
        this.faceScore = faceScore;
    }

    public Integer getExerciseVolume() {
        return exerciseVolume;
    }

    public void setExerciseVolume(Integer exerciseVolume) {
        this.exerciseVolume = exerciseVolume;
    }

    @Override
    public String toString() {
        return "Dog [颜色：" + color + ", 颜值：" + faceScore + ", 运动量：" + exerciseVolume + "]";
    }
}

2、工厂：定义一个存储容器Map，颜色作为key。

public class Factory {

    // 容器
    private static final Map<String, Dog> DOG_MAP = new HashMap<>();

    private Factory() {
        throw new UnsupportedOperationException("不支持创建实例！");
    }

    public static Dog get(String color) {
        Dog dog = DOG_MAP.get(color);
        // 当容器中没有相似对象时，就创建一个，并放进容器
        if (Objects.isNull(dog)) {
            System.out.println("创建新对象...");
            dog = new Dog();
            dog.setColor(color);
            DOG_MAP.put(color, dog);
        }
        return dog;
    }
}

3、测试：可以看到，第一次获取某种颜色的狗时，由于容器中不存在指定的狗，所以会创建相应的狗对象并放进容器；当之后获取指定颜色的狗时，将直接从容器中获得。

public class FlyweightTest {
    public static void main(String[] args) {
        // 颜色数组
        String[] colors = {"black", "white", "flower", "yellow"};
        Random random = new Random();
        // 获取10只颜色随机的狗
        for (int i = 0; i < 10; i++) {
            Dog dog = Factory.get(colors[random.nextInt(colors.length)]);
            System.out.println(dog);
        }

    }
}

run

创建新对象...
Dog [颜色：black, 颜值：87, 运动量：8]
创建新对象...
Dog [颜色：flower, 颜值：77, 运动量：8]
创建新对象...
Dog [颜色：yellow, 颜值：14, 运动量：30]
创建新对象...
Dog [颜色：white, 颜值：82, 运动量：61]
Dog [颜色：white, 颜值：82, 运动量：61]
Dog [颜色：flower, 颜值：77, 运动量：8]
Dog [颜色：black, 颜值：87, 运动量：8]
Dog [颜色：white, 颜值：82, 运动量：61]
Dog [颜色：flower, 颜值：77, 运动量：8]
Dog [颜色：yellow, 颜值：14, 运动量：30]

优缺点

享元模式的优点在于它大幅度地降低内存中对象的数量。
但是，它做到这一点所付出的代价也是很高的：享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

使用场景

系统中存在大量相似对象
需要缓冲池的场景