西安网站建设外包咖啡网站源码

当前位置： 首页 > news >正文

西安网站建设外包,咖啡网站源码,网站安全设计,网站换关键词Stream操作流 在Java 8中#xff0c;得益于Lambda所带来的函数式编程#xff0c;引入了一个全新的Stream概念#xff0c;用于解决已有集合类库既有的弊端。 1.1 集合的迭代 几乎所有的集合#xff08;如 Collection 接口或 Map 接口等#xff09;都支持直接或间接的迭代…Stream操作流 在Java 8中得益于Lambda所带来的函数式编程引入了一个全新的Stream概念用于解决已有集合类库既有的弊端。 1.1 集合的迭代 几乎所有的集合如 Collection 接口或 Map 接口等都支持直接或间接的迭代遍历操作。而当我们需要对集合中的元素进行操作的时候除了必需的添加、删除、获取外最典型的就是集合遍历。例如 public class Demo {public static void main(String[] args) {ListString list new ArrayList();list.add(张无忌);list.add(周芷若);list.add(赵敏);list.add(张三);list.add(张三丰);for (String name : list) {System.out.println(name);}} }这是一段非常简单的集合遍历操作对集合中的每一个字符串都进行打印输出操作。 循环遍历的弊端 Java 8的Lambda让我们可以更加专注于做什么What而不是怎么做How这点此前已经结合内部类进行了对比说明。现在我们仔细体会一下上例代码可以发现 for循环的语法就是“怎么做”for循环的循环体才是“做什么” 为什么使用循环因为要进行遍历。但循环是遍历的唯一方式吗遍历是指每一个元素逐一进行处理而并不是从第一个到最后一个顺次处理的循环。前者是目的后者是方式。 试想一下如果希望对集合中的元素进行筛选过滤 将集合A根据条件一过滤为子集B然后再根据条件二过滤为子集C。 那怎么办在Java 8之前的做法可能为 这段代码中含有三个循环每一个作用不同 首先筛选所有姓张的人然后筛选名字有三个字的人最后进行对结果进行打印输出。 public class DemoFilter {public static void main(String[] args) {ListString list new ArrayList();list.add(张无忌);list.add(周芷若);list.add(赵敏);list.add(张三);list.add(张三丰);ListString zhangList new ArrayList();for (String name : list) {if (name.startsWith(张)) {zhangList.add(name);}}ListString shortList new ArrayList();for (String name : zhangList) {if (name.length() 3) {shortList.add(name);}}for (String name : shortList) {System.out.println(name);}} }每当我们需要对集合中的元素进行操作的时候总是需要进行循环、循环、再循环。这是理所当然的么不是。循环是做事情的方式而不是目的。另一方面使用线性循环就意味着只能遍历一次。如果希望再次遍历只能再使用另一个循环从头开始。 那Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢 public static void main(String[] args) {ListString list new ArrayList();list.add(张无忌);list.add(周芷若);list.add(赵敏);list.add(阳顶天);list.add(小昭);list.add(杨逍);list.add(杨过);list.add(韦一笑);list.add(谢逊);list.add(灭绝师太);list.add(静虚师太);//获取list的stream流StreamString listStream list.stream();//stream.filter(boolean) 当boolean true 是保留false移除//过滤流中的非姓张的人名 //boolean test(T t)StreamString zhangStream listStream.filter(t - t.startsWith(张));//姓张 且名字长度是3个字的StreamString shortStream zhangStream.filter(t - t.length() 3);//迭代输出 //void accept(T t)shortStream.forEach(t - System.out.println(t));//等同于list.stream().filter(s - s.startsWith(张)).filter(s - s.length() 3).forEach(s - System.out.println(s));}直接阅读代码的字面意思即可完美展示无关逻辑方式的语义获取流、过滤姓张、过滤长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历我们真正要做的事情内容被更好地体现在代码中。流式版本比之前的写法要更易于阅读因为流遵循了做什么而非怎么做的原则。 流表面上看起来和集合很类似都可以让我们转换和获取数据。但是它们之间存在着显著的差异 流并不存储其元素。这些元素可能存储在底层的集合中或者是按需生成的。 流的操作不会修改其数据源。例如filter方法不会从新的流中移除元素而是会生成一个新的流其中不包含被过滤掉的元素。 流的操作是尽可能惰性执行的。这意味着直至需要其结果时操作才会执行。
例如 如果我们只想査找前5个长单词而不是所有的长单词那么filter方法就会在匹配到第 5 个单词后就停止过滤。 1.2 流式思想 注意请暂时忘记对传统IO流的固有印象 整体来看流式思想类似于工厂车间的“生产流水线” 当需要对多个元素进行操作特别是多步操作的时候考虑到性能及便利性我们应该首先拼好一个“模型”步骤方案然后再按照方案去执行它。 这张图中展示了过滤、映射、跳过、计数等多步操作这是一种集合元素的处理方案而方案就是一种“函数模型”。图中的每一个方框都是一个“流”调用指定的方法可以从一个流模型转换为另一个流模型。而最右侧的数字3是最终结果。 这里的 filter 、 map 、 skip 都是在对函数模型进行操作集合元素并没有真正被处理。只有当终结方法 count 执行的时候整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。 备注“Stream流”其实是一个集合元素的函数模型它并不是集合也不是数据结构其本身并不存储任何元素或其地址值。 1.3 获取流方式 生成Stream流的方式 Collection体系集合 使用默认方法stream()生成流 default Stream stream() Map体系集合 把Map转成Set集合间接的生成流 数组 通过Arrays中的静态方法stream生成流 同种数据类型的多个数据 通过Stream接口的静态方法of(T… values)生成流
java.util.stream.Stream 是Java 8新加入的最常用的流接口。这并不是一个函数式接口。 public interface StreamT extends BaseStreamT, StreamT获取一个流非常简单有以下几种常用的方式 所有的 Collection 集合都可以通过 stream 默认方法获取流Stream 接口的静态方法 of 可以获取数组对应的流。 **根据Collection获取流 ** 首先 java.util.Collection 接口中加入了default方法 stream 用来获取流所以其所有实现类均可获取流。 public class DemoGetStream {public static void main(String[] args) {/获取Stream流的方式1.Collection中 方法 Stream stream()2.Stream接口 中静态方法 of(T…t) 向Stream中添加多个数据/ListString list new ArrayList();StreamString stream1 list.stream();SetString set new HashSet();StreamString stream2 set.stream();} }根据数组获取流 如果使用的不是集合或映射而是数组由于数组对象不可能添加默认方法所以 Stream 接口中提供了静态方法of 使用很简单 public static void main(String[] args) {String[] array { 张无忌, 张翠山, 张三丰, 张翠山 };StreamString stream Stream.of(array);StreamString stream3 Stream.of(张小山);StreamString stream4 Stream.of(张无忌, 张翠山, 张三丰, 张一元); }of 方法的参数其实是一个可变参数所以支持数组。 1.4 常用方法 流模型的操作很丰富这里介绍一些常用的API。这些方法可以被分成两种 终结方法返回值类型不再是 Stream 接口自身类型的方法因此不再支持类似 StringBuilder 那样的链式调用。终结方法包括 count 和 forEach等 方法。 非终结方法中间方法返回值类型仍然是 Stream 接口自身类型的方法因此支持链式调用。除了终结方法外其余方法均为非终结方法。 备注除了以下要介绍的方法外还有更多方法请自行参考API文档。
方法名说明Stream filter(Predicate predicate)用于对流中的数据进行过滤Stream limit(long maxSize)返回此流中的元素组成的流截取前指定参数个数的数据Stream skip(long n)跳过指定参数个数的数据返回由该流的剩余元素组成的流static Stream concat(Stream a, Stream b)合并a和b两个流为一个流Stream distinct()返回由该流的不同元素根据Object.equals(Object) 组成的流 filter过滤 可以通过 filter 方法将一个流转换成另一个子集流。方法声明 StreamT filter(Predicate? super T predicate);该接口接收一个 Predicate 函数式接口参数可以是一个Lambda作为筛选条件。 public static void main(String[] args) {StreamString original Stream.of(张无忌, 张三丰, 周芷若);StreamString result original.filter((String s) - s.startsWith(张));}limit取用前几个 limit 方法可以对流进行截取只取用前n个。方法 StreamT limit(long maxSize)参数是一个long型如果集合当前长度大于参数则进行截取否则不进行操作。基本使用 public static void main(String[] args) {StreamString original Stream.of(张无忌, 张三丰, 周芷若);StreamString result original.limit(2);System.out.println(result.count()); // 2 }skip跳过前几个 如果希望跳过前几个元素可以使用 skip 方法获取一个截取之后的新流 StreamT skip(long n)如果流的当前长度大于n则跳过前n个否则将会得到一个长度为0的空流。基本使用 public static void main(String[] args) {StreamString original Stream.of(张无忌, 张三丰, 周芷若);StreamString result original.skip(2);System.out.println(result.count()); // 1 } concat组合 如果有两个流希望合并成为一个流那么可以使用 Stream 接口的静态方法concat static T StreamT concat(Stream? extends T a, Stream? extends T b)这是一个静态方法与 java.lang.String 当中的 concat 方法是不同的。 public static void main(String[] args) {StreamString streamA Stream.of(张无忌);StreamString streamB Stream.of(张翠山);StreamString result Stream.concat(streamA, streamB); } distinct: 去重 public static void main(String[] args) {//创建一个集合存储多个字符串元素ArrayListString list new ArrayListString();list.add(林青霞);list.add(张曼玉);list.add(王祖贤);list.add(柳岩);list.add(张敏);list.add(张无忌);// 取前4个数据组成一个流StreamString s1 list.stream().limit(4);// 跳过2个数据组成一个流StreamString s2 list.stream().skip(2);Stream.concat(s1,s2).distinct().forEach(s- System.out.println(s));}终结方法 forEach : 逐一处理 虽然方法名字叫 forEach 但是与for循环中的for-each不同该方法并不保证元素的逐一消费动作在流中是被有序执行的。 void forEach(Consumer? super T action);该方法接收一个 Consumer 接口函数会将每一个流元素交给该函数进行处理。例如 public class DemoForEach {public static void main(String[] args) {StreamString stream Stream.of(张无忌, 张三丰, 周芷若);stream.forEach((String str)-{System.out.println(str);});} }在这里lambda表达式 (String str)-{System.out.println(str);} 就是一个Consumer函数式接口的示例。 count统计个数 正如旧集合 Collection 当中的 size 方法一样流提供 count 方法来数一数其中的元素个数 long count();此处方法返回值是long而不是int public static void main(String[] args) {StreamString original Stream.of(张无忌, 张三丰, 周芷若);StreamString result original.filter((String s) - s.startsWith(张));System.out.println(result.count()); // 2 }在上述介绍的各种方法中凡是返回值仍然为 Stream 接口的为函数拼接方法它们支持链式调用而返回值不再为Stream 接口的为终结方法不再支持链式调用。 Files.lines : 方法 Files.lines 是 Java 8 中的一个方法用于读取文件中的所有行并返回为一个流Stream对象。 使用 Files.lines 方法可以方便地逐行读取文本文件。下面是一个示例代码 import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.stream.Stream;public class FileLinesExample {public static void main(String[] args) {String filename path/to/file.txt;try (StreamString lines Files.lines(Paths.get(filename))) {lines.forEach(System.out::println);} catch (IOException e) {e.printStackTrace();}} }在这个示例中我们使用 Paths.get 方法来获取文件路径并将其传递给 Files.lines 方法。然后使用 try-with-resources 语句来确保在读取完成后关闭流。在 lines.forEach(System.out::println) 中我们遍历每一行并打印到控制台上。 请注意你需要替换 filename 变量的值为实际的文件路径。此外使用 Files.lines 时要注意处理可能抛出的 IOException 异常。 常见末端方法 返回类型方法名方法签名描述voidforEachvoid forEach(Consumer? super T action)对流中的每个元素执行给定的操作voidforEachOrderedvoid forEachOrdered(Consumer? super T action)保证按照流中元素的遍历顺序执行给定的操作longcountlong count()返回流中的元素数OptionalTfindFirstOptional findFirst()返回流中的第一个元素OptionalTfindAnyOptional findAny()返回流中的任意一个元素booleanallMatchboolean allMatch(Predicate? super T predicate)检查流中的所有元素是否都满足给定的谓词booleananyMatchboolean anyMatch(Predicate? super T predicate)检查流中是否有任意一个元素满足给定的谓词booleannoneMatchboolean noneMatch(Predicate? super T predicate)检查流中的所有元素是否都不满足给定的谓词OptionalTmaxOptional max(Comparator? super T comparator)返回流中根据给定比较器最大的元素OptionalTminOptional min(Comparator? super T comparator)返回流中根据给定比较器最小的元素TreduceT reduce(T identity, BinaryOperator accumulator)根据给定的起始值和累加函数将流中的所有元素聚合成一个结果OptionalTreduceOptional reduce(BinaryOperator accumulator)根据给定的累加函数将流中的所有元素聚合成一个结果 Rcollect R collect(Collector? super T, A, R collector)将流中的所有元素收集到一个容器中IntStreammapToIntIntStream mapToInt(ToIntFunction? super T mapper)将流中的元素映射为 int 值返回一个 IntStreamLongStreammapToLongLongStream mapToLong(ToLongFunction? super T mapper)将流中的元素映射为 long 值返回一个 LongStreamDoubleStreammapToDoubleDoubleStream mapToDouble(ToDoubleFunction? super T mapper)将流中的元素映射为 double 值返回一个 DoubleStreamStreamTdistinctStream distinct()返回一个去除重复元素之后的新流StreamTsortedStream sorted()返回一个根据自然顺序升序排序后的新流StreamTsortedStream sorted(Comparator? super T comparator)返回一个根据给定比较器排序后的新流StreamTskipStream skip(long n)返回一个丢弃前 n 个元素后的新流StreamTlimitStream limit(long maxSize)截取前 maxSize 个元素返回一个新流 Stream流的收集操作【应用】 概念 对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中 常用方法 方法名说明R collect(Collector collector)把结果收集到集合中 工具类Collectors提供了具体的收集方式 方法名说明public static Collector toList()把元素收集到List集合中public static Collector toSet()把元素收集到Set集合中public static Collector toMap(Function keyMapper,Function valueMapper)把元素收集到Map集合中 代码演示
// toList和toSet方法演示 public class MyStream7 {public static void main(String[] args) {ArrayListInteger list1 new ArrayList();for (int i 1; i 10; i) {list1.add(i);}list1.add(10);list1.add(10);list1.add(10);list1.add(10);list1.add(10);//filter负责过滤数据的.//collect负责收集数据.//获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.//Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.ListInteger list list1.stream().filter(number - number % 2 0).collect(Collectors.toList());System.out.println(list);SetInteger set list1.stream().filter(number - number % 2 0).collect(Collectors.toSet());System.out.println(set); } } /** Stream流的收集方法 toMap方法演示 创建一个ArrayList集合并添加以下字符串。字符串中前面是姓名后面是年龄 zhangsan,23 lisi,24 wangwu,25 保留年龄大于等于24岁的人并将结果收集到Map集合中姓名为键年龄为值 */ public class MyStream8 {public static void main(String[] args) {ArrayListString list new ArrayList();list.add(zhangsan,23);list.add(lisi,24);list.add(wangwu,25);MapString, Integer map list.stream().filter(s - {String[] split s.split(,);int age Integer.parseInt(split[1]);return age 24;}// collect方法只能获取到流中剩余的每一个数据.//在底层不能创建容器,也不能把数据添加到容器当中//Collectors.toMap 创建一个map集合并将数据添加到集合当中// s 依次表示流中的每一个数据//第一个lambda表达式就是如何获取到Map中的键//第二个lambda表达式就是如何获取Map中的值).collect(Collectors.toMap(s - s.split(,)[0],s - Integer.parseInt(s.split(,)[1]) ));System.out.println(map);} }Stream流综合练习 案例需求 现在有两个ArrayList集合分别存储6名男演员名称和6名女演员名称要求完成如下的操作 男演员只要名字为3个字的前三人女演员只要姓林的并且不要第一个把过滤后的男演员姓名和女演员姓名合并到一起把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据 演员类Actor已经提供里面有一个成员变量一个带参构造方法以及成员变量对应的get/set方法 代码实现 演员类 public class Actor {private String name;public Actor(String name) {this.name name;}public String getName() {return name;}public void setName(String name) {this.name name;} }测试类
public class StreamTest {public static void main(String[] args) {//创建集合ArrayListString manList new ArrayListString();manList.add(周润发);manList.add(成龙);manList.add(刘德华);manList.add(吴京);manList.add(周星驰);manList.add(李连杰);ArrayListString womanList new ArrayListString();womanList.add(林心如);womanList.add(张曼玉);womanList.add(林青霞);womanList.add(柳岩);womanList.add(林志玲);womanList.add(王祖贤);//男演员只要名字为3个字的前三人StreamString manStream manList.stream().filter(s - s.length() 3).limit(3);//女演员只要姓林的并且不要第一个StreamString womanStream womanList.stream().filter(s - s.startsWith(林)).skip(1);//把过滤后的男演员姓名和女演员姓名合并到一起StreamString stream Stream.concat(manStream, womanStream);// 将流中的数据封装成Actor对象之后打印stream.forEach(name - {Actor actor new Actor(name);System.out.println(actor);}); } }forEachOrdered 和 forEach 区别 forEachOrdered 和 forEach 都是 Java 8 中 Stream API 提供的方法用于对流中的元素进行迭代操作。它们之间的区别在于元素的处理顺序。 forEach 方法它在并行流上不保证元素的处理顺序。在并行流中元素会按照多个线程处理可能会导致输出的顺序与源数据的顺序不一致。 forEachOrdered 方法它在并行流上保证元素的处理顺序与源数据的顺序一致。无论是串行流还是并行流forEachOrdered 方法都会按照源数据的顺序依次处理元素。
下面是一个示例来演示两者之间的区别 import java.util.Arrays; import java.util.concurrent.TimeUnit;public class ForEachExample {public static void main(String[] args) {String[] words {apple, banana, cherry, date};// forEachSystem.out.println(forEach:);Arrays.stream(words).parallel().forEach(System.out::println);// forEachOrderedSystem.out.println(forEachOrdered:);Arrays.stream(words).parallel().forEachOrdered(System.out::println);} }在这个示例中我们创建了一个包含几个单词的字符串数组。然后使用并行流对这些单词进行处理。通过 forEach 方法打印输出时由于并行流的处理顺序不确定每次运行结果可能会有所不同。而通过 forEachOrdered 方法打印输出时无论是串行流还是并行流都会按照源数据的顺序依次输出单词。 总结来说forEach 方法适用于不关心元素处理顺序的场景而 forEachOrdered 方法适用于需要保证元素处理顺序和源数据顺序一致的场景。需要根据具体需求选择使用哪个方法。