Java代码简化之道：从冗余到优雅的20个关键技巧

Java代码简化之道：从冗余到优雅的20个关键技巧

一、现代Java特性运用

1. 模式匹配（Java 16+）

传统写法：

if (obj instanceof String) {
    String str = (String) obj;
    if (str.length() > 5) {
        // ...
    }
}

简化版：

if (obj instanceof String str && str.length() > 5) {
    // 直接使用str变量
}

2. 增强型Switch表达式（Java 14+）

传统写法：

String type;
switch (status) {
    case 200: type = "OK"; break;
    case 404: type = "Not Found"; break;
    default: type = "Unknown";
}

简化版：

String type = switch (status) {
    case 200 -> "OK";
    case 404 -> "Not Found";
    default -> "Unknown";
};

二、Stream API高效实践

3. 集合转换的黄金法则

传统循环：

List<String> filtered = new ArrayList<>();
for (User user : users) {
    if (user.getAge() > 18) {
        filtered.add(user.getName());
    }
}

Stream简化：

List<String> filtered = users.stream()
    .filter(u -> u.getAge() > 18)
    .map(User::getName)
    .toList();

4. 分组统计的魔法

传统方式：

Map<Department, List<Employee>> map = new HashMap<>();
for (Employee emp : employees) {
    Department dept = emp.getDepartment();
    if (!map.containsKey(dept)) {
        map.put(dept, new ArrayList<>());
    }
    map.get(dept).add(emp);
}

Collectors优化：

Map<Department, List<Employee>> map = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));

三、空值处理的艺术

5. Optional的深度应用

传统判空：

String city = null;
if (user != null) {
    Address addr = user.getAddress();
    if (addr != null) {
        city = addr.getCity();
    }
}

Optional链式处理：

String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

6. Objects工具类妙用

冗余校验：

if (name == null || name.isEmpty()) {
    throw new IllegalArgumentException();
}

简洁校验：

String validName = Objects.requireNonNullElseGet(name, () -> "default");

四、设计模式与架构优化

7. 策略模式+Lambda

传统实现：

interface ValidationStrategy {
    boolean execute(String s);
}

class LengthStrategy implements ValidationStrategy {
    public boolean execute(String s) {
        return s.length() > 8;
    }
}

// 使用
validator.setStrategy(new LengthStrategy());

Lambda简化：

validator.setStrategy(s -> s.length() > 8);

8. 构建者模式革新

传统Builder：

User user = new UserBuilder()
    .name("Alice")
    .age(30)
    .build();

记录类+紧凑写法（Java 16+） ：

record User(String name, int age) {}

User user = new User("Alice", 30);

五、高效工具集成

9. Lombok自动生成

传统POJO：

public class User {
    private String name;
    private int age;
    
    // 手动编写getter/setter/构造方法/toString等
}

Lombok优化：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
}

10. Guava预处理

集合创建：

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");

工厂方法优化：

List<String> list = Lists.newArrayList("a", "b", "c");

六、函数式编程技巧

11. 方法引用代替Lambda

原始Lambda

users.forEach(u -> System.out.println(u));

方法引用优化：

users.forEach(System.out::println);

12. 函数式接口组合

传统条件判断：

Predicate<String> longPredicate = s -> s.length() > 10;
Predicate<String> numberPredicate = s -> s.matches("\\d+");

if (longPredicate.test(input) && numberPredicate.test(input)) {
    // ...
}

组合优化：

Predicate<String> combined = longPredicate.and(numberPredicate);
if (combined.test(input)) {
    // ...
}

七、异常处理精简

13. try-with-resources优化

传统资源管理：

BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("file.txt"));
    // 处理逻辑
} finally {
    if (br != null) {
        br.close();
    }
}

自动资源管理：

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    // 自动关闭资源
}

八、并发编程简化

14. CompletableFuture链式调用

传统异步处理

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<String> future1 = executor.submit(() -> fetchData1());
Future<String> future2 = executor.submit(() -> fetchData2());

String result1 = future1.get();
String result2 = future2.get();
// 合并结果...

函数式异步：

CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> fetchData1());
CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> fetchData2());

cf1.thenCombine(cf2, (r1, r2) -> processResults(r1, r2))
   .thenAccept(System.out::println);

九、元编程技巧

15. 注解处理器应用

传统校验代码：

public void saveUser(User user) {
    if (user.getName() == null) {
        throw new IllegalArgumentException("姓名不能为空");
    }
    if (user.getAge() < 18) {
        throw new IllegalArgumentException("年龄不合法");
    }
    // 持久化操作...
}

注解校验优化：

public void saveUser(@NotNull @Valid User user) {
    // 自动校验通过后执行
}

十、代码结构优化

16. 卫语句取代嵌套

深层嵌套：

public void process(Order order) {
    if (order != null) {
        if (order.isValid()) {
            if (order.getItems().size() > 0) {
                // 核心逻辑
            }
        }
    }
}

卫语句优化：

public void process(Order order) {
    if (order == null) return;
    if (!order.isValid()) return;
    if (order.getItems().isEmpty()) return;
    
    // 核心逻辑
}

最佳实践原则：

1. 优先使用Java标准库特性
2. 保持方法不超过15行
3. 避免过度设计导致的复杂化
4. 使用静态代码分析工具（SonarQube/Checkstyle）
5. 定期进行代码重构（IDE重构功能）

性能考量：

• Stream API在小型集合处理时可能有性能损耗
• Optional包装会创建额外对象
• 方法引用比Lambda更易被JIT优化

通过合理运用这些技巧，开发者可以在保持代码可读性的同时，将代码量减少30%-50%。但需注意：简化不是目的，清晰的表达和可维护性才是核心目标。