Stream流是jdk8开始新增的一套api，可以用于操作集合或数组的内容。
Stream流大量的结合了Lambda的语法风格来编程，功能强大，性能高效，代码简洁，可读性好。
体验Stream流
把集合中所有以三开头并且三个字的元素存储到一个新集合。
package streamDemo;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class StreamDemo1 {
public static void main(String[] args) {
//目标：认识stream流，掌握基本使用步骤，体会它的优势
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张无忌");
list.add("张三丰");
list.add("张小四");
//用传统方案找出姓张的人名字为三个字的存入到新集合中
List<String> newList = new ArrayList<>();
for(String name : list)
{
if(name.startsWith("张")&&name.length()==3)
{
newList.add(name);
}
}
System.out.println(newList);
//用stream流
List<String> newList2=list.stream().filter(s -> s.startsWith("张")).filter(s ->s.length()==3).collect(Collectors.toList());
System.out.println(newList2);
}
}相较于传统方法的排序和筛选，stream流只需要一行就可以实现功能，代码更简洁。
获取Stream流
语法：
Stream<集合或数组内存储的数据类型> 变量名 = 数组或集合名.stream();示例
package streamDemo;
import java.util.*;
import java.util.stream.Stream;
public class StreamDemo2 {
public static void main(String[] args) {
//获取stream流的方式
//1、获取集合的stream流，调用集合提供的stream（）方法
Collection<String> list = new ArrayList<>();
Stream<String> s1 = list.stream();
//2、Map集合
Map<String,Integer> map = new HashMap<>();
//获取它的键流
Stream<String> s2 = map.keySet().stream();
//值流
Stream<Integer> s3 = map.values().stream();
//键值对流
Stream<Map.Entry<String, Integer>> s4 = map.entrySet().stream();
//3、数组的流
String[] names = {"张三丰","张学友","张学良"};
Stream<String> s5 = Arrays.stream(names);
System.out.println(s5.count());
Stream<String> s6 = Stream.of(names);
Stream<String> s7 = Stream.of("张三丰", "张无忌", "张三");
}
}
Stream流的常用中间方法
中间方法指的是，使用完这个方法后，会返回一个新的Stream流，例如筛选完姓张的人后返回一个只有姓张的人的集合用于后续操作。
获取的Stream流可以使用多个中间方法进行筛选，直到选出我们需要的数据。
常用的几种方法有：过滤方法、合并方法、映射/加工方法等
Stream流中若是需要为自定义数据类型规定排序规则/筛选规则，可以使用Lambda方法。
示例
package streamDemo;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamDemo3 {
public static void main(String[] args) {
//掌握Stream流常用的中间方法，对流上的数据进行处理（返回新流：支持链式存储）
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张无忌");
list.add("张三丰");
list.add("张小四");
//过滤方法
list.stream()
.filter(s -> s.startsWith("张"))
.filter(s ->s.length()==3)
.forEach(s -> System.out.println(s));
//排序方法
List<Double> scorce = new ArrayList<>();
scorce.add(99.8);
scorce.add(98.7);
scorce.add(83.7);
scorce.add(67.5);
scorce.add(67.5);
scorce.stream().sorted().forEach(s-> System.out.println(s));//升序
System.out.println("=============================");
scorce.stream().sorted((s1,s2)->Double.compare(s2,s1))
.forEach(s-> System.out.println(s));//降序
System.out.println("=============================");
scorce.stream().sorted((s1,s2)->Double.compare(s2,s1))
.limit(2).forEach(System.out::println);//只要前两名
System.out.println("=============================");
scorce.stream().sorted((s1,s2)->Double.compare(s2,s1))
.skip(2).forEach(System.out::println);//跳过前两名
System.out.println("=============================");
//如果希望自定义对象能够去重，需要重写对象的hashCode和equals方法才能去重
scorce.stream().sorted((s1,s2)->Double.compare(s2,s1))
.distinct().forEach(System.out::println);//去重
//映射/加工方法： 把流上原本的数据拿出来变成新数据放回流上
scorce.stream().map(s->"加十分后："+(s+10)).forEach(System.out::println);
//合并流
Stream<String> s1 = Stream.of("张三丰", "张无忌", "张三");
Stream<Integer> s2 = Stream.of(111,22,33);
Stream<Object> s3 = Stream.concat(s1,s2);//每次只能合并两个
System.out.println(s3.count());
}
}
Stream流的常用终结方法
终结方法指的是调用完后不会返回新的Stream流了，不能再继续调用流了。
常用的一些终结方法有统计/收集方法。收集方法是将目前流中的数据存储到一个集合/数组中，统计方法是统计流中目前的元素数量，流中的最大值最小值等。
package streamDemo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Teacher implements Comparable<Teacher>{
private String name;
private int age;
private double salary;
@Override
public String toString()
{
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}'+"\n";
}
//t2.compareTo(t1)
//t2==this 比较者
//t1==o 被比较者
//规定：如果t2大于t1，返回正数；如果t2小于t1，返回负数；如果t2等于t1，返回0
@Override
public int compareTo(Teacher o) {
//按照年龄升序排序
// if (this.age>o.age)
// return 1;
// else if (this.age<o.age)
// return -1;
// return 0;
// }
return this.age-o.age;//升序
//return o.age-this.age;//降序
}
}package streamDemo;
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamDemo4 {
public static void main(String[] args) {
//掌握Stream流的统计，收集操作（终结方法）
List<Teacher> teachers = new ArrayList<>();
teachers.add(new Teacher("张三",18,5000));
teachers.add(new Teacher("老陈",38,8000));
teachers.add(new Teacher("老金",58,15000));
teachers.add(new Teacher("老魏",63,16000));
teachers.add(new Teacher("张五",28,3500));
teachers.stream().filter(s->s.getSalary()>6000).forEach(s-> System.out.println(s));
System.out.println("======================================");
long count = teachers.stream().filter(s -> s.getSalary() > 15000).count(); //计15000薪水以上的人数
System.out.println(count);
System.out.println("======================================");
//获取薪水最高的老师对象
Optional<Teacher> max = teachers.stream().max((t1, t2) -> Double.compare(t1.getSalary(), t2.getSalary()));
Teacher maxTeacher = max.get();
System.out.println(maxTeacher);
//最小
Optional<Teacher> min = teachers.stream().min((t1, t2) -> Double.compare(t1.getSalary(), t2.getSalary()));
Teacher minTeacher = min.get();
System.out.println(minTeacher);
System.out.println("=====================================");
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张无忌");
list.add("张三丰");
list.add("张小四");
//收集到集合或数组中
Stream<String> s1 = list.stream().filter(s->s.startsWith("张"));
//收集到list集合
//流只能收集一次
List<String> List1 = s1.collect(Collectors.toList());
System.out.println(List1);
//收集到Set集合
Set<String> list2 =list.stream().filter(s->s.startsWith("张")).collect(Collectors.toSet());
System.out.println(list2);
System.out.println("=============收集到map集合===================");
Stream<Teacher> s4 = teachers.stream();
//收集到Map集合：键是老师名称，值是老师薪水
Map<String, Double> map = s4.collect(Collectors.toMap(t1 -> t1.getName(), t1 -> t1.getSalary()));
System.out.println(map);
}
}以上就是关于Stream流的基本语法。
