Stream API集合处理技巧
HashMap<String, Integer> dataMap = new HashMap<>();
dataMap.put("X", 10);
dataMap.put("Y", 20);
List<Integer> numberList = Arrays.asList(3, 6, 9, 12, 15, 15);
// 求数值总和
int total = numberList.stream().mapToInt(Integer::intValue).sum();
int accumulate = numberList.stream().reduce(0, Integer::sum);
int parallelSum = numberList.parallelStream().reduce(0, Integer::sum);
// 查找极值
Optional<Integer> maximum = numberList.stream().max(Integer::compareTo);
Optional<Integer> minimum = numberList.stream().min(Integer::compareTo);
minimum.ifPresent(val -> System.out.println("最小值: " + val));
// 统计信息汇总
IntSummaryStatistics stats = numberList.stream()
.mapToInt(Integer::intValue)
.summaryStatistics();
System.out.println("最大数: " + stats.getMax());
System.out.println("最小数: " + stats.getMin());
System.out.println("合计: " + stats.getSum());
System.out.println("均值: " + stats.getAverage());
// 数据去重
List<Integer> uniqueNumbers = numberList.stream()
.distinct()
.toList();
// 遍历输出
numberList.forEach(System.out::println);
dataMap.forEach((k, v) -> System.out.println(k + "=>" + v));
// 条件过滤与变换
List<String> wordList = Arrays.asList("hello", "world", "java");
List<String> processedWords = wordList.stream()
.filter(word -> word.length() > 4)
.map(String::toUpperCase)
.toList();
// 对象分组与聚合
List<Employee> employees = Arrays.asList(
new Employee("张三", 25),
new Employee("李四", 30),
new Employee("王五", 25)
);
Map<Integer, List<Employee>> groupedByAge = employees.stream()
.collect(Collectors.groupingBy(Employee::getAge));
int ageSum = employees.stream()
.mapToInt(Employee::getAge)
.sum();
// 嵌套对象处理
Optional<Organization> org = fetchOrganization();
String managerName = org.flatMap(Organization::getTeam)
.flatMap(Team::getLeader)
.map(Leader::getFullName)
.orElse("未指定");
int[] arrayData = {2, 4, 6, 8, 10};
int arraySum = Arrays.stream(arrayData).sum();
int[] sortedArray = Arrays.stream(arrayData).sorted().toArray();
异常处理最佳实践
// 自动资源管理
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
// 文件处理逻辑
} catch (IOException ex) {
// 异常处理
}
函数式接口简化回调机制
// 传统方式定义回调接口
public interface ResponseHandler {
void handleSuccess(String data);
void handleError(Exception error);
}
public void asyncRequest(ResponseHandler handler) {
try {
String result = performRequest();
handler.handleSuccess(result);
} catch (Exception ex) {
handler.handleError(ex);
}
}
// 传统调用方式
asyncRequest(new ResponseHandler() {
@Override
public void handleSuccess(String data) {
System.out.println("成功: " + data);
}
@Override
public void handleError(Exception error) {
System.err.println("失败: " + error.getMessage());
}
});
// 函数式接口优化后
@FunctionalInterface
public interface ResponseCallback {
void onSuccess(String result);
void onFailure(Exception error);
}
public void executeAsync(ResponseCallback callback) {
try {
String data = requestData();
callback.onSuccess(data);
} catch (Exception ex) {
callback.onFailure(ex);
}
}
// Lambda表达式调用
executeAsync(
result -> System.out.println("响应: " + result),
error -> System.err.println("错误: " + error.getMessage())
);
字符串处理优化策略
// 格式化字符串
String userName = "王小明";
int userAge = 22;
String userInfo = String.format("姓名：%s，年龄：%d岁", userName, userAge);
// 字符串拼接优化
// StringBuilder适用于单线程环境
StringBuilder builder = new StringBuilder();
builder.append("项目A").append("-").append("阶段1");
String projectInfo = builder.toString();
// StringBuffer适用于多线程环境
StringBuffer buffer = new StringBuffer();
buffer.append("模块B").append(":").append("完成");
String moduleStatus = buffer.toString();
// StringJoiner用于分隔符拼接
StringJoiner joiner = new StringJoiner("|");
joiner.add("数据1").add("数据2").add("数据3");
String joinedResult = joiner.toString();
// Java 11新增字符串方法
String multilineText = "第一行\n第二行";
System.out.println(multilineText.isBlank());
System.out.println(multilineText.lines().count());
// Java 14文本块特性
String xmlContent = """
<?xml version="1.0"?>
<root>
<element>内容</element>
</root>
""";
System.out.println(xmlContent);
并发编程优化方案
// 传统线程安全集合使用
Hashtable<String, Integer> legacyTable = new Hashtable<>();
synchronized (legacyTable) {
if (!legacyTable.containsKey("counter")) {
legacyTable.put("counter", 1);
} else {
legacyTable.put("counter", legacyTable.get("counter") + 1);
}
}
// 现代并发集合优化
ConcurrentMap<String, Integer> modernMap = new ConcurrentHashMap<>();
modernMap.putIfAbsent("counter", 0);
modernMap.computeIfPresent("counter", (key, value) -> value + 1);
// CompletableFuture异步编程
CompletableFuture<String> taskOne = CompletableFuture.supplyAsync(() -> processTaskA());
CompletableFuture<String> taskTwo = CompletableFuture.supplyAsync(() -> processTaskB());
CompletableFuture<String> mergedTasks = taskOne.thenCombine(taskTwo, (a, b) -> a + " | " + b);
// 超时控制
CompletableFuture<String> timeoutTask = CompletableFuture.supplyAsync(() -> longRunningTask());
try {
String outcome = timeoutTask.get(2, TimeUnit.SECONDS);
} catch (TimeoutException tex) {
// 超时处理逻辑
}
其他优化技术
惰性求值模式
// 延迟计算实现
Supplier<String> deferredCalculation = () -> {
// 复杂计算过程
return expensiveComputation();
};
String computedValue = deferredCalculation.get(); // 实际执行计算
对象映射转换
class User {
private String fullName;
private int userAge;
private double accountBalance;
}
class UserView {
private String name;
private int age;
}
// Function接口转换
Function<User, UserView> converter = user -> {
UserView view = new UserView();
view.name = user.getFullName();
view.age = user.getUserAge();
return view;
};
UserView userViewModel = converter.apply(userObject);
// BeanUtils工具转换
UserView targetView = new UserView();
BeanUtils.copyProperties(userObject, targetView);
