享元模式（Flyweight Pattern）

// 外部状态：字符位置（不可共享，随场景变化）
public class Position {
    private final int x;  // X坐标
    private final int y;  // Y坐标

    public Position(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }
}

// 抽象享元：字符接口
public interface Character {
    // 显示字符，接收外部状态（位置）
    void display(Position position);
}

// 具体享元：字母（共享对象，存储内部状态）
public class Letter implements Character {
    // 内部状态：字符值（如'A'，可共享，创建后不可变）
    private final char charValue;

    // 构造器初始化内部状态
    public Letter(char charValue) {
        this.charValue = charValue;
    }

    // 结合外部状态（位置）显示字符
    @Override
    public void display(Position position) {
        System.out.printf("字符 '%c' 显示在位置 (%d, %d)%n",
                charValue, position.getX(), position.getY());
    }
}

import java.util.HashMap;
import java.util.Map;

// 享元工厂：管理字符享元的创建与缓存
public class CharacterFactory {
    // 缓存享元对象：键为内部状态（字符值），值为享元对象
    private final Map<Character, Character> flyweights = new HashMap<>();

    // 获取享元：存在则返回缓存，不存在则创建并缓存
    public Character getCharacter(char charValue) {
        // 检查缓存
        Character character = flyweights.get(charValue);
        // 若不存在，创建新对象并缓存
        if (character == null) {
            character = new Letter(charValue);
            flyweights.put(charValue, character);
            System.out.printf("创建新字符享元：'%c'（当前缓存大小：%d）%n",
                    charValue, flyweights.size());
        } else {
            System.out.printf("复用字符享元：'%c'（当前缓存大小：%d）%n",
                    charValue, flyweights.size());
        }
        return character;
    }
}

// 客户端：使用字符享元
public class Client {
    public static void main(String[] args) {
        // 创建享元工厂
        CharacterFactory factory = new CharacterFactory();

        // 场景1：显示文档中的字符（多次出现相同字符）
        Character a1 = factory.getCharacter('A');
        a1.display(new Position(10, 20));  // A at (10,20)

        Character b = factory.getCharacter('B');
        b.display(new Position(15, 20));  // B at (15,20)

        Character a2 = factory.getCharacter('A');  // 复用已创建的'A'
        a2.display(new Position(30, 40));  // A at (30,40)

        Character a3 = factory.getCharacter('A');  // 再次复用
        a3.display(new Position(50, 60));  // A at (50,60)
    }
}

// 示例：LRU缓存策略（简化版）
public class LRUCharacterFactory {
    private final LinkedHashMap<Character, Character> flyweights = 
        new LinkedHashMap<>(16, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<Character, Character> eldest) {
                return size() > 10;  // 超过10个对象则淘汰最久未使用的
            }
        };
    // ... 其他代码与普通工厂类似
}

public class SingletonCharacterFactory {
    private static final SingletonCharacterFactory INSTANCE = new SingletonCharacterFactory();
    private SingletonCharacterFactory() {}  // 私有构造器
    public static SingletonCharacterFactory getInstance() { return INSTANCE; }
    // ... 缓存逻辑
}

// RecyclerView缓存复用核心逻辑（简化）
public class Recycler {
    // 缓存ViewHolder（享元对象）
    private final SparseArray<ViewHolder> cache = new SparseArray<>();

    // 获取缓存的ViewHolder，若无则创建
    public ViewHolder getViewHolder(int viewType) {
        ViewHolder holder = cache.get(viewType);
        if (holder == null) {
            holder = createViewHolder(viewType);  // 创建新对象
            cache.put(viewType, holder);
        }
        return holder;
    }
}