Java Stream拼接案例怎么整合数据

本文目录导读：

1. 基础拼接操作
2. 对象属性拼接
3. 复杂数据整合
4. 分组和聚合整合
5. 真实业务场景
6. 高级整合技巧
7. 使用建议

我来为你详细介绍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
    }
}

使用建议

1. 选择合适的方法：

   • Collectors.joining()：纯字符串拼接
   • Stream.concat()：合并多个Stream
   • flatMap()：扁平化嵌套集合

2. 注意性能：

   • 大数据量时使用StringBuilder
   • 避免在循环中使用字符串拼接

3. 格式化输出：

   • 使用String.format()格式化复杂内容
   • 使用joining的重载方法添加分隔符、前缀、后缀

4. 链式操作：

   • 结合filter、map、sorted等操作
   • 保持代码可读性

这些案例覆盖了大多数日常开发中需要的数据整合场景,可以根据实际需求灵活组合使用。