logo网站免费,wordpress3.0 主题,做网站找云无限,深圳企业宣传片目录
Java 8对流的支持
流的创建
随机数流
int类型的区间范围
generate()
iterate()
流生成器
Arrays
正则表达式 本笔记参考自#xff1a; 《On Java 中文版》 ||| 流的概念#xff1a;流是一个与任何特定的存储机制都没有关系的元素序列。 流与对象的成批处理有关…目录
Java 8对流的支持
流的创建
随机数流
int类型的区间范围
generate()
iterate()
流生成器
Arrays
正则表达式 本笔记参考自 《On Java 中文版》 ||| 流的概念流是一个与任何特定的存储机制都没有关系的元素序列。 流与对象的成批处理有关。使用流的时候我们会从一个管道Pipe这一概念主要用于不同线程之间的通信中抽取元素并对它们进行操作。 这些管道通常会被串联起来形成这个流上的一个操作管线。 流的一个核心优点是它们能使我们的程序更小也更好理解。而当配合流进行使用时lambda表达式和方法引用能更好的发挥它们的作用。
【例子以有序方式显示int数】 在该例子中需要按照有序方式显示随机选择的5~20范围内、不重复的int数。
import java.util.Random;public class Randoms {public static void main(String[] args) {new Random(47).ints(5, 20) // 生成一个ints类型的流范围是5~20.distinct() // 中间流操作distinct()去除重复的值.limit(7) // 选择前7个值.sorted() // 进行排序.forEach(System.out::println); // 为每一个流元素执行括号中的操作}
} 程序执行的结果如下 ints()方法会生成一个流该方法有多个重载版本其中两个元素的版本可以设置所生成值的上下界。 注意Randoms.java没有声明任何变量。流可以对有状态的系统进行建模而不需要使用赋值或可变数据在之后的例子中这种做法会经常见到。 上述这个例子展示了一种编程风格声明式编程。我们说明想要完成什么what而不是指名怎么做how。 上述例子的命令式编程形式如下这种形式更难理解 这种形式需要定义3个变量并且由于nextInt()无法确定下界因此需要我们手动进行设定。这就体现了Randoms.java这种写法的优势方便并且表达清晰。 还可以这样区分上述这两个示例
外部迭代像ImperativeRandoms.java这样显式地编写的迭代机制。内部迭代像Randoms.java这样我们看不见任何迭代机制。这种迭代产生的代码具有更好的可读性并且更适用于多处理器。 除此之外流还有一个重要特性惰性求值。这意味着它们只有在绝对必要时才会被求值通常是在表达式的值被使用时。这种延迟求值的特性使得我们可以表示非常大的序列而不用考虑内存问题。
Java 8对流的支持 早期的Java并没有引入流的概念。这使得在后来当Java的设计者想要引入流的概念时面对的是一整套现有的库。若想要将流这个概念融入Java就需要向接口中放入新的方法这无疑会破坏原有的结构。 Java 8引入的解决方案是接口中的默认default方法。使用它Java的设计者们将流方法硬塞进了现有的类中并且放入的操作还不少。现在可以将Java中的流操作分为三种类型
创建流。修改流元素即中间操作。消费流元素即终结操作这种操作往往意味着收集一个流的元素通常会将收集的元素放入一个集合中。 流的创建
【例子Stream.of()的使用例】
import java.util.stream.Stream;public class StreamOf {public static void main(String[] args) {Stream.of( // 在这里构造器Bubble()只是用于生成一个普通的类new Bubble(1), new Bubble(2), new Bubble(3)).forEach(System.out::println);Stream.of(八百, 标兵, 奔, 北坡).forEach(System.out::print);System.out.println();Stream.of(3.14159, 2.718, 1.618).forEach(System.out::println);}
} 程序执行的结果如下 通过使用Stream.of()可以轻松地将一组条目变为一个流。 另外Collection也包含了一个stream()操作通过它可以生成一个基于Collection的流
【例子通过Collection生成一个流】
import java.util.*;public class CollectionToStream {public static void main(String[] args) {ListBubble bubbles Arrays.asList(new Bubble(1), new Bubble(2), new Bubble(3));System.out.println(bubbles.stream() // 通过Collection生成一个流.mapToInt(b - b.i) // 将对象流转变成一个包含Integer的IntStream.sum());SetString w new HashSet(Arrays.asList(G F E D C B A.split( )));// map()操作会接受流中的每个元素在其上应用括号中的操作来创建一个新的元素这个新元素会继续顺着流传递下去w.stream().map(x - x ).forEach(System.out::print);System.out.println();MapString, Double m new HashMap();m.put(pi, 3.14159);m.put(e, 2.718);m.put(phi, 1.618);m.entrySet().stream().map(e - e.getKey() : e.getValue()).forEach(System.out::println);}
} 程序执行的结果是 map()方法接受流中的每个元素在其上应用一个操作来创建一个新的元素然后将这个新元素沿着流继续传递下去。map()有许多不同的版本比如mapToInt()等。 所有集合类都有stream()方法。 为了从Map集合中生成一个流需要首先调用entrySet()来生成一个对象流其中的每个对象都包含一个键和与其相关联的值。
随机数流 就像之前示例所示Random类在Java 8时得到了增强它获得了一组可以生成流的方法
【例子Random类的stream()方法使用以int类型为例】
import java.util.Random;
import java.util.stream.Stream;public class RandomGenerators {public static T void show(StreamT stream) {stream.limit(4).forEach(System.out::println);System.out.println();}public static void main(String[] args) {Random rand new Random(47);System.out.format(%n无参数时%n);show(rand.ints().boxed()); // boxed()方法可以将基本类型转换为对应的包装器类型// 一个参数控制流的大小System.out.format(%n一个参数时%n);show(rand.ints(2).boxed());// 两个参数控制上下边界System.out.format(%n两个参数时%n);show(rand.ints(10, 20).boxed());// 三个参数控制流的大小和边界System.out.format(%n三个参数时%n);show(rand.ints(3, 3, 9).boxed());}
} 程序执行的结果是 其他类型也有可以通过类型的方式创建流。 在上述程序中出现了这样的语句
public static T void show(StreamT stream) {
其中类型参数T可以是任何东西因此可以使用IntegerLong或者Double等。另外虽然Random类只会生成int、double之类的基本类型的值。但boxed()流会自动将基本类型转换为其对应的包装器类型。 使用Random也可以创建一个可用于提供任何一组对象的Supplier。
【例子使用Random创建Supplier】 要求读取以下文本文件Cheese.dat生成String对象。
Not much of a cheese shop really, is it?
Finest in the district, sir.
And what leads you to that conclusion?
Well, its so clean.
Its certainly uncontaminated by cheese. 编写程序通过File类读取文本
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class RandomWords implements SupplierString {ListString words new ArrayList();Random rand new Random(47);RandomWords(String fname) throws IOException { // throws声明一个方法可能抛出的异常ListString lines Files.readAllLines(Paths.get(fname));// 使用的是外部迭代可优化for (String line : lines.subList(1, lines.size())) { // subList()方法用于去除第一行for (String word : line.split([ .?,]))words.add(word.toLowerCase());}}Overridepublic String get() {return words.get(rand.nextInt(words.size()));}Overridepublic String toString() {return words.stream().collect(Collectors.joining( ));}public static void main(String[] args) throws Exception {System.out.println(Stream.generate(new RandomWords(Cheese.dat)).limit(10).collect(Collectors.joining( )));}
} 程序执行的结果是 上述语句出现中split()方法的表达式变得更加复杂了。
line.split([ .?,])
这条语句会在遇见 ①空格 或 ②方括号内存在的标点符号 时进行分隔。另外方括号右边的表示其前面出现的事物是可以重复出现的。 在toString()和main()中都出现了collect()操作这一操作会根据参数将所有的流元素组合起来。当向collect()中传入一个Collectors.joining()时得到的结果是一个String它会根据joining()中的参数进行分隔。 除上面演示的之外还存在着许多的Collectors。 注意Stream.generate()它可以接受任何的SupplierT并生成一个由T类型的对象组成的流这个流的长度可以看做无限长。 int类型的区间范围 IntStream类提供了一个range()方法可以生成一个由int值组成的流
【例子IntStream中的range()方法】
import static java.util.stream.IntStream.*;public class Ranges {public static void main(String[] args) {// 传统方式生成一个int值组成的序列int result 0;for (int i 10; i 20; i)result i;System.out.println(result);// for-in搭配一个区间范围result 0;for (int i : range(10, 20).toArray())result i;System.out.println(result);// 使用流System.out.println(range(10, 20).sum());}
} 程序执行的结果如下 可以看出使用流的第三种方法更加简便。 另外可以使用repeat()工具函数来取代简单的for循环
【例子repeat()方法及其使用例】
package onjava;import static java.util.stream.IntStream.*;public class Repeat {public static void repeat(int n, Runnable action) {range(0, n).forEach(i - action.run());}
} 使循环变得更加简洁
import static onjava.Repeat.*;public class Looping {static void hi() {System.out.println(嗨!);}public static void main(String[] args) {repeat(3, ()-System.out.println(循环中...));repeat(2, Looping::hi);}
} 程序执行的结果是 generate() 再来看一个generate()方法的使用例
【例子generate()方法的使用例】
import java.util.Random;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Generator implements SupplierString {Random rand new Random(47);char[] letters ABCDEFGHIJKLMN.toCharArray();Overridepublic String get() {return letters[rand.nextInt(letters.length)];}public static void main(String[] args) {String word Stream.generate(new Generator()).limit(30) // 选择前30个值.collect(Collectors.joining()); // collect()在后台最终会调用Supplier的get()可查看堆栈System.out.println(word);}
} 程序执行的结果是 在官方文档中有关于generate()的说明 这个方法会返回一个无限的、连续的并且没有顺序的流其中的每个元素有Supplier生成。 若想要创建一个由完全相同的对象组成的流只需要将一个生成这些对象的lambda表达式传递给generate()即可
import java.util.stream.Stream;public class Duplicator {public static void main(String[] args) {Stream.generate(() - duplicate).limit(3).forEach(System.out::println);}
} 程序执行的结果是 Java会根据我们传入的lambda表达式方法引用也是在底层创建一个实现了目标接口的类的示例。因此generate()可以接受一个lambda表达式。 复习Supplier是一个函数式接口。 接下来展示的是之前提到过的Bubble类它包含了自己的静态生成器方法
public class Bubble {public final int i;public Bubble(int n) {i n;}Overridepublic String toString() {return Bubble( i );}private static int count 0;public static Bubble bubbler() {return new Bubble(count);}
} 在这里bubbler()方法能够与SupplierBubble接口相兼容理由如下参考讯飞星火
bubbler()方法是静态的可用于静态方法引用并且返回类型是Bubble。无参与SupplierBubble的无参构造器相匹配。bubbler()的设计目的与SupplierBubble的相符合即提供一个无参数的工厂方法来生成特定类型的对象。
因此可以将该方法引用传递给Stream.generate()
import java.util.stream.Stream;public class Bubbles {public static void main(String[] args) {Stream.generate(Bubble::bubbler).limit(5).forEach(System.out::println);}
} 程序执行的结果是 这是创建一个单独的工厂方法的一个替代方案。 iterate() Stream.iterate()的官方描述是这样的 这个方法会从第一个种子seed即第一个参数开始将其传递给第二个参数所引用的方法。方法的结果会被添加到这个流上并被保存下来作为下一次iterate()调用的第一个参数以此类推。 iterate()方法还有一个3参数的版本多了一个用于筛选的谓词Predicate。 【例子斐波那契数列】
import java.util.stream.Stream;public class Fibonacci {int x 1;StreamInteger numbers() {return Stream.iterate(0, // 0被传递给i作为i的初始值i - { // i中储存的是return语句的返回值int result x i;x i; // 需要使用一个x来保存另一个数值return result;});}public static void main(String[] args) {new Fibonacci().numbers().skip(20) // 跳过前20个数据.limit(10) // 然后再从中取出前10个.forEach(System.out::println);}
} 程序执行的结果是 斐波那契数列将数列中的最后两个元素相加生成下一个元素。由于iterate()只会记住结果result因此需要使用x来记住另一个元素。 流生成器 在生成器Builder设计模式中我们会创建一个生成器对象为该对象提供多段构造信息最终执行“生成”动作。Stream库提供了这样一个Builder
【例子Builder的使用例】
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;public class FileToWordsBuilder {Stream.BuilderString builder Stream.builder();public FileToWordsBuilder(String filePath)throws Exception {Files.lines(Paths.get(filePath)).skip(1) // 跳过开头行.forEach(line - {for (String w : line.split([ .?,]))builder.add(w);});}StreamString stream() {return builder.build();}public static void main(String[] args) throws Exception {new FileToWordsBuilder(Cheese.dat).stream().limit(7).map(w - w ).forEach(System.out::print);}
} 程序执行的结果是 注意在构造器添加文件中的单词时它没有调用build()。这意味着只要不调用stream()方法就可以继续往builder对象中添加单词。 可以加入一个标志来查看build()是否已经被调用加入一个方法在可能的情况下继续添加单词。 Arrays Arrays类中同样包含了名为stream()的静态方法可以将数组转换成流。
【例子Arrays的stream()】
import java.util.Arrays;
import onjava.Operation;public class MetalWork2 {public static void main(String[] args) {Arrays.stream(new Operation[]{() - Operation.show(Heat),() - Operation.show(Hammer),() - Operation.show(Twist),() - Operation.show(Anneal),}).forEach(Operation::execute); // execute负责执行流中每个元素对应的操作}
} 程序执行的结果是 上述例子中出现的Operation接口定义如下 这是一个函数式接口定义了show()方法和runOps()方法。 new Operation[]表达式动态地创建了一个由Operation对象组成的类型化数组。forEach()操作会为数组中的每一个元素执行execute()。也就是说在没有进入这条ForEach()操作之前都可以继续往Operation[]中添加内容。 使用stream()方法也可以生成IntStream、LongStream和DoubleStream
【例子stream()方法生成其他Stream】
import java.lang.reflect.Array;
import java.util.Arrays;public class ArrayStreams {public static void main(String[] args) {Arrays.stream(new double[]{3.14159, 2.718, 1.618}).forEach(n - System.out.format(%f , n));System.out.println();Arrays.stream(new int[]{1, 3, 5}).forEach(n - System.out.format(%d , n));System.out.println();Arrays.stream(new long[]{11, 22, 33, 44}).forEach(n - System.out.format(%d , n));System.out.println();// 选择一个子区间Arrays.stream(new int[]{1, 3, 5, 7, 15, 28, 37}, 3, 6).forEach(n-System.out.format(%d , n));System.out.println();}
} 程序执行的结果是 最后出现的语句
(new int[]{1, 3, 5, 7, 15, 28, 37}, 3, 6)
多使用了两个额外的参数第一个参数告诉stream()从数组哪个位置开始选择元素第二个参数告诉stream()在哪里停下。 正则表达式 Java 8向java.util.regex.Patern类中加入了一个新方法splitAsStream()。这个新方法接受一个字符序列并根据我们传入的公式将其分割为一个流。 splitAsStream()有一个约束其输入应该是一个CharSequence因此我们不能将一个流传入到splitAsStream()中。 【例子利用正则表达式切割String】
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class FileToWordsRegexp {private String all;public FileToWordsRegexp(String filepath)throws Exception {all Files.lines(Paths.get(filepath)).skip(1) // 跳过第一行.collect(Collectors.joining( ));}public StreamString stream() {return Pattern.compile([ ,.?]).splitAsStream(all);}public static void main(String[] args)throws Exception {FileToWordsRegexp fw new FileToWordsRegexp(Cheese.dat);fw.stream().limit(7).map(w - w ).forEach(System.out::print);System.out.println();fw.stream().skip(7).limit(2).map(w - w ).forEach(System.out::print);System.out.println();}
} 程序执行的结果是 构造器读取了文件中的信息将其转入一个String中。在这里我们可以多次回头调用stream()并且每次都可以从保存的String中创建一个新的流。 这个例子存在一个缺点被读取的整个文件都要存储在内存中。这会导致流的两个优势占据极少的内部存储以及惰性求值无法发挥其的作用。
