这是java8 引入的新的特性 和之前介绍的java IO 流多多少少有所区别。简单的说IO就是进行了基本的数据传输操作,Stream是对集合的数据进行过滤操作。主要就是对集合进行操作。IO涉及比较广,主要还是进行数据的传输。
相比较集合的话就是一般是配合使用的。集合是用来对数据进行一个存储,不会对数据进行其它形式的处理,主要就是存储。Stream是会对数据处理的,判断,过滤,计算都有。
一般在对集合中的数据进行处理的话,结合Stream可以非常方便进行操作。我们一般还是配合Lambda表达式的模式进行处理。代码比较简化优雅。
filter(Predicate<? super T> predicate) 返回由与此给定谓词匹配的此流的元素组成的流。 会返回判断条件为true的元素,这个方法会返回一个流
如下,我们先用filter 来返回判断结果为true的流,然后再调用collect中的方法让它返回集合。
ArrayList<String> list = new ArrayList<>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("张敏");
list.add("张无忌");
List<String> list_ = list.stream().filter(s -> s.startsWith("张")).collect(Collectors.toList());
至于collect方法,我们主要需要了解它的一些用法。
collect(Collector<? super T,A,R> collector)
1.Collectors.toList():转换成List集合。/ Collectors.toSet():转换成set集合。
List<String> list_de = list.stream().collect(Collectors.toList());
2:Collectors.toCollection(TreeSet::new):转换成特定的set集合。
TreeSet<String> treeset = list.stream().collect(Collectors.toCollection(TreeSet::new));
3:Collectors.toMap(keyMapper, valueMapper, mergeFunction):转换成map
这个方法包含三个重载方法
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier);
keyMapper:Key 的映射函数 valueMapper:Value 的映射函数 mergeFunction:当 Key 冲突时,调用的合并方法 mapSupplier:Map 构造器,在需要返回特定的 Map 时使用
需要注意的是如果键出现重复或者值为空的时候可能出现异常.所以再转换map的时候可以对值得冲突首先做处理.
简单举例 先创建一个类,Student_clo
package Stream;
public class Student_clo<S, I extends Number, S1> {
private String name;
private Integer age;
private String id;
public Student_clo(S jgdabc, I i, S snka) {
this.name = (String) jgdabc;
this.age = (Integer) i;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
**测试类的使用**
package Stream;
import java.util.ArrayList;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
public class Student_Collection {
public static void main(String[] args) {
// Student_clo student_clo = new Student_clo();
// Student_clo student_1_clo = new Student_clo();
// Student_clo student_2_clo = new Student_clo();
ArrayList<Student_clo<String,Integer,String>> student = new ArrayList<>(3);
student.add(new Student_clo<>("jgdabc",12,"snka"));
student.add(new Student_clo<>("jgdb",13,"45"));
student.add(new Student_clo<>("sjns",19,"asjsa"));
// v1,v2 这边对可能出现的键冲突进行了处理,只是用一下方法
student.stream().collect(Collectors.toMap(Student_clo::getAge, Student_clo::getName,(v1,v2)->v2));
}
}
3:distinct() 方法 这个方法得作用是比较简单的,就是用来去除重复的元素。操作对象也是为流对象。
4: sorted()/sorted(T,T)->int) 方法的主要作用就是实现一个排序。如果流中的元素实现了Comparable接口,有自己的排序规则,就可以直接调用sorted() 方法,如果没有实现排序接口,那么需要调用sorted((T,T)->int )去实现排序接口。
定义一个基本类
package Stream;
public class Student_clo<S, I extends Number, S1> {
private String name;
private Integer age;
private String id;
public Student_clo(S jgdabc, I i, S snka) {
this.name = (String) jgdabc;
this.age = (Integer) i;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
package Stream;
import javax.sound.midi.Soundbank;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Student_Collection {
public static void main(String[] args) {
// Student_clo student_clo = new Student_clo();
// Student_clo student_1_clo = new Student_clo();
// Student_clo student_2_clo = new Student_clo();
ArrayList<Student_clo<String,Integer,String>> student = new ArrayList<>(3);
student.add(new Student_clo<>("jgdabc",12,"snka"));
student.add(new Student_clo<>("jgdb",11,"45"));
student.add(new Student_clo<>("sjns",19,"asjsa"));
List<Student_clo<String, Integer, String>> list_sort = student.stream().sorted((p1,p2)->p1.getAge()-p2.getAge()).collect(Collectors.toList());
for(Student_clo l: list_sort)
{
System.out.println(l.getAge()+l.getName());
}
System.out.println(list_sort);
}
}
5:limit(long n) 返回前n个元素,也就是对处理返回的元素做一个限制
List<Student_clo<String, Integer, String>> list_sort = student.stream().sorted((p1,p2)->p1.getAge()-p2.getAge()).limit(2).collect(Collectors.toList());
6:skip(long n) 这个方法是用来过滤掉前n个元素,也可以认为是跳过
List<Student_clo<String, Integer, String>> list_sort = student.stream().sorted((p1,p2)->p1.getAge()-p2.getAge()).limit(2).skip(1).collect(Collectors.toList());
7:forEach() 方法 该方法可用于对集合进行一个遍历输出
8:映射(转换):map 实现将流中的元素映射到另一个流当中 其中接口类型为Function,在写lambda需要注意一下泛型接口就可以
list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
9:count() 也可以认为是一个终结方法,主要是对元素进行计数,例如返回的的计数。比较简单,对象当然还是操作在Stream流上。
10:concat()方法 对流进行一个合并
// 取前四个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
//跳过两个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//合并需求两个流
Stream.concat(s1,s2).forEach(System.out::println);
11:flatMap() 对比map 方法的话,区别在于如果map中有流中嵌套了,那么一次遍历是得不到想要的结果的,需要两次遍历,如果我们要flapMap它只需要一次遍历,也就是它会把每个流打开,那么当然只需要一次遍历。
12 peek() peek 函数会按照消费接口Consumer函数进行消费处理,并可以改变函数的一些属性。
list.stream().peek(s-> System.out.println(s));
list.stream().peek(System.out::print);
list.stream().peek(StringBuffer::new);
13:iterate() 方法 返回有序无限连续 Stream由函数的迭代应用产生 f至初始元素 seed ,产生 Stream包括 seed , f(seed) , f(f(seed)) ,等
Stream.iterate(0,x->x+1).limit(6).forEach(System.out::println);
//0,1,2,3,4,5
14: reduce() 方法 对集合形成的流对象进行一个归约 使用 associative累积函数对此流的元素执行 reduction ,并返回描述减小值的 Optional (如果有)。
8的api说的十分精准而难懂。
我们可以用它来做对集合形成的流对象中的元素进行求和。
ArrayList<Integer> list_i = new ArrayList<>();
list_i.add(1);
list_i.add(2);
list_i.add(3);
Integer sum = list_i.stream().reduce(0, Integer::sum);
System.out.println(sum);//6
15: max()/min() 方法 还是操作流对象,只不过可以用这个方法来进行获取最大的对象,继而获取值。
先定义了一个Student_clo类
package Stream;
public class Student_clo<S, I extends Number, S1> {
private String name;
private Integer age;
private String id;
public Student_clo(S jgdabc, I i, S snka) {
this.name = (String) jgdabc;
this.age = (Integer) i;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
ArrayList<Student_clo<String,Integer,String>> student = new ArrayList<>(3);
student.add(new Student_clo<>("jgdabc",12,"snka"));
student.add(new Student_clo<>("jgdb",11,"45"));
student.add(new Student_clo<>("sjns",19,"asjsa"));
Optional<Student_clo<String, Integer, String>> max = student.stream().max((e1, e2) -> e1.getAge() - e2.getAge());
System.out.println(max.get().getAge());//返回到最大年龄为19
16:allMatch()/anyMatch()/noneMatch() 很明显就是作为匹配,分别对应全部匹配,一个或者一个以上的匹配,不匹配。如果满足对应的条件,就返回True,反之,返回false。 具体去用的话就十分清楚明了。
boolean b = list_i.stream().allMatch(i -> i > 0);
boolean b1 = list_i.stream().anyMatch(i -> i > 2);
boolean b2 = list_i.stream().noneMatch(i -> i - 3 >= 0);
在介绍方法的上面已经说明了。就是Collection集合系列。基本该说的都说了。前面运用的方法基本都是在集合的基础上进行说明。
Stream<String> stream2 = list.stream();
用流将数组包围起来以后,就可以更加方便的使用一些方法(Stream流上的一些处理)
String arr[] = {"jgdabc","dnkas","esfnsa"};
Stream<String> arr1 = Stream.of(arr);
Stream<String> limit = arr1.limit(1);
limit.forEach(System.out::println);
也可以使用数组中的方法去转换为stream流
final IntStream stream1 = Arrays.stream(new int[]{1, 2, 3});
完整格式
Stream.iterate(final T seed, final UnaryOperator f)
基本在方法说明上也说了。 从参数上具体分析的话,就是一个常量seed,可指定泛型,然后呢,生成到f,f是UnaryOpeartor类型的。
这个类型是什么呢?查看源码的话,还是返现也就是一个继承Function的接口,然后里面有一个静态的方法。
很明显的就是一个函数式接口,稍微了解下就好。
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
/**
* Returns a unary operator that always returns its input argument.
*
* @param <T> the type of the input and output of the operator
* @return a unary operator that always returns its input argument
*/
static <T> UnaryOperator<T> identity() {
return t -> t;
}
}
具体使用这个iterate的时候也就可以正如上面方法中提到的。做到一个类似遍历取值的效果。
Stream.iterate(0, n -> n + 1).limit(5).forEach(a -> {
System.out.println(a);//0,1,2,3,4
});
其实和iterate一样创建的是无限流。
怎么体现,随机数生成,就可以体现。因为无限流的特点,一般需要用limit()去进行限制。配合使用。还是挺好玩的。只要了解到lambda,函数式编程,好奇的话,看看源码,接口,就完事。
如果你不限制的话,生成时不会结束的。有趣。
Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(10));
限制一下
Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(10)).limit(10);
stream.forEach(e -> System.out.println(e));
我们也可以去用一个并行流
其实这个流,可以直接放在集合这边去归结,但是感觉这个并行流还是十分有特点的。并行的一个流,采用了多线程的方式。既然采用多线程,那么如果我foreach()进行终结遍历stream所包含的集合的元素,那么一个输出无需。为了好区分,避开使用set集合去验证这个特点。
ArrayList<String> list = new ArrayList<>();
list.add("10");
list.add("20");
list.add("30");
list.add("13");
list.add("50");
Integer arr[] = {1,2,3,4};
list.parallelStream().forEach(System.out::println);
并行可以提高效率,原理使用的还是forkjoin线程池。就简单介绍一下。从集合Collection的并行流的这个方法一直追溯源码的话,会一直找到其实是使用了forkjoin线程池。