1-认识Sream流
是JDK8开始新增的一套API（java.util.stream.*），可以用于操作集合或者数组的数据。
优势：Stream流大量的结合了Lambda语法风格来编程，功能强大，性能高效，代码简洁，可读性好。
1.1-体验Stream流
需求：
把集合中所有以“张”开头，且是三个字的元素存储到一个新集合。
1.1.1-传统方案
找出姓张的人，名字为3个字，存储到新集合中去，强调这个遍历的过程。
//目标：认识Sream流，掌握其基本使用步骤，体会其优势特点。
List<String> list = new ArrayList<>();
list.add("周芷若");
list.add("张无忌");
list.add("赵敏");
list.add("张三丰");
list.add("张强");
list.add("张翠山");
//1.先用传统方案找出姓张的人，名字为3个字，存储到新集合中去
List<String> list2 = new ArrayList<>();
for (String name : list) {
if (name.startsWith("张") && name.length() == 3) { //StarWith以姓张开始，并且长度为3
list2.add(name);
}
}
System.out.println(list2);
1.1.2-使用Stream方案
把流理解为一个传送带，把集合里的所有数据扔到这个传送带上
List<String> list = new ArrayList<>();
list.add("周芷若");
list.add("张无忌");
list.add("赵敏");
list.add("张三丰");
list.add("张强");
list.add("张翠山");
//2.使用Stream流解决
List<String> list2 = list.stream() //把流理解为一个传送带，把集合里的所有数据扔到这个传送带上
.filter(name -> name.startsWith("张")) //过滤：把姓张的过滤出来 前面是数据 后面是过滤条件
//返回一个新的流 这个流就只包含了姓张的人
.filter(name -> name.length() == 3) //过滤：把名字为3个字的过滤出来
.collect(Collectors.toList()); //把符合条件的数据收集到新集合中去
System.out.println(list2);
1.2-Stream流的使用步骤
- 准备数据源（集合/数组/...）
- 获取这个数据源的Stream流（Stream流代表一条流水线，并能与数据源建立连接。）
- 调用流水线的各种方法，对数据进行处理计算（过滤、排序、去重...）
- 获取处理的结果（遍历、同济、收集到一个新集合中返回）
2-获取Stream流
- 获取集合的Stram流
//Collection类提供如下方法
default Stream<E> stream //获取当前集合对象的Stream流- 获取数组的Stream流
//Arrays类提供如下方法
public static <T> Stream<T> stream(T[] array)//获取当前数组对象的Stream流
//Stream类提供如下方法
public static<T> Stream<T> of(T...values) //获取当前接收数据的Stream流
3-Stream流提供的常用方法
这一部分讲的就是Stream的中间方法，对于流水线上数据进行处理的部分。
有filiter过滤、sorted排序、按sorted照指定规则排序、limit获取前几个元素、skip跳过前几个元素、distinct去除流中重复的元素、map对元素进行加工，并返回对应的新流、concat合并a和b两个流为一个流...
- 中间方法指的是调用完成后会返回新的Stream流，可以继续使用（支持链式编程）。
3.1方法代码实例
public static void main(String[] args) {
//目标：掌握Stream提供的常用的中间方法，对流上的数据进行处理（返回新流，支持链式编程）
List<String> list = new ArrayList<>();
list.add("周芷若");
list.add("张无忌");
list.add("赵敏");
list.add("张三丰");
list.add("张强");
list.add("张翠山");
//1.过滤方法
list.stream()
.filter(name -> name.startsWith("张")&& name.length()==3).forEach(System.out::println);
System.out.println("----------------------------------------------------------------");
//2.排序方法。
List<Double> list2 = new ArrayList<>();
list2.add(30.10);
list2.add(20.50);
list2.add(10.10);
list2.add(20.50);
list2.add(40.00);
list2.add(40.00);
list2.add(50.50);
list2.stream().sorted().forEach(System.out::println); //默认是升序。
System.out.println("----------------------------------------------------------------");
list2.stream().sorted((s1,s2)->Double.compare(s2, s1)).limit(3).forEach(System.out::println);//降序后只要前三名
System.out.println("----------------------------------------------------------------");
list2.stream().sorted((s1,s2)->Double.compare(s2, s1)).skip(2).forEach(System.out::println);//跳过前两名
System.out.println("----------------------------------------------------------------");
list2.stream().sorted((s1,s2)->Double.compare(s2, s1)).distinct().skip(2).forEach(System.out::println);//跳过前两名
//这里是Double类，他类内已经重写了HashCode和equals，所以能自动去重和排序，如果是我们自定义的学生类，就需要重写HashCode和equals方法。
System.out.println("----------------------------------------------------------------");
//加工方法（映射方法）：把流上原来的数据拿出来变成新数据又放到流上去。
list2.stream().map(s->"加十分后："+(s+10)).forEach(System.out::println);
System.out.println("----------------------------------------------------------------");
//合并流：把两个流接起来
Stream<String> s1 = Stream.of("张无忌", "赵敏", "周芷若", "张强","牛马打工人");
Stream<Integer> s2 = Stream.of(12,42,83,34,25,46,27,18,39);
Stream<Object> s3=Stream.concat(s1,s2); //两个流类型不同，所以我们用Object类型，如果都是String类型，直接用String类型即可。
s3.forEach(System.out::println);
}
4-终结方法、收集Stream流
4.1-终结方法
终结方法指的是调用完成后，不会返回新Stream了，没法继续使用流了。
Stream提供的常用终结方法。
//目标：掌握Stream中的收集操作（终结方法）
List<Teacher> teachers = new ArrayList<>();
teachers.add(new Teacher("张三", 30, 3000));
teachers.add(new Teacher("程序员", 18, 14000));
teachers.add(new Teacher("李四", 25, 5000));
teachers.add(new Teacher("雷电将军", 25, 720020));
teachers.add(new Teacher("工程师", 28, 50200));
teachers.add(new Teacher("王五", 35, 7000));
teachers.stream().filter(teacher -> teacher.getSalary() > 15000).forEach(System.out::println);//foreach后就不能再用stream流了，这就是终结方法
System.out.println("----------------------------------------------------------------");
long count = teachers.stream().filter(teacher -> teacher.getSalary() > 15000).count();//count()终结方法
System.out.println(count);
System.out.println("----------------------------------------------------------------");
Optional<Teacher> max = teachers.stream().max((t1, t2) -> Double.compare(t1.getSalary(), t2.getSalary()));//max()终结方法
Teacher maxteacher = max.get();
System.out.println(maxteacher);
Optional<Teacher> min = teachers.stream().min((t1, t2) -> Double.compare(t1.getSalary(), t2.getSalary()));//min()终结方法
Teacher minteacher = min.get();
System.out.println(minteacher);
}
运行结果
4.2收集Stream流
- 收集Stream：就是把Stream流操作后的结果转回到集合或者数组中去返回。
- Stream流：方便操作集合/数组的手段；集合/数组：才是开发中的目的。
- 流只能收集一次，流操作完一次，被收集后，是不能再收集的。
收集到List集合
收集到Set集合
收集到数组
收集到Map集合
5-综合案例前置条件
5.1-方法中可变参数
- 就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型...参数名称;
可变参数的特点和好处
- 特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。
- 好处：常常用来灵活的接收数据。
public static void main(String[] args) {
//目标：认识可变参数
show(new int[]{1, 2, 3, 4, 5});//可以传数组
show(1,2,3);//可以传多个参数
show(1,2);//可以传两个参数
show(1);//可以传一个参数
show();//可以不传参数
//优势：接收参数很灵活，可以替代数组传参。
}
// 注意事项：可变参数在形参列表只能有一个，可变参数必须放在形参列表的最后面
public static void show(int...nums){
//内部怎么拿数据？
//可变参数对内实际上就是一个数组，nums 就是数组。
for (int i = 0; i < nums.length; i++) {
System.out.println(nums.length);
System.out.println(Arrays.toString(nums));
System.out.println("-----------------------------------------------");
}
}
运行结果
5.2-Collections工具类
- 是一个用来操作集合的工具类
Collections提供的常用静态方法
6-综合案例：斗地主小游戏
小游戏的结构
Card类
package com.xunshan.demo4Test;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Card {
private String size;
private String color;
private int num;
@Override
public String toString() {
return size+color;
}
}Room类
package com.xunshan.demo4Test;
import java.util.*;
public class Room {
//1.准备好54张牌，给房间使用：定义一个集合容器装54张牌。
//开发中不确定什么集合，就ArayList完事了
private List<Card> allCards=new ArrayList<>();
//2.初始化54张牌进去。
{
//3.准备点数
String[] sizes={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
//4.准备花色
String[] colors={"♥","♠","♣","♦"};
//5.组合点数和花色成为牌对象，加入到集合中去。
int num=0;
for (String size : sizes) {
num++;
for (String color : colors) {
//6.创建牌对象 加入到牌集合中去
allCards.add(new Card(size,color,num));
}
}
allCards.add(new Card("小王","☆",++num));
allCards.add(new Card("大王","★",++num));
System.out.println("新牌是："+allCards);
}
public void start() {
//7.开始洗牌
Collections.shuffle(allCards);
System.out.println("洗牌后："+allCards);
//8.发牌：定义三个玩家：令狐冲=【】，令狐白=【】，令狐紫=【】
Map<String,List<Card>> players=new HashMap<>();//令狐冲=【】，令狐白=【】，令狐紫=【】
List<Card> lhc=new ArrayList<>();
players.put("令狐冲",lhc);
List<Card> lhb=new ArrayList<>();
players.put("令狐白",lhb);
List<Card> lhz=new ArrayList<>();
players.put("令狐紫",lhz);
//allCards=[54张牌]=[6♦, 7♦, J♦, 3♠, 6♥, 2♥, K♦, Q♦, 4♠, 7♥, J♣,...
//只发出去51张
for (int i = 0; i < allCards.size()-3; i++) {
Card card = allCards.get(i);
//判断当前牌应该发给谁
if(i%3==0){
//请阿冲揭牌
lhc.add(card);
}else if(i%3==1){
//请阿白揭牌
lhb.add(card);
}else{
//请阿紫揭牌
lhz.add(card);
}
}
//11.拿最后三张底牌
List<Card> bottom=allCards.subList(allCards.size()-3,allCards.size());
System.out.println("底牌是："+bottom);
//抢地主：把这个集合直接到给玩家
lhz.addAll(bottom);
//9.对牌排序
sortCards(lhc);
sortCards(lhb);
sortCards(lhz);
//10.看牌，遍历Map集合
for (Map.Entry<String, List<Card>> entry : players.entrySet()) {
//获取玩家名字
String name = entry.getKey();
//获取到玩家牌
List<Card> cards = entry.getValue();
//遍历玩家牌
System.out.println(name+"的牌是："+cards);
}
}
private void sortCards(List<Card> cards) {
Collections.sort(cards, new Comparator<Card>(){
@Override
public int compare(Card o1, Card o2) {
return o1.getNum()-o2.getNum();
}
});
}
}Game类
package com.xunshan.demo4Test;
public class Game {
public static void main(String[] args) {
//目标：开发斗地主游戏
//1.每张牌都是一个对象，定义牌类。
//2.游戏房间也是一个对象，定义房间类（54张牌，开始启动）
Room r=new Room();
r.start();
}
}运行结果
每次运行的结果都是随机的，默认是令狐紫为地主，多三张牌，自动发牌，自动按大小排序。
