- 流式思想
微信截图_20200520094759.png
- Stream流的简单尝试
- 传统for循环遍历的方法
import java.util.ArrayList;
import java.util.List;
/*
使用传统的方式对集合中的元素进行过滤
需求：
1.过滤以y开头的字符串
2.长度大于5
*/
public class Demo01List {
public static void main(String[] args) {
//创建一个list集合
List<String> list = new ArrayList<>();
list.add("yorick");
list.add("lucy");
list.add("yoyo");
list.add("tom");
list.add("youraka");
//过滤以y开头的字符串存入listA中
List<String> listA = new ArrayList<>();
for (String s : list) {
if(s.startsWith("y")){
listA.add(s);
}
}
//过滤长度大于5的字符串存入listB中
List<String> listB = new ArrayList<>();
for (String s : listA) {
if(s.length()>5){
listB.add(s);
}
}
//打印结果
for (String s : listB) {
System.out.println(s);
}
}
}
- Steam流的方式
import java.util.ArrayList;
import java.util.List;
/*
使用Stream流的方式遍历集合，对集合中的数据进行过滤
关注的是做什么，而不是怎么做
*/
public class Demo02Stream {
public static void main(String[] args) {
//创建一个list集合
List<String> list = new ArrayList<>();
list.add("yorick");
list.add("lucy");
list.add("yoyo");
list.add("tom");
list.add("youraka");
//过滤以y开头的字符串存入listA中
//过滤长度大于5的字符串存入listB中
//打印结果
list.stream()
.filter(name->name.startsWith("y"))
.filter(name->name.length()>5)
.forEach(name-> System.out.println(name));
}
}
- 获取stream流
import java.util.*;
import java.util.stream.Stream;
/*
获取Stream流的两种方式：
1.Collection集合可以通过stream默认方法获取流
2.Stream接口的静态方法of可以获取数组对应的流
*/
public class Demo03GetStream {
public static void main(String[] args) {
//1. Collection集合转换为stream流
//List集合
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
//Set集合
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
//Map集合间接获取stream流
Map<String,String> map = new HashMap<>();
//key流
Set<String> keySet = map.keySet();
Stream<String> stream3 = keySet.stream();
//value流
Collection<String> values = map.values();
Stream<String> stream4 = values.stream();
//entry流
Set<Map.Entry<String, String>> entries = map.entrySet();
Stream<Map.Entry<String, String>> stream5 = entries.stream();
//2.把数组转换为stream流
Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
//可变参数
String[] strings = {"a","bb","ccc"};
Stream<String> stream7 = Stream.of(strings);
}
- stream常用方法
- 延迟方法 和终结方法（延迟方法返回的类型仍然是Stream接口自身类型，可以支持链式调用；终结方法不再返回Stream接口自身类型，不再支持链式调用，终结方法包括count和forEach方法）
- Stream流属于管道流，只能被消费(使用)一次。第一个Stream流调用完毕方法，数据就会流转到下一个Stream上，而这是第一个Stream流已经使用完毕，就会关闭不能再调用方法了。
- forEach方法
import java.util.stream.Stream;
/*
Stream常用方法forEach
该方法接收一个Consumer接口函数，将流中每个元素交给该函数进行处理
简单记：
forEach方法，用来遍历流中的数据
是一个终结方法，后面不可以继续调用Stream流中的其他方法
*/
public class Demo04ForEach {
public static void main(String[] args) {
Stream<String> stream = Stream.of("yorick", "tom", "jerry");
stream.forEach(name-> System.out.println(name));
}
- filter方法
import java.util.stream.Stream;
/*
Stream流中的常用方法filter，用于对stream流中的数据进行过滤
filter方法的参数Predicate是一个函数式接口，用于对数据过滤
*/
public class Demo05Filter {
public static void main(String[] args) {
Stream<String> stream = Stream.of("yorick", "tom", "jerry", "youraka");
Stream<String> stream2 = stream.filter(name -> name.startsWith("y"));
stream2.forEach(name-> System.out.println(name));
}
- map方法
import java.util.stream.Stream;
/*
Stream流常用方法map,用于将流中的元素映射到另一个流中。
该接口需要Function函数式接口参数，可以将当前流中的T类型转换为另一种R类型的流
*/
public class Demo06Map {
public static void main(String[] args) {
Stream<String> stream = Stream.of("1", "2", "3");
Stream<Integer> integerStream = stream.map(strNum -> Integer.parseInt(strNum));
integerStream.forEach(num-> System.out.println(num));
}
}
- count方法
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
/*
Stream流中的常用方法count，用于统计Stream流中元素的个数
count方法是一个终结方法，返回值为long类型，不能继续调用Stream流中的其他方法
*/
public class Demo07Count {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
Stream<Integer> stream = list.stream();
long count = stream.count();
System.out.println(count);
}
}
- limit方法
import java.util.stream.Stream;
/*
Stream流的常用方法limit，用于截取流中的元素。
limit方法可以对流进行截取，只取前n个。
limit方法是延迟方法，可以返回一个新的流，继续调用Stream流中的其他方法
*/
public class Demo08Limit {
public static void main(String[] args) {
Stream<String> stream = Stream.of("yorick", "tom", "jerry");
Stream<String> limitStream = stream.limit(2);
limitStream.forEach(name-> System.out.println(name));
}
}
- skip方法
import java.util.stream.Stream;
/*
Steam流中的常用方法skip，用于跳过前n个元素
若流的当前长度大于n，则跳过前n个元素，否则会得到一个长度为0的空流
*/
public class Demo09Skip {
public static void main(String[] args) {
Stream<String> stream = Stream.of("yorick", "tom", "jerry");
Stream<String> skipStream = stream.skip(2);
skipStream.forEach(name-> System.out.println(name));
}
}
- concat静态方法
import java.util.stream.Stream;
/*
Stream流中的常用方法Concat，用于把流组合到一起。
若希望将两个流合并为一个流，可以使用Stream接口中的静态方法concat
*/
public class Demo10Concat {
public static void main(String[] args) {
Stream<String> stream1 = Stream.of("yorick", "tom", "jerry");
Stream<String> stream2 = Stream.of("torasa", "jackson");
Stream<String> concatStream = Stream.concat(stream1, stream2);
concatStream.forEach(name-> System.out.println(name));
}
- 练习
传统for循环方法
import java.util.ArrayList;
/*
练习：集合元素处理(传统)
现有两个ArrayList集合存储多个姓名，使用传统for循环处理集合
1.listA 只要4个字母以上的，存储到一个新集合
2.listA 只要其中的前2个，存储到新的集合
3.listB 只要以y开头的，纯粹到新集合
4.listB 筛选后不要前两个，存储新集合
5.将两集合合并
6.根据姓名创建Person对象，并存储到新集合
7.打印
*/
public class Demo11StreanTestTraditional {
public static void main(String[] args) {
ArrayList<String> listA = new ArrayList<>();
listA.add("tom");
listA.add("smith");
listA.add("jerry");
listA.add("amanda");
listA.add("bob");
//1.listA 只要4个字母以上的，存储到一个新集合
ArrayList<String> one1 = new ArrayList<>();
for (String s : listA) {
if(s.length()>4){
one1.add(s);
}
}
//2.listA 只要其中的前2个，存储到新的集合
ArrayList<String> one2 = new ArrayList<>();
for(int i=0 ;i<2 ; i++){
one2.add(one1.get(i));
}
ArrayList<String> listB = new ArrayList<>();
listB.add("yourka");
listB.add("yoyo");
listB.add("torasa");
listB.add("yorick");
listB.add("tomcat");
//3.listB 只要以y开头的，纯粹到新集合
ArrayList<String> two1 = new ArrayList<>();
for (String s : listB) {
if(s.startsWith("y")){
two1.add(s);
}
}
//4.listB 筛选后不要前两个，存储新集合
ArrayList<String> two2 = new ArrayList<>();
for(int i=2 ; i<two1.size() ; i++){
two2.add(two1.get(i));
}
//5.将两集合合并
ArrayList<String> allList = new ArrayList<>();
allList.addAll(one2);
allList.addAll(two2);
//6.根据姓名创建Person对象，并存储到新集合
ArrayList<Person> personList = new ArrayList<>();
for (String s : allList) {
personList.add(new Person(s));
}
//7.打印
for (Person person : personList) {
System.out.println(person);
}
}
}
stream流的方式处理
import java.util.ArrayList;
import java.util.stream.Stream;
/*
练习：集合元素处理(stram流)
现有两个ArrayList集合存储多个姓名，使用传统for循环处理集合
1.listA 只要4个字母以上的，存储到一个新集合
2.listA 只要其中的前2个，存储到新的集合
3.listB 只要以y开头的，纯粹到新集合
4.listB 筛选后不要前两个，存储新集合
5.将两集合合并
6.根据姓名创建Person对象，并存储到新集合
7.打印
*/
public class Demo12StreamTest {
public static void main(String[] args) {
ArrayList<String> listA = new ArrayList<>();
listA.add("tom");
listA.add("smith");
listA.add("jerry");
listA.add("amanda");
listA.add("bob");
//1.listA 只要4个字母以上的，存储到一个新集合
//2.listA 只要其中的前2个，存储到新的集合
Stream<String> listAStream = listA.stream().filter(name -> name.length() > 4).limit(2);
ArrayList<String> listB = new ArrayList<>();
listB.add("yourka");
listB.add("yoyo");
listB.add("torasa");
listB.add("yorick");
listB.add("tomcat");
//3.listB 只要以y开头的，纯粹到新集合
//4.listB 筛选后不要前两个，存储新集合
Stream<String> listBStream = listB.stream().filter(name -> name.startsWith("y")).skip(2);
//5.将两集合合并
//6.根据姓名创建Person对象，并存储到新集合
//7.打印
Stream.concat(listAStream,listBStream).map(name->new Person(name)).forEach(person-> System.out.println(person));
}
}
网友评论