diff --git a/service/src/test/java/cn/bunny/stream/StreamTest.java b/service/src/test/java/cn/bunny/stream/StreamTest.java
index 1cf9d07..a090ec6 100644
--- a/service/src/test/java/cn/bunny/stream/StreamTest.java
+++ b/service/src/test/java/cn/bunny/stream/StreamTest.java
@@ -1,22 +1,26 @@
 package cn.bunny.stream;
 
+import lombok.SneakyThrows;
 import org.junit.jupiter.api.Test;
 
 import java.math.BigInteger;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Stream;
 
 public class StreamTest {
+    // 产生随机数字流，会一直输出
     @Test
     void testStream() {
-        // 产生随机数字流，会一直输出
         Stream<Double> stream = Stream.generate(Math::random);
         stream.forEach(System.out::println);
     }
 
+    // 一直循环添加
     @Test
     void internalStream() {
-        // 一直循环添加
         Stream<BigInteger> stream = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));
         stream.forEach(System.out::println);
     }
@@ -39,4 +43,119 @@ public class StreamTest {
         Stream<String> stream = Stream.ofNullable("hello");
         stream.forEach(System.out::println);
     }
+
+    @SneakyThrows
+    @Test
+    void testLines() {
+        var lines = Files.lines(Path.of("D:\\Project\\demo\\sharding-sphere5\\service\\src\\test\\java\\cn\\bunny\\stream\\StreamTest.java"));
+        lines.forEach(System.out::println);
+
+        lines.close();
+    }
+
+    @Test
+    void testMap() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
+
+        // Map处理数据
+        var list = numbers.stream().map(number -> number * 2).toList();
+        System.out.println(list);
+
+        // 扁平化数据
+        List<List<Integer>> nestedNumbers = Arrays.asList(
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(4, 5),
+                Arrays.asList(6, 7, 8)
+        );
+        System.out.println("原始数据：" + nestedNumbers);
+        var integerList = nestedNumbers.stream().flatMap(List::stream).toList();
+        System.out.println(integerList);
+
+
+        // 将每个字符串拆分为字符并输出
+        Stream<String> stream = Stream.of("apple", "banana", "cherry");
+        List<Object> objectList1 = stream.mapMulti((str, consumer) -> {
+            System.out.println(str);
+            for (char c : str.toCharArray()) {
+                consumer.accept(c);
+            }
+        }).toList();
+        System.out.println(objectList1);
+
+
+        // 使用 mapMulti 方法处理流中的元素
+        Stream<Integer> integerStream = Stream.of(1, 2, 3);
+        var objectList = integerStream.mapMulti((num, consumer) -> {
+            // [1, 1, 4, 8, 9, 27]
+            consumer.accept(num * num);
+            consumer.accept(num * num * num);
+        }).toList();
+        System.out.println(objectList);
+    }
+
+    // 在需要仅处理流中前几个元素时，可以使用 limit 方法。
+    @Test
+    void testLimit() {
+        Stream<Integer> stream = Stream.iterate(0, i -> i + 1);
+        Stream<Integer> limit = stream.limit(5);
+        limit.forEach(System.out::println);
+    }
+
+    // 在需要跳过流中的前几个元素后处理后续元素时，可以使用 skip 方法。
+    @Test
+    void testSkip() {
+        Stream<Integer> stream = Stream.iterate(0, i -> i + 1);
+        Stream<Integer> skip = stream.skip(3);
+        skip.forEach(System.out::println);
+    }
+
+    // 在需要根据条件获取流中开头满足条件的元素时，可以使用 takeWhile 方法。
+    @Test
+    void takeWhileTest() {
+        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
+        Stream<Integer> integerStream = stream.takeWhile(num -> num < 4);
+        integerStream.forEach(System.out::println);
+    }
+
+    // 在需要丢弃流中开头满足条件的元素后处理剩余元素时，可以使用 dropWhile 方法。
+    @Test
+    void dropWhileTest() {
+        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
+        stream.dropWhile(num -> num < 4).forEach(System.out::println);
+    }
+
+    // 在需要将两个流合并成一个流时，可以使用 concat 方法。
+    @Test
+    void concatTest() {
+        Stream<Integer> stream1 = Stream.of(1, 2, 3);
+        Stream<Integer> stream2 = Stream.of(4, 5, 6);
+        Stream<Integer> concatenatedStream = Stream.concat(stream1, stream2);
+        concatenatedStream.forEach(System.out::println);
+    }
+
+    // 在需要从流中去除重复元素时，可以使用 distinct 方法。
+    @Test
+    void distinctTest() {
+        Stream<String> stream = Stream.of("apple", "banana", "apple", "orange", "banana");
+        stream.distinct().forEach(System.out::println);
+    }
+
+    // 默认情况下，sorted 方法会按自然顺序对元素进行升序排序。如果需要降序排序，可以使用 sorted(Comparator.reverseOrder())；返回负数是升序
+    @Test
+    void sortedTest() {
+        // 当条件是负数时是升序还是降序、相等不变这句话对吗？
+        // 当使用 sorted 方法时，负数会被认为是比正数更小，所以如果排序条件是负数，它会被放在最前面，因此会是升序排序。
+        // 相等不变这句话通常是指排序时相等的元素在排序后的顺序不变，这在 Java 中是成立的。
+        Stream<Integer> stream = Stream.of(3, 1, 4, 1, 5, 9, 2, 6);
+        stream.sorted().forEach(System.out::println);
+    }
+
+    // 在需要在流的处理过程中查看元素但不改变流本身时，可以使用 peek 方法。
+    @Test
+    void peekTest() {
+        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
+        stream.peek(System.out::println).forEach(integer -> {
+        }); // 迭代所有元素
+        stream.close(); // 在所有操作完成后关闭流
+    }
 }