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

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)部類
Comparator<String> comparator1 = new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
};

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

// Lambda表達式
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)建無限流
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"))  // 過濾以'a'開頭的字符串
    .map(String::toUpperCase)        // 轉換為大寫
    .distinct()                      // 去除重復
    .sorted()                        // 排序
    .collect(Collectors.toList());   // 終端操作，收集結果

// 終端操作示例
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();

List<Person> persons = getPersonList();

double averageAge = persons.stream()
    .filter(p -> p.getGender() == Gender.FEMALE)  // 過濾女性
    .mapToInt(Person::getAge)                     // 提取年齡
    .average()                                    // 計算平均值
    .orElse(0);                                   // 處理空結果

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

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

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

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

???????// 復雜統(tǒng)計
DoubleSummaryStatistics statistics = products.stream()
    .collect(Collectors.summarizingDouble(Product::getPrice));
System.out.println("平均價格: " + statistics.getAverage());
System.out.println("最高價格: " + statistics.getMax());
System.out.println("最低價格: " + statistics.getMin());
System.out.println("總價值: " + 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();

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

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

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

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

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

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

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

// 不好的例子：操作鏈過長，難以理解
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的結果

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

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

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

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

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

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