目录
一.概念
是Jdk8开始新增的一套API (java.util.stream.*)，可以用于操作集合或者数组的数据。
好处:
Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好。
二.Stream流处理数据的步骤
1.得到集合或者数组的Stream流。
获取集合对象的Stream流：default Stream<E> stream()
获取数组对象的Stream流：
Arrays类提供的静态方法 public static <T> Stream<T> stream(T[] array)
Stream类提供的静态方法 public static<T> Stream<T> of(T... values)
package com.itheima.day08.teacher.stream;
import java.util.*;
import java.util.stream.Stream;
public class StreamDemo01 {
/*
掌握
如何获取 List的Stream流
如何获取 Set的Stream流
单列集合对象.stream()
如何获取 Map的Stream流
变成单列之后 在 .stream()
如果获取 数组的Stream流
Arrays.stream(数组)
Stream.of(数组)
将集合中的数据放到流水线上。
*/
public static void main(String[] args) {
//1 List的Stream流
List<String> names = new ArrayList<>();
Collections.addAll(names,"蔡徐坤","小黑子","ikun","鸡你太美");
// 数据转换到流上
Stream<String> stream1 = names.stream();
//2 Set的Stream流
Set<String> set = new HashSet<>();
Collections.addAll(set,"蔡徐坤","小黑子","ikun","鸡你太美");
// 数据转换到流上
Stream<String> stream2 = names.stream();
//3:如何获取 Map的Stream流
Map<String,Integer> map = new HashMap<>();
map.put("姚明",40);
map.put("刘翔",42);
map.put("郭敬明",44);
// 键集 转换成Stream流
Stream<String> stream31 = map.keySet().stream();
// 值集 转换成Stream流
Stream<Integer> stream32 = map.values().stream();
//处理键值对呢？ 键值对对象 叫entry
Stream<Map.Entry<String, Integer>> stream3 = map.entrySet().stream();
//4:数组 的Stream流
String[] array = {"蔡徐坤","小黑子","ikun","鸡你太美"};
//两种方式
Stream<String> stream4 = Arrays.stream(array);
Stream<String> stream5 = Stream.of(array);
}
}
2.调用Stream流的中间方法对数据进行处理
中间方法调用完成后会返回新的Stream流，可以继续使用(支持链式编程)
package com.itheima.day08.teacher.stream;
import java.util.stream.Stream;
public class StreamDemo02 {
/*
学习Stream流的中间方法
*/
public static void main(String[] args) {
//将多个数据放到流水线上 形成新的Stream流
Stream<String> stream1 = Stream.of("a", "b", "c", "d", "e", "f", "g");
// limit(long n)流水线上取出前n个元素..形成一个新的流向 旧的流向已经关闭 (永不回头)
// Stream<String> limit = stream1.limit(3);
// forEach(写处理每个数据的lambda表达式)
// lambda ()->{}
System.out.println("=================limit 取前几个======================");
stream1.limit(3).forEach(s-> System.out.println(s));
// forEach() 终结方法 从流水线上下来了。
//============================
System.out.println("=================skip跳过======================");
Stream<String> stream2 = Stream.of("a", "b", "c", "d", "e", "f", "g");
//跳过
stream2.skip(4).forEach(s -> System.out.println(s));
System.out.println("=============distinct去重==========================");
Stream<String> stream3 = Stream.of("a", "b", "a", "d", "b", "b", "g");
//终结方法
// System.out.println(stream3.count());
// stream3.skip(3); 报错 原因 count()终结
long count = stream3.distinct().count();
System.out.println("去重之后还有几个数据:"+count);
System.out.println("============sorted排序=================");
Stream<Integer> stream4 = Stream.of(911,119,111,114,110);
stream4.sorted().forEach(s-> System.out.println(s));//默认排序
System.out.println("============sorted排序 自定义排序规则=================");
Stream<Integer> stream5 = Stream.of(911,119,111,114,110);
stream5.sorted((o1,o2)->o2-o1).forEach(s-> System.out.println(s));//默认排序
}
}
----------------
package com.itheima.day08.teacher.stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
public class StreamDemo03 {
/*
学会使用Stream流的中间方法
*/
public static void main(String[] args) {
List<Double> scores = new ArrayList<>();
Collections.addAll(scores, 88.5, 100.0, 50.0);
// sorted 排序 排序的规则 两个数据比较 (o1,o2)->{比较的规则}
// sorted((o1,o2)->{排序的规则}) sorted() 默认规则
// forEach(完成数据的遍历) 每次取出来每一个元素
// forEach((s)->{处理s})
// filter是过滤的功能 找出符合要求的数据 返回的结果是boolean
// filter((s)->{return 判断语句;})
// filter(s->判断语句)
// 找出成绩大于等于60分的数据，并升序后，再输出。
scores.stream().filter(s->s>=60).sorted().forEach(System.out::println);
// map 一一映射 转换的意思
// 将流中的Double类型数据 变成字符串类型
// Stream<Double> stream = scores.stream(); 流里面是 Double类型元素
// map 将A 类型 转换成 B类型
// Double---String
// map((A s)->{return B类型;})
// map(A类型参数->B类型数据)
// Stream<String> stringStream = scores.stream().map((Double d) -> {
// return d + "哈哈";
// });
Stream<String> stringStream = scores.stream().map( d -> d + "哈哈");
// Double类型 变成学生类型
// scores.stream().map((Double s)->{返回 学生对象})
// Stream<Student> studentStream = scores.stream().map((Double s) -> {
// return new Student("小明", 18, s);
// });
Stream<Student> studentStream = scores.stream().map( s-> new Student("小明", 18, s));
//苍穹外卖 项目后期 可以使用map进行类型转换。
//合并流
Stream<String> stream1 = Stream.of("a", "b", "c");
Stream<String> stream2 = Stream.of("1", "2", "3");
Stream<String> stream = Stream.concat(stream1, stream2);
//两个流合并到一个流上了。
}
}
3.调用Stream流的终结方法获取处理的结果
终结方法调用完成后，不会返回新Stream了，不能继续使用流了
代码演示：
package com.itheima.day08.teacher.stream;
/**
* 学生类
*/
public class Student {
private String name;
private int age;
private double score;
public Student() {
}
public Student(String name, int age, double score) {
this.name = name;
this.age = age;
this.score = score;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return score
*/
public double getScore() {
return score;
}
/**
* 设置
* @param score
*/
public void setScore(double score) {
this.score = score;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + ", score = " + score + "}";
}
}
--------------
package com.itheima.day08.teacher.stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
public class StreamDemo04 {
/*
学会使用Stream流的终结方法
*/
public static void main(String[] args) {
List<Double> scores = new ArrayList<>();
Collections.addAll(scores, 88.5, 100.0, 50.0);
System.out.println(scores.stream().count());//求出该流中数据的个数
scores.stream().forEach(s-> System.out.println(s));//对流中数据进行处理--输出
System.out.println("===========求最大值==============");
Double max = scores.stream().max((o1, o2) -> Double.compare(o2, o1)).get(); //按照正常前后顺序才能找到，翻过会找到最小值
// Double max = scores.stream().max(Double::compare).get();
Double min = scores.stream().min((o1, o2) -> Double.compare(o1, o2)).get();
System.out.println(max);
System.out.println(min);
List<Student> students = new ArrayList<>();
students.add(new Student("小明",28,1.67));
students.add(new Student("小李",26,1.98));
students.add(new Student("小王",27,1.99));
//求出身高最高的哪位同志
// Student student = students.stream().max((o1, o2) -> Double.compare(o1.getScore(), o2.getScore())).get();
Student student = students.stream().max((o1, o2) -> Double.compare(o1.getScore(), o2.getScore())).get();
System.out.println(student);
}
}
------------------
package com.itheima.day08.teacher.stream;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class StreamTest01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张歆艺");
list.add("周杰伦");
list.add("赵雷");
list.add("张译");
list.add("张学友");
//把集合中所有以 张开头 且3个字的元素存储到新的集合中
List<String> newList = new ArrayList<>();
for (String name : list) {
if(name.startsWith("张") && name.length()==3){
newList.add(name);
}
}
System.out.println(newList);
// 将集合数据放到流水线上 进行 一步步的操作
List<String> newList2 = list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).collect(Collectors.toList());
System.out.println(newList2);
}
}
3485
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
