本文目录导读：
我来为你详细介绍Java Stream中拼接和整合数据的各种案例。
基础拼接操作
字符串拼接
import java.util.*;
import java.util.stream.Collectors;
public class StreamConcatExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
// 1. 使用Collectors.joining
String joined = names.stream()
.collect(Collectors.joining(", "));
System.out.println(joined); // Alice, Bob, Charlie, David
// 2. 带前缀和后缀
String joinedWithDecoration = names.stream()
.collect(Collectors.joining(", ", "[", "]"));
System.out.println(joinedWithDecoration); // [Alice, Bob, Charlie, David]
}
}
对象属性拼接
class User {
private String name;
private int age;
private String email;
// 构造方法、getter、setter
public User(String name, int age, String email) {
this.name = name;
this.age = age;
this.email = email;
}
// getter方法
public String getName() { return name; }
public int getAge() { return age; }
public String getEmail() { return email; }
}
public class ObjectConcatExample {
public static void main(String[] args) {
List<User> users = Arrays.asList(
new User("Alice", 25, "alice@example.com"),
new User("Bob", 30, "bob@example.com"),
new User("Charlie", 28, "charlie@example.com")
);
// 1. 拼接特定属性
String names = users.stream()
.map(User::getName)
.collect(Collectors.joining(", "));
System.out.println(names); // Alice, Bob, Charlie
// 2. 拼接多个属性
String userInfo = users.stream()
.map(u -> String.format("%s (%d岁)", u.getName(), u.getAge()))
.collect(Collectors.joining("; "));
System.out.println(userInfo); // Alice (25岁); Bob (30岁); Charlie (28岁)
// 3. 条件拼接
String adultNames = users.stream()
.filter(u -> u.getAge() > 26)
.map(User::getName)
.collect(Collectors.joining(", "));
System.out.println(adultNames); // Bob, Charlie
}
}
复杂数据整合
import java.util.stream.Stream;
public class ComplexDataIntegration {
public static void main(String[] args) {
// 1. 多个Stream合并
Stream<String> stream1 = Stream.of("A", "B", "C");
Stream<String> stream2 = Stream.of("D", "E", "F");
Stream<String> stream3 = Stream.of("G", "H", "I");
String merged = Stream.concat(
Stream.concat(stream1, stream2), stream3
).collect(Collectors.joining("-"));
System.out.println(merged); // A-B-C-D-E-F-G-H-I
// 2. 扁平化嵌套集合
List<List<String>> nestedLists = Arrays.asList(
Arrays.asList("1", "2", "3"),
Arrays.asList("4", "5", "6"),
Arrays.asList("7", "8", "9")
);
String flatResult = nestedLists.stream()
.flatMap(Collection::stream)
.collect(Collectors.joining(","));
System.out.println(flatResult); // 1,2,3,4,5,6,7,8,9
}
}
分组和聚合整合
import java.util.Map;
import java.util.stream.Collectors;
public class GroupAggregationExample {
public static void main(String[] args) {
List<User> users = Arrays.asList(
new User("Alice", 25, "alice@example.com"),
new User("Bob", 30, "bob@example.com"),
new User("Charlie", 25, "charlie@example.com"),
new User("David", 30, "david@example.com")
);
// 1. 按年龄分组并拼接姓名
Map<Integer, String> ageToNames = users.stream()
.collect(Collectors.groupingBy(
User::getAge,
Collectors.mapping(
User::getName,
Collectors.joining(", ")
)
));
System.out.println(ageToNames);
// {25=Alice, Charlie, 30=Bob, David}
// 2. 按年龄分组拼接详细信息
Map<Integer, String> userDetails = users.stream()
.collect(Collectors.groupingBy(
User::getAge,
Collectors.mapping(
u -> String.format("%s(%s)", u.getName(), u.getEmail()),
Collectors.joining("; ")
)
));
System.out.println(userDetails);
}
}
真实业务场景
public class BusinessExamples {
// 场景1: 生成订单摘要
static class OrderItem {
private String productName;
private int quantity;
private double price;
public OrderItem(String productName, int quantity, double price) {
this.productName = productName;
this.quantity = quantity;
this.price = price;
}
// getter...
public String getProductName() { return productName; }
public int getQuantity() { return quantity; }
public double getPrice() { return price; }
}
public static void main(String[] args) {
List<OrderItem> items = Arrays.asList(
new OrderItem("苹果", 3, 5.0),
new OrderItem("香蕉", 2, 3.5),
new OrderItem("橙子", 5, 4.0)
);
// 生成订单摘要
String orderSummary = items.stream()
.map(item -> String.format("%s x%d (¥%.2f)",
item.getProductName(),
item.getQuantity(),
item.getPrice()))
.collect(Collectors.joining("\n", "===== 订单明细 =====\n",
"\n==================="));
System.out.println(orderSummary);
// 场景2: 生成标签组合
List<String> tags = Arrays.asList("Java", "Python", "JavaScript");
String tagStr = tags.stream()
.map(tag -> "#" + tag)
.collect(Collectors.joining(" "));
System.out.println(tagStr); // #Java #Python #JavaScript
// 场景3: SQL IN 子句生成
List<Integer> ids = Arrays.asList(1, 2, 3, 4, 5);
String sqlInClause = ids.stream()
.map(String::valueOf)
.collect(Collectors.joining(", ", "IN (", ")"));
System.out.println(sqlInClause); // IN (1, 2, 3, 4, 5)
}
}
高级整合技巧
public class AdvancedIntegration {
public static void main(String[] args) {
// 1. 自定义Collector
List<String> items = Arrays.asList("a", "b", "c", "d");
String customJoined = items.stream()
.collect(Collector.of(
StringBuilder::new,
(sb, s) -> sb.append(s).append(" | "),
StringBuilder::append,
StringBuilder::toString
));
System.out.println(customJoined); // a | b | c | d |
// 2. 去重后拼接
List<String> duplicateItems = Arrays.asList("A", "B", "A", "C", "B", "D");
String distinctJoined = duplicateItems.stream()
.distinct()
.sorted()
.collect(Collectors.joining(", "));
System.out.println(distinctJoined); // A, B, C, D
// 3. 限制数量拼接
List<String> manyItems = Arrays.asList("1", "2", "3", "4", "5");
String limitedJoined = manyItems.stream()
.limit(3)
.collect(Collectors.joining(", "));
System.out.println(limitedJoined); // 1, 2, 3
// 4. 带编号的拼接
String numberedJoined = IntStream.range(0, manyItems.size())
.mapToObj(i -> (i + 1) + "." + manyItems.get(i))
.collect(Collectors.joining(", "));
System.out.println(numberedJoined); // 1.1, 2.2, 3.3, 4.4, 5.5
}
}
使用建议
-
选择合适的方法：
Collectors.joining()：纯字符串拼接Stream.concat()：合并多个StreamflatMap()：扁平化嵌套集合
-
注意性能：
- 大数据量时使用StringBuilder
- 避免在循环中使用字符串拼接
-
格式化输出：
- 使用String.format()格式化复杂内容
- 使用joining的重载方法添加分隔符、前缀、后缀
-
链式操作：
- 结合filter、map、sorted等操作
- 保持代码可读性
这些案例覆盖了大多数日常开发中需要的数据整合场景,可以根据实际需求灵活组合使用。
