1
2
3
4
5

A[需要选择数据结构] → B{数据访问模式?}
B →|随机访问| C{需要排序?}
B →|顺序访问| D{访问顺序?}
B →|键值访问| E[哈希表]
B →|层次访问| F[树结构]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// ❌ 效率低的字符串拼接
String result = "";
for (int i = 0; i < 1000; i++) {
    result += "item" + i;
}

// ✅ 高效的字符串拼接
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("item").append(i);
}
String result = sb.toString();

1
2
3
4
5

// 选择合适的初始容量和负载因子
Map<String, Integer> map = new HashMap<>(16, 0.75f);

// 对于已知大小的数据，预设容量
Map<String, Integer> map = new HashMap<>((int)(expectedSize / 0.75f) + 1);

1
2
3
4
5

// 使用哈希表存储会话信息
Map<String, UserSession> sessionMap = new ConcurrentHashMap<>();

// 使用队列实现会话超时清理
Queue<SessionTimeout> timeoutQueue = new PriorityQueue<>();

1
2
3
4
5
6
7
8

// LRU缓存实现（LinkedHashMap + 双向链表）
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;
    }
}

1
2
3
4

// 使用栈管理游戏状态
Stack<GameState> stateStack = new Stack<>();
stateStack.push(new MenuState());
stateStack.push(new GamePlayState());

1
2
3

// 使用图结构和A*算法
Graph gameMap = new Graph();
List<Node> path = AStar.findPath(gameMap, start, goal);

1
2
3
4
5
6
7
8

// 使用队列缓冲数据流
BlockingQueue<DataPacket> buffer = new LinkedBlockingQueue<>(1000);

// 生产者
buffer.offer(packet);

// 消费者
DataPacket packet = buffer.poll(1, TimeUnit.SECONDS);

1
2
3

// 使用B+树构建数据库索引
BPlusTree<String, Record> index = new BPlusTree<>(degree);
index.insert(key, record);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 重用对象，减少GC压力
public class NodePool {
    private final Queue<TreeNode> pool = new LinkedList<>();

    public TreeNode acquire() {
        TreeNode node = pool.poll();
        return node != null ? node : new TreeNode();
    }

    public void release(TreeNode node) {
        node.reset();
        pool.offer(node);
    }
}

1
2
3

// 预分配适当大小，避免频繁扩容
List<String> list = new ArrayList<>(expectedSize);
Map<String, Integer> map = new HashMap<>(expectedSize * 4 / 3);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 使用位操作压缩存储
class CompactBitSet {
    private long[] words;

    public void set(int bitIndex) {
        int wordIndex = bitIndex >> 6; // 除以64
        int bitOffset = bitIndex & 63;  // 模64
        words[wordIndex] |= (1L << bitOffset);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// ❌ 创建大量临时对象
for (int i = 0; i < 1000000; i++) {
    String temp = "prefix" + i + "suffix";
    process(temp);
}

// ✅ 重用StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000000; i++) {
    sb.setLength(0);
    sb.append("prefix").append(i).append("suffix");
    process(sb.toString());
}