Java语言程序设计——篇十一（6）

       🌿🌿🌿跟随博主脚步，从这里开始→博主主页🌿🌿🌿

• 欢迎大家：这里是我的学习笔记、总结知识的地方，喜欢的话请三连，有问题可以私信🌳🌳🌳
  您的点赞👍、关注➕、收藏⭐️、评论📝、私信📧是我最大的支持与鼓舞！！！🌻🌻🌻

流概述

• 流（stream）指的是数据流，它像一个管道，可以将数据从源传输到目的地。
• 流看起来像集合，但流并不是存储对象的数据结构，它仅用来移动数据，因此不能像集合一样向流中添加元素。
• 使用流的主要原因是它支持顺序的和并行的聚集操作。例如，可以很容易地排序、过滤或转换流中的元素。
• 流可分为顺序流和并行流。
• 如果计算机支持多核CPU，使用并行流将大大提高效率。
• Stream API定义在java.util.stream包中。
• Stream接口是最常用的类型。Stream对象可用来传输任何类型的对象。还有一些特殊的流，如IntStream、LongStream和DoubleStream等。
• Stream接口中定义了大量方法，其中有些方法执行中间操作，有些方法执行终止操作。
• 中间操作是将一个流转换成另一个流，sorted、filter和map方法执行中间操作。
• 终止操作产生一个最终结果，count、forEach方法执行终止操作。
• 值得注意的是，流操作是延迟的，在源上的计算只有当执行终止操作时才开始执行。

创建和获得流

• 有多种方法可以创建和返回一个流对象。
  （1）使用Stream接口的of()静态方法创建一个顺序流，可以将值的列表或数组传递给该方法。

String[] words = {"this", "is", "a", "java", "string"};
Stream<String> stream = Stream.of(words);
stream.forEach(System.out::println);

Stream<Integer> stream = Stream.of(100,200,300);
stream.forEach(System.out::println);

（2）用java.util.Arrays类的stream()静态方法可以将一个数组转换成顺序流。

String[] words = {"this", "is", "a", "java", "string"};
Stream<String> stream = Arrays.stream (words);
stream.forEach(System.out::println);

（3）java.util.Collection接口也有一个stream()方法返回顺序流，另一个parallelStream()方法返回并行流。格式如下：

default Stream<E> stream()
default Stream<E> parallelStream()
String[] words = {"this", "is", "a", "java", "string"};
List<String> list = Arrays.asList(words);
Stream<String> stream1 = list.stream();
Stream<String> stream2 = list.parallelStream();

连接流和排序流

• Stream接口的concat()静态方法用于将两个流连接起来。方法返回一个新流，结果是第一个流的后面接第二个流的所有元素。
• Stream接口的sorted()方法对流排序，有两个sorted()。其中一个用于其元素实现了Comparable接口的流，另一个接受一个Comparator对象。

实战演练

例：StreamConcateDemo.java

import java.util.stream.Stream;

public class StreamConcateDemo {
public static void main(String[] args) {
Stream<String> stream1 = Stream.of("Beijing", "Shanghai");
Stream<String> stream2 = Stream.of("Sydney", "London", "Paris");
Stream<String> stream = Stream.concat(stream1, stream2).sorted();
stream.forEach(System.out::println);
     }  
}

• 使用limit(n)方法可以限制返回流的元素个数，它返回一个包含n个元素的新流（如果原始流的长度小于n，则返回原始流）。这个方法特别适合裁剪指定长度的流。

Stream<String> stream = Stream.concat(stream1,stream2).sorted().limit(3);

过滤流

• 过滤流是按某种规则选择流中的元素，它返回一个包含选择元素的新流。调用Stream对象的filter()方法过滤流，传递一个Predicate对象，Predicate决定元素是否包含在新流中。
• 下面代码可将一个字符串流转换成另一个只包含长度大于等于4的单词的流。

String[] words = {"this", "is", "a", "java", "string"};
List<String> list = Arrays.asList(words);
Stream<String> longWords = 
          list.stream().filter(w->w.length()>=4);

流转换

• 可将流中的值进行某种形式的转换。这时可以使用map()方法，并且给它传递一个进行转换的函数。

Stream map(Function<T, R> mapper)

• 下面代码可以将所有单词转换为小写形式：

String[] words = {"This", "Is", "A", "Java", "String"};
List<String> list = Arrays.asList(words);
Stream<String> lowerWords = list.stream().map(String::
          方法引用		   toLowerCase);
Stream<String> lowerWords = list.stream().map(s->  							               Lambda表达式                 s.toLowerCase());
lowerWords.forEach(System.out::println);

流规约

• 经常需要从流中获得一个结果，例如，返回流中元素的数量。此时，可以使用流的count()方法实现。这样的方法称为归约方法（reduction），规约是终止操作。
• Stream接口提供了几个简单的归约方法，除count()方法外，还有max()和min()方法，它们分别返回流中的最大值和最小值。
• 需要注意的是，max()和min()方法返回一个Optional类型的值，它可能会封装返回值，也可能表示没有返回（当流为空时）。

实战演练

import java.util.stream.*;
public class StreamDemo1 {
public static void main(String[] args) {
String[] words = {"This", "Is", "A", "Java", "String"};
long n = Stream.of(words).count();
System.out.println(n);
   }
}

import java.util.stream.*;
import java.util.Optional;
public class StreamDemo2 {
public static void main(String[] args) {
String[] words = {"This", "Is", "A", "Java", "String"};
Optional<String> largest = Stream.of(words).max(String::compareTo);
System.out.println("Max="+largest.get());
  }
}

收集结果

• 当处理完流后，可能需要查看一下结果或将结果收集到其他容器中。
• 可以调用toArray()方法将流中所有元素转换成数组。因为不可能在运行时创建一个泛型数组，所以表达式stream.toArray()返回一个Object[]类型数组。如果想获得相应类型数组，将类型传递给数组的构造方法：

 String[] result = stream.toArray(String[]::new);

• 可以将流中元素收集到另一个集合，Stream有一个方便的方法collect()，它接受一个Collection接口实例。Collectors类为普通集合提供了大量工厂方法。
• 要将一个流收集到List或Set中，可以直接调用：

List<String> result =  stream.collect(Collectors.toList());
Set<String> result =  stream.collect(Collectors.toSet());

基本类型流

• 对于基本类型，可以使用其包装类创建流，例如，Stream。显然，将整数包装成包装类型效率低下。
• 为了直接将基本类型值存储到流中而不需要进行包装，Stream类库提供了IntStream、LongStream和DoubleStream类型，对short、char、byte、boolean类型使用IntStream类型，对float类型使用DoubleStream类型。
• 要创建一个IntStream，可以调用IntStream.of()方法或Arrays.stream()方法。

IntStream stream = IntStream.of(1, 2, 3);
int[] value = {1,2,3};
IntStream stream = Arrays.stream(value, 0, 2);

并行流

• 大多数计算机都是多核的。在这些计算机上可以并行执行多个线程。使用并行流可以提高计算效率。
• 创建一个并行流。使用Collection的paralellStream()方法可以从任何集合获得一个并行流。

 List<String> words = Arrays.asList("one","two","three");
Stream<String> parallelWords = words.parallelStream();

• 使用paralell()方法可将顺序流转换成并行流。

String[] wordArray = {"one","two","three"};
Stream<String> parallelWords=Stream.of(wordArray).parallel();

综合演练

关于Stream API的Java例题，我们可以从多个方面来展示其应用，包括创建Stream、中间操作（如过滤、映射、排序等） 以及终止操作（如收集、遍历等）。以下是一些具体的Java例题：
1️⃣ 创建Stream
例1：从集合中创建Stream

import java.util.Arrays;  
import java.util.List;  
import java.util.stream.Stream;  
  
public class StreamExample {  
    public static void main(String[] args) {  
        List<String> list = Arrays.asList("Java", "Python", "C++", "JavaScript");  
        Stream<String> stream = list.stream();  
        stream.forEach(System.out::println);  
    }  
}

例2：从数组中创建Stream

import java.util.Arrays;  
import java.util.stream.Stream;  
  
public class StreamExample {  
    public static void main(String[] args) {  
        int[] numbers = {1, 2, 3, 4, 5};  
        Stream<Integer> stream = Arrays.stream(numbers);  
        stream.forEach(System.out::println);  
    }  
}

2️⃣中间操作
例3：过滤Stream中的元素

import java.util.Arrays;  
import java.util.List;  
import java.util.stream.Stream;  
  
public class StreamExample {  
    public static void main(String[] args) {  
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  
        Stream<Integer> filteredStream = numbers.stream().filter(n -> n % 2 == 0);  
        filteredStream.forEach(System.out::println); // 输出偶数  
    }  
}

例4：映射Stream中的元素

import java.util.Arrays;  
import java.util.List;  
import java.util.stream.Stream;  
  
public class StreamExample {  
    public static void main(String[] args) {  
        List<String> strings = Arrays.asList("apple", "banana", "cherry");  
        Stream<Integer> lengthStream = strings.stream().map(String::length);  
        lengthStream.forEach(System.out::println); // 输出字符串的长度  
    }  
}

3️⃣终止操作
例5：收集Stream中的元素到List

import java.util.Arrays;  
import java.util.List;  
import java.util.stream.Collectors;  
import java.util.stream.Stream;  
  
public class StreamExample {  
    public static void main(String[] args) {  
        List<String> strings = Arrays.asList("apple", "banana", "cherry");  
        List<String> filteredAndSortedStrings = strings.stream()  
                .filter(s -> s.startsWith("a"))  
                .sorted()  
                .collect(Collectors.toList());  
        filteredAndSortedStrings.forEach(System.out::println); // 输出过滤并排序后的字符串  
    }  
}

博主用心写，读者点关注，互动传真情，知识不迷路。