主要特点和优势：

1. 声明式编程： 您只需描述您想要的结果，而不是详细说明如何实现这个结果。这使得代码更具可读性和可维护性。

2. 函数式编程风格： 可以使用函数式接口和 lambda 表达式来定义对数据的操作。

3. 流水线操作： 一系列的中间操作（如 filter、map、sorted 等）可以链接在一起，形成一个处理流水线，最后通过终端操作（如 collect、forEach、reduce 等）产生最终的结果。

4. 并行处理： 可以很容易地将顺序流转换为并行流，从而利用多核 CPU 的优势，提高处理大数据集的性能。

        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 28));

        // 获取所有人的名字列表
        List<String> names = people.stream()
               .map(Person::getName)
               .collect(Collectors.toList());

        System.out.println(names);

        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 28));

        // 将 List 转换为 Map
        Map<String, Person> personMap = people.stream()
               .collect(Collectors.toMap(Person::getName, person -> person));

        System.out.println(personMap);


处理合并的

Map<String, Person> personMap = people.stream()
       .collect(Collectors.toMap(Person::getName, person -> person, (existingValue, newValue) -> existingValue));

	@Test
	public void groupTest() {
		List<Person> persons = ImmutableList.of(
				new Person("Alice", 25),
				new Person("Bob", 30),
				new Person("Charlie", 25),
				new Person("David", 35)
		);
		// 对对象进行分组
		Map<Integer, List<Person>> groupedPersons = persons.stream().collect(Collectors.groupingBy(Person::getAge));
		Assert.assertEquals(3, groupedPersons.keySet().size());
	}

	@Test
	public void partitionedTest() {
		List<Person> persons = ImmutableList.of(
				new Person("Alice", 25),
				new Person("Bob", 30),
				new Person("Charlie", 25),
				new Person("David", 35)
		);
		Map<Boolean, List<Person>> partitionedPersons = persons.stream().collect(Collectors.partitioningBy(p -> p.getAge() > 30));
		Assert.assertEquals(1, partitionedPersons.get(true).size());
	}

	@Test
	public void flattenedTest() {
		List<List<String>> names = ImmutableList.of(
				ImmutableList.of("Alice", "Bob"),
				ImmutableList.of("Charlie", "David")
		);
		List<String> flattenedNames = names.stream()
				.flatMap(List::stream)
				.collect(Collectors.toList());
		Assert.assertEquals(4, flattenedNames.size());
	}

	@Test
	public void sortedTest() {
		List<Person> persons = ImmutableList.of(
				new Person("Alice", 25),
				new Person("Bob", 30),
				new Person("Charlie", 25),
				new Person("David", 35)
		);
		List<Person> sortedPersons = persons.stream()
				.sorted(Comparator.comparing(Person::getAge).thenComparing(Person::getName))
				.collect(Collectors.toList());
		Assert.assertEquals("David", sortedPersons.get(sortedPersons.size() - 1).getName());
	}

	@Test
	public void sortedByLengthTest() {
		List<String> words = ImmutableList.of("banana", "cherry", "apple");
		List<String> sortedWords = words.stream()
				.sorted((s1, s2) -> Integer.compare(s1.length(), s2.length()))
				.collect(Collectors.toList());
		Assert.assertEquals("apple", sortedWords.get(0));
	}

	@Test
	public void distinctTest() {
		List<Integer> list1 = ImmutableList.of(1, 2, 3);
		List<Integer> list2 = ImmutableList.of(3, 4, 5);
		List<Integer> combinedList = Stream.concat(list1.stream(), list2.stream())
				.distinct()
				.collect(Collectors.toList());
		Assert.assertEquals(5, combinedList.size());
	}

	@Test
	public void filterTest() {
		List<String> words = ImmutableList.of("apple", "banana", "cherry");
		List<String> longWords = words.stream()
				.filter(word -> word.length() > 5)
				.collect(Collectors.toList());
		Assert.assertEquals(2, longWords.size());
	}



	@Test
	public void maxTest() {
		List<Integer> numbers = ImmutableList.of(1, 5, 3, 7, 2);
		int max = numbers.stream()
				.max(Integer::compareTo)
				.orElse(0);
		Assert.assertEquals(7, max);

		double average = numbers.stream()
				.mapToDouble(Integer::doubleValue)
				.average()
				.orElse(0);
		System.out.println(average);
	}