// 常用函數(shù)式接口示例
Function<T, R>    // 接收一個(gè)T類(lèi)型參數(shù)，返回R類(lèi)型結(jié)果
Predicate<T>      // 接收一個(gè)參數(shù)，返回boolean
Consumer<T>       // 接收一個(gè)參數(shù)，無(wú)返回值
Supplier<T>       // 無(wú)參數(shù)，返回T類(lèi)型結(jié)果
BiFunction<T,U,R> // 接收T和U類(lèi)型參數(shù)，返回R類(lèi)型結(jié)果

Predicate<String> isLongString = s -> s.length() > 10;
List<String> longStrings = new ArrayList<>();
for (String s : strings) {
    if (isLongString.test(s)) {
        longStrings.add(s);
    }
}

// 傳統(tǒng)匿名內(nèi)部類(lèi)
Comparator<String> comparator1 = new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
};

// 使用Lambda表達(dá)式
Comparator<String> comparator2 = (s1, s2) -> s1.length() - s2.length();

// Lambda表達(dá)式
list.forEach(s -> System.out.println(s));

// 方法引用
list.forEach(System.out::println);

// 從集合創(chuàng)建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> streamFromList = list.stream();

// 從數(shù)組創(chuàng)建
String[] array = {"a", "b", "c"};
Stream<String> streamFromArray = Arrays.stream(array);

// 使用Stream.of方法
Stream<String> streamOfValues = Stream.of("a", "b", "c");

// 創(chuàng)建無(wú)限流
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1);
Stream<Double> randomStream = Stream.generate(Math::random);

// 中間操作示例
List<String> result = list.stream()
    .filter(s -> s.startsWith("a"))  // 過(guò)濾以'a'開(kāi)頭的字符串
    .map(String::toUpperCase)        // 轉(zhuǎn)換為大寫(xiě)
    .distinct()                      // 去除重復(fù)
    .sorted()                        // 排序
    .collect(Collectors.toList());   // 終端操作，收集結(jié)果

// 終端操作示例
long count = list.stream()
    .filter(s -> s.length() > 3)
    .count();

boolean anyMatch = list.stream()
    .anyMatch(s -> s.startsWith("a"));

Optional<String> first = list.stream()
    .filter(s -> s.startsWith("a"))
    .findFirst();

// 假設(shè)我們有一個(gè)產(chǎn)品列表
List<Product> products = getProductList();

// 找出所有價(jià)格大于100的電子產(chǎn)品，并返回其名稱(chēng)列表
List<String> expensiveElectronics = products.stream()
    .filter(p -> p.getCategory().equals("Electronics"))
    .filter(p -> p.getPrice() > 100)
    .map(Product::getName)
    .collect(Collectors.toList());

// 按類(lèi)別分組并計(jì)算每個(gè)類(lèi)別的平均價(jià)格
Map<String, Double> avgPriceByCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::getCategory,
        Collectors.averagingDouble(Product::getPrice)
    ));

// 按價(jià)格區(qū)間分組
Map<String, List<Product>> productsByPriceRange = products.stream()
    .collect(Collectors.groupingBy(p -> {
        if (p.getPrice() < 50) return "低價(jià)";
        else if (p.getPrice() < 100) return "中價(jià)";
        else return "高價(jià)";
    }));

???????// 復(fù)雜統(tǒng)計(jì)
DoubleSummaryStatistics statistics = products.stream()
    .collect(Collectors.summarizingDouble(Product::getPrice));
System.out.println("平均價(jià)格: " + statistics.getAverage());
System.out.println("最高價(jià)格: " + statistics.getMax());
System.out.println("最低價(jià)格: " + statistics.getMin());
System.out.println("總價(jià)值: " + statistics.getSum());
System.out.println("產(chǎn)品數(shù)量: " + statistics.getCount());

// 串行處理
long count1 = list.stream()
    .filter(this::isExpensive)
    .count();

// 并行處理
long count2 = list.parallelStream()
    .filter(this::isExpensive)
    .count();

// 或者將串行流轉(zhuǎn)換為并行流
long count3 = list.stream()
    .parallel()
    .filter(this::isExpensive)
    .count();

// 適合并行的場(chǎng)景：大量數(shù)據(jù)的計(jì)算密集型操作
long sum = IntStream.range(0, 10_000_000)
    .parallel()
    .filter(n -> n % 2 == 0)
    .sum();

// 不適合并行的場(chǎng)景：數(shù)據(jù)量小或操作簡(jiǎn)單
List<String> shortList = Arrays.asList("a", "b", "c");
shortList.parallelStream()  // 不必要的并行化
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// 使用對(duì)象流，涉及裝箱拆箱
Stream<Integer> boxedStream = Stream.of(1, 2, 3, 4, 5);
int sum1 = boxedStream.reduce(0, Integer::sum);

// 使用基本類(lèi)型流，避免裝箱拆箱
IntStream primitiveStream = IntStream.of(1, 2, 3, 4, 5);
int sum2 = primitiveStream.sum();

// 查找第一個(gè)匹配的元素
Optional<Product> product = products.stream()
    .filter(p -> p.getPrice() > 100)
    .findFirst();

// 檢查是否存在匹配的元素
boolean hasExpensive = products.stream()
    .anyMatch(p -> p.getPrice() > 1000);

// 不好的例子：操作鏈過(guò)長(zhǎng)，難以理解
List<String> result = persons.stream()
    .filter(p -> p.getAge() > 18)
    .filter(p -> p.getGender() == Gender.FEMALE)
    .map(p -> p.getName())
    .filter(n -> n.startsWith("A"))
    .map(n -> n.toUpperCase())
    .collect(Collectors.toList());

// 好的例子：拆分操作，提取有意義的方法
Predicate<Person> isAdult = p -> p.getAge() > 18;
Predicate<Person> isFemale = p -> p.getGender() == Gender.FEMALE;
Predicate<String> startsWithA = n -> n.startsWith("A");

List<String> result = persons.stream()
    .filter(isAdult.and(isFemale))
    .map(Person::getName)
    .filter(startsWithA)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

List<String> result = stream
    .filter(s -> s.length() > 3)
    .peek(s -> System.out.println("Filtered: " + s))
    .map(String::toUpperCase)
    .peek(s -> System.out.println("Mapped: " + s))
    .collect(Collectors.toList());

// 分解操作鏈
Stream<Person> adultStream = persons.stream()
    .filter(p -> p.getAge() > 18);
// 可以檢查adultStream的結(jié)果

Stream<String> nameStream = adultStream
    .map(Person::getName);
// 可以檢查nameStream的結(jié)果

List<String> result = nameStream
    .collect(Collectors.toList());

Stream<String> stream = list.stream();
long count = stream.count();  // 消費(fèi)流
long count2 = stream.count(); // 錯(cuò)誤：流已被消費(fèi)

// 不好的做法：在流操作中修改外部變量
List<String> result = new ArrayList<>();
stream.forEach(s -> result.add(s.toUpperCase())); // 有副作用

// 好的做法：使用收集器
List<String> result = stream
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// 無(wú)限流需要限制
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1);
List<Integer> first10 = infiniteStream
    .limit(10)  // 限制元素?cái)?shù)量
    .collect(Collectors.toList());