Java业务开发中的高效编程技巧

1. 集合处理优化

1.1 使用合适的集合类型

// 需要快速查找 - 使用HashSet/HashMap
Set<String> uniqueNames = new HashSet<>(); // O(1)查找
Map<String, User> userMap = new HashMap<>(); 

// 需要保持顺序 - LinkedHashSet/LinkedHashMap
Set<String> orderedNames = new LinkedHashSet<>(); // 保持插入顺序
Map<String, User> orderedUserMap = new LinkedHashMap<>();

// 需要排序 - TreeSet/TreeMap
Set<String> sortedNames = new TreeSet<>(); // 自动排序
Map<String, User> sortedUserMap = new TreeMap<>();

1.2 集合初始化时指定容量

// 不好的做法 - 默认大小，可能多次扩容
List<User> users = new ArrayList<>();

// 好的做法 - 指定初始容量
List<User> users = new ArrayList<>(expectedSize);
Map<String, User> userMap = new HashMap<>(expectedSize);

2. 流式处理(Stream)优化

2.1 避免在流中重复操作

// 不好的做法 - 多次调用size()
list.stream().filter(item -> list.size() > 10).forEach(...);

// 好的做法 - 先计算
int size = list.size();
list.stream().filter(item -> size > 10).forEach(...);

2.2 使用并行流处理大数据集

// 顺序处理
List<Result> results = bigList.stream()
    .map(this::compute)
    .collect(Collectors.toList());

// 并行处理
List<Result> results = bigList.parallelStream()
    .map(this::compute)
    .collect(Collectors.toList());

3. 字符串处理技巧

3.1 使用StringBuilder拼接字符串

// 不好的做法 - 产生多个中间字符串
String result = "";
for (String str : strings) {
    result += str;
}

// 好的做法
StringBuilder sb = new StringBuilder();
for (String str : strings) {
    sb.append(str);
}
String result = sb.toString();

3.2 使用StringJoiner或String.join()

// 传统方式
String joined = String.join(", ", list);

// 更灵活的方式
StringJoiner joiner = new StringJoiner(", ", "[", "]");
list.forEach(joiner::add);
String joined = joiner.toString();

4. 资源管理技巧

4.1 使用try-with-resources

// 传统方式 - 需要手动关闭
BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("file.txt"));
    // 使用br
} finally {
    if (br != null) {
        br.close();
    }
}

// 现代方式 - 自动关闭
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    // 使用br
}

4.2 使用I/O缓冲

// 不好的做法 - 无缓冲
try (FileInputStream fis = new FileInputStream("file.txt");
     InputStreamReader isr = new InputStreamReader(fis);
     BufferedReader br = new BufferedReader(isr)) {
    // 读取操作
}

// 好的做法 - 使用缓冲
try (BufferedReader br = Files.newBufferedReader(Paths.get("file.txt"))) {
    // 读取操作
}

5. 并发编程技巧

5.1 使用并发集合

// 传统同步集合 - 性能较低
List<String> syncList = Collections.synchronizedList(new ArrayList<>());

// 并发集合 - 更好的性能
List<String> concurrentList = new CopyOnWriteArrayList<>();
Map<String, String> concurrentMap = new ConcurrentHashMap<>();

5.2 使用CompletableFuture进行异步编程

// 顺序执行
Result1 r1 = service1.call();
Result2 r2 = service2.call();
Result3 r3 = service3.call();
process(r1, r2, r3);

// 并行执行
CompletableFuture<Result1> f1 = CompletableFuture.supplyAsync(service1::call);
CompletableFuture<Result2> f2 = CompletableFuture.supplyAsync(service2::call);
CompletableFuture<Result3> f3 = CompletableFuture.supplyAsync(service3::call);

CompletableFuture.allOf(f1, f2, f3)
    .thenAccept(__ -> process(f1.join(), f2.join(), f3.join()));

6. 缓存常用数据

6.1 使用内存缓存

// 简单实现
private static final Map<String, Data> CACHE = new ConcurrentHashMap<>();

public Data getData(String key) {
    return CACHE.computeIfAbsent(key, k -> loadDataFromDB(k));
}

6.2 使用Guava Cache

LoadingCache<String, Data> cache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(new CacheLoader<String, Data>() {
        public Data load(String key) {
            return loadDataFromDB(key);
        }
    });

// 使用
Data data = cache.get("key");

7. 数据库访问优化

7.1 使用批量操作

// 单条插入
for (User user : users) {
    userDao.insert(user); // 多次数据库往返
}

// 批量插入
userDao.batchInsert(users); // 一次数据库往返

7.2 使用JPA EntityGraph避免N+1查询

@EntityGraph(attributePaths = {"orders", "orders.items"})
User findWithOrdersById(Long id);

8. 日志记录技巧

8.1 使用占位符而非字符串拼接

// 不好的做法 - 即使日志级别不够也会执行字符串拼接
logger.debug("User " + userId + " performed action " + action);

// 好的做法
logger.debug("User {} performed action {}", userId, action);

8.2 延迟日志计算

// 使用lambda延迟计算
logger.debug("Some expensive calculation: {}", () -> doExpensiveCalculation());

9. 对象复用技巧

9.1 使用对象池

// 使用Apache Commons Pool
GenericObjectPool<ExpensiveObject> pool = new GenericObjectPool<>(
    new BasePooledObjectFactory<ExpensiveObject>() {
        @Override
        public ExpensiveObject create() throws Exception {
            return new ExpensiveObject();
        }
    });

// 使用
ExpensiveObject obj = pool.borrowObject();
try {
    // 使用对象
} finally {
    pool.returnObject(obj);
}

10. 设计模式应用

10.1 使用享元模式共享对象

// 享元工厂
public class FlyweightFactory {
    private static final Map<String, Flyweight> pool = new HashMap<>();
    
    public static Flyweight getFlyweight(String key) {
        return pool.computeIfAbsent(key, k -> new ConcreteFlyweight(k));
    }
}

// 使用
Flyweight f1 = FlyweightFactory.getFlyweight("shared");
Flyweight f2 = FlyweightFactory.getFlyweight("shared"); // 返回同一个实例

实际案例：订单处理优化

// 优化前的代码
public void processOrders(List<Order> orders) {
    for (Order order : orders) {
        // 每次循环都查询
        User user = userDao.findById(order.getUserId());
        Product product = productDao.findById(order.getProductId());
        Address address = addressDao.findById(order.getAddressId());
        
        // 处理逻辑
        processOrder(order, user, product, address);
    }
}

// 优化后的代码
public void processOrdersOptimized(List<Order> orders) {
    // 1. 收集所有ID
    Set<Long> userIds = orders.stream().map(Order::getUserId).collect(Collectors.toSet());
    Set<Long> productIds = orders.stream().map(Order::getProductId).collect(Collectors.toSet());
    Set<Long> addressIds = orders.stream().map(Order::getAddressId).collect(Collectors.toSet());
    
    // 2. 批量查询
    Map<Long, User> userMap = userDao.findByIdIn(userIds).stream()
        .collect(Collectors.toMap(User::getId, Function.identity()));
    Map<Long, Product> productMap = productDao.findByIdIn(productIds).stream()
        .collect(Collectors.toMap(Product::getId, Function.identity()));
    Map<Long, Address> addressMap = addressDao.findByIdIn(addressIds).stream()
        .collect(Collectors.toMap(Address::getId, Function.identity()));
    
    // 3. 并行处理订单
    orders.parallelStream().forEach(order -> {
        User user = userMap.get(order.getUserId());
        Product product = productMap.get(order.getProductId());
        Address address = addressMap.get(order.getAddressId());
        
        processOrder(order, user, product, address);
    });
}