Java 最佳实践总结

总结 Java 开发中的最佳实践，帮助编写更高质量、更易维护的代码。

一、编码规范

1.1 命名规范

// 类名：PascalCase
public class UserService {}

// 方法/变量：camelCase
public void createUser() {}
private int userCount;

// 常量：UPPER_SNAKE_CASE
private static final int MAX_SIZE = 100;

// 泛型：单个大写字母
public class Box<T> {}
public <K, V> Map<K, V> createMap() {}

1.2 注释规范

/**
 * 用户服务类
 * 
 * <p>提供用户相关的 CRUD 操作</p>
 * 
 * @author Your Name
 * @version 1.0
 * @see User
 */
public class UserService {
    
    /**
     * 创建用户
     * 
     * @param name 用户名称，不能为空
     * @param email 用户邮箱，必须是有效邮箱格式
     * @return 创建的用户对象
     * @throws IllegalArgumentException 当参数无效时
     * @throws UserExistsException 当用户已存在时
     */
    public User createUser(String name, String email) {
        // ...
    }
}

二、集合使用

2.1 选择合适的集合

// 需要快速随机访问
List<String> list = new ArrayList<>();

// 需要频繁插入删除
List<String> list = new LinkedList<>();

// 需要去重
Set<String> set = new HashSet<>();

// 需要有序
Set<String> set = new LinkedHashSet<>();
Map<String, Integer> map = new LinkedHashMap<>();

// 需要排序
Map<String, Integer> map = new TreeMap<>();

// 高并发场景
List<String> list = new CopyOnWriteArrayList<>();
Map<String, Integer> map = new ConcurrentHashMap<>();

2.2 集合操作

// ✅ 推荐：使用 Stream API
List<String> names = users.stream()
    .filter(u -> u.getAge() > 18)
    .map(User::getName)
    .collect(Collectors.toList());

// ✅ 推荐：使用 computeIfAbsent
map.computeIfAbsent(key, k -> createValue(k));

// ❌ 避免：手动检查
if (!map.containsKey(key)) {
    map.put(key, createValue(key));
}

三、异常处理

3.1 异常使用原则

// ✅ 推荐：捕获具体异常
try {
    readFile();
} catch (FileNotFoundException e) {
    log.error("File not found", e);
}

// ❌ 避免：捕获过于宽泛
try {
    readFile();
} catch (Exception e) {
    // 不知道发生了什么异常
}

// ✅ 推荐：不要吞掉异常
try {
    process();
} catch (IOException e) {
    log.error("Processing failed", e);
    throw new BusinessException("处理失败", e);
}

// ❌ 避免：吞掉异常
try {
    process();
} catch (IOException e) {
    // 什么都不做
}

3.2 try-with-resources

// ✅ 推荐：自动关闭资源
try (FileInputStream fis = new FileInputStream("file.txt");
     BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
    return br.readLine();
}

// ❌ 避免：手动关闭
FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
    // ...
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            // ...
        }
    }
}

四、性能优化

4.1 字符串操作

// ✅ 推荐：字符串字面量比较
if ("success".equals(status)) {}

// ❌ 避免：可能 NPE
if (status.equals("success")) {}

// ✅ 推荐：循环外创建 StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}

// ❌ 避免：循环内创建
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;  // 每次创建新对象
}

4.2 集合优化

// ✅ 推荐：预估容量
List<String> list = new ArrayList<>(1000);
Map<String, Integer> map = new HashMap<>(1000);

// ❌ 避免：频繁扩容
List<String> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    list.add(String.valueOf(i));  // 多次扩容
}

五、并发编程

5.1 线程安全

// ✅ 推荐：使用并发集合
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// ❌ 避免：手动同步
Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());

// ✅ 推荐：使用原子类
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();

// ❌ 避免：volatile 不保证原子性
volatile int count = 0;
count++;  // 非原子操作

5.2 线程池使用

// ✅ 推荐：手动创建线程池
ExecutorService executor = new ThreadPoolExecutor(
    10,  // 核心线程数
    50,  // 最大线程数
    60,  // 空闲存活时间
    TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100),  // 有界队列
    new ThreadFactoryBuilder().setNameFormat("pool-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
);

// ❌ 避免：使用 Executors 创建
ExecutorService executor = Executors.newFixedThreadPool(10);
// 可能 OOM

六、代码质量

6.1 单一职责

// ❌ 违反单一职责
public class UserService {
    public User createUser() {}
    public void sendEmail() {}
    public void generateReport() {}
}

// ✅ 符合单一职责
public class UserService {
    public User createUser() {}
}

public class EmailService {
    public void sendEmail() {}
}

public class ReportService {
    public void generateReport() {}
}

6.2 依赖注入

// ❌ 硬编码依赖
public class UserService {
    private UserRepository repository = new UserRepositoryImpl();
}

// ✅ 依赖注入
public class UserService {
    private final UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

七、总结

Java 最佳实践核心要点：

最佳实践是经验的总结，但也要根据实际场景灵活运用。