文章目录
- 体验stream流
- stream流的生成方式
- Stream流的常见中间操作方法
- Stream流的常见中间操作方法
- Stream流的常见终结操作方法
- Stream流的练习
- Stream流的收集操作
体验stream流
package heima.stream流;
import java.util.ArrayList;
public class P1 {
public static void main(String[] args) {
//创建一个集合，存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("小林");
list.add("张小");
list.add("小王");
list.add("小岩");
list.add("张大");
list.add("张中中");
//把集合中所有以“张”开头的元素存储到一个新的集合
ArrayList<String> zhangList = new ArrayList<String>();
for (String s : list){
if (s.startsWith("张")){
zhangList.add(s);
}
}
// System.out.println(zhangList);//[张小, 张大, 张中中]
//把“张”开头的集合中的长度为3的元素存储到一个新的集合中
ArrayList<String> threeList = new ArrayList<String>();
for (String s : zhangList){
if (s.length() == 3){
threeList.add(s);
}
}
System.out.println(threeList);//[张中中]
}
}
stream流的生成方式
package heima.stream流;
import java.util.*;
import java.util.stream.Stream;
public class P2 {
public static void main(String[] args) {
//Collection体系的集合可以使用默认方法stream()生成流
List<String> list = new ArrayList<String>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();
//Map体系的集合间接的生成流
Map<String,Integer> map = new HashMap<String,Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> calueStream = map.values().stream();
Stream<Map.Entry<String,Integer>> entryStream = map.entrySet().stream();
//数组可以通过Stream接口的静态方法of（T... values）生成流
String[] strArray = {"hello","world","java"};
Stream<String> strArrayStream = Stream.of(strArray);
Stream<String> strArrayStream2 = Stream.of("hello","world","java");
Stream<Integer> intStream = Stream.of(10,20,30);
}
}
Stream流的常见中间操作方法
package heima.stream流;
import java.util.ArrayList;
public class P3 {
public static void main(String[] args) {
//创建一个集合，存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("小林");
list.add("张小");
list.add("小王");
list.add("小岩");
list.add("张大");
list.add("张中中");
//需求1：把list集合中以张开头的元素在控制台输出
list.stream().filter(s->s.startsWith("张")).forEach(System.out::println);
System.out.println("------");
//需求2：把list集合中长度为3的元素在控制台输出
list.stream().filter(s->s.length() == 3).forEach(System.out::println);
System.out.println("------");
//需求3：符合上述两个要求的输出
list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);
}
}
Stream流的常见中间操作方法
- 取数与跳过
package heima.stream流;
import java.util.ArrayList;
public class P4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
list.add("F");
//1.取前3个数据在控制台输出
list.stream().limit(3).forEach(System.out::println);
System.out.println("-----------");
//2.跳过3个元素，把剩下的元素在控制台输出
list.stream().skip(3).forEach(System.out::println);
System.out.println("-----------");
//3.跳过2个元素，把剩下的前2个在控制台输出
list.stream().skip(2).limit(2).forEach(System.out::println);
System.out.println("-----------");
}
}
- 合并与拆分
package heima.stream流;
import java.util.ArrayList;
import java.util.stream.Stream;
public class P5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
list.add("F");
//1.取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
System.out.println("----------------");
//2.跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
System.out.println("----------------");
//2.合并需求1和2的流并输出
// Stream.concat(s1,s2).forEach(System.out::println);
// System.out.println("----------------");
//4.合并需求1和2得到的流并输出，要求字符串元素不能重复
Stream.concat(s1,s2).distinct().forEach(System.out::println);
}
}
- 自然排序和比较器排序
package heima.stream流;
import java.util.ArrayList;
public class P6 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Adhhdadj");
list.add("Bwndjnad");
list.add("Ccjacnba");
list.add("wjdnawcD");
list.add("Ecxancjasnjcs");
list.add("GG");
list.add("F");
//需求1：按字母顺序输出
// list.stream().sorted().forEach(System.out::println);
// System.out.println("----------");
//需求2：按字符串长度输出
// list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);
list.stream().sorted((s1,s2)->{
int num = s1.length()-s2.length();
int num2 = num==0?s1.compareTo(s2):num;
return num2;
}).forEach(System.out::println);
}
}
需求2 有两种实现方法
package heima.stream流;
import java.util.ArrayList;
public class P7 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");
//将集合中的字符串数据转为整数之后输出
list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
list.stream().map(Integer::parseInt).forEach(System.out::println);
list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
//int sum返回此流中元素的总和
int result = list.stream().mapToInt(Integer::parseInt).sum();
System.out.println(result);
}
}
Stream流的常见终结操作方法
package heima.stream流;
import java.util.ArrayList;
public class P8 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("林间");
list.add("张言");
list.add("王忠");
list.add("李仪");
list.add("张雁");
//1.统计集合中有几个以张开头的元素，并输出
long count = list.stream().filter(s->s.startsWith("张")).count();
System.out.println(count);
}
}
Stream流的练习
package heima.stream流;
import java.util.ArrayList;
import java.util.stream.Stream;
public class P9 {
public static void main(String[] args) {
ArrayList<String> manList = new ArrayList<String>();
manList.add("周rf");
manList.add("成l");
manList.add("刘dh");
manList.add("吴j");
manList.add("周xc");
manList.add("李lj");
ArrayList<String> womanList = new ArrayList<String>();
womanList.add("林xr");
womanList.add("张my");
womanList.add("林qx");
womanList.add("柳y");
womanList.add("林zl");
womanList.add("王zx");
//way1
//男演员只要名字为3个字的前三人
// Stream<String> manStream = manList.stream().filter(s->s.length()==3).limit(3);
//
// //女演员只要姓林的，并且不要第一个
// Stream<String> womanStream = womanList.stream().filter(s->s.startsWith("林")).skip(1);
//
// //把过滤后的男演员姓名和女演员姓名合并
// Stream<String> stream = Stream.concat(manStream,womanStream);
//
// //把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
// stream.map(Actor::new).forEach(System.out::println);
// stream.map(Actor::new).forEach(p-> System.out.println(p.getName()));
//way2
Stream.concat(manList.stream().filter(s->s.length()==3).limit(3),
womanList.stream().filter(s->s.startsWith("林")).skip(1)).map(Actor::new).
forEach(p-> System.out.println(p.getName()));
}
}
way1行不通，不明原因
Stream流的收集操作
package heima.stream流;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class P10 {
public static void main(String[] args) {
//创建list集合对象
List<String> list = new ArrayList<String>();
list.add("林qx");
list.add("张my");
list.add("王zx");
list.add("柳y");
//1.得到名字为3个字的流
Stream<String> listStream = list.stream().filter(s->s.length()==3);
//2.把使用Stream流操作完毕的数据收集到list集合中并遍历
List<String> names = listStream.collect(Collectors.toList());
for (String name:names){
System.out.println(name);
}
//创建Set集合对象
Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(20);
set.add(30);
set.add(33);
set.add(35);
//3.得到年龄大于25的流
Stream<Integer> setStream = set.stream().filter(age->age > 25);
//4.把使用Stream流操作完毕的数据收集到Set集合中并遍历
Set<Integer> ages = setStream.collect(Collectors.toSet());
for (Integer age:ages){
System.out.println(age);
}
String[] strArray = {"林qx,30","张my,33","王zx,35","柳y,25"};
//5.得到字符串中年龄数据大于20的流
Stream<String> arrayStream = Stream.of(strArray).filter(s->Integer.parseInt(s.split(",")[1])>20);
//6.把使用stream流操作完毕的数据手机到Map集合中遍历，字符串中的姓名作键，年龄作值
Map<String,Integer> map = arrayStream.collect(Collectors.toMap(s->s.split(",")[0],s->Integer.parseInt(s.split(",")[1])));
Set<String> keySet = map.keySet();
for (String key:keySet){
Integer value = map.get(key);
System.out.println(key+","+value);
}
}
}
