中国站
中国站
国际站

关于我们

质量为本、客户为根、勇于拼搏、务实创新

新闻公告

< 返回新闻公共列表

java8：Stream

发布时间：2020-04-02 00:00:00

   Stream 介绍

java8添加了一个抽象流Stream，可以让我们像写sql一样操作集合元素。Stream将要处理的元素看做是一种流， 在管道中传输，并进行处理，最后由终止操作得到处理的结果。

什么是Stream？

Stream是一个来自特定元素队列并支持聚合操作

  • 元素是具体类型的对象，形成一个队列。
  • 数据源是流的来源。
  • 聚合操作是类似sql一样的操作，比如filter, map, reduce, find, match, sorted等。
  • Stream自己不会存储元素。
  • Stream不会改变源对象。
  • Stream操作是延迟执行的。

创建流 串行流

stream()：即单线程的方式去操作流

并行流

parallelStream():即多线程方式去操作流

@Test
	public void test() {
		//1通过Collection提供的stream()和parallelStream()方法
		Listlist = Arrays.asList("a","b","c");
		Streamstream1 = list.stream();
		Streamstream2 = list.parallelStream();
		
		//2通过Arrays的静态方法stream()
		String[] strs= {"a","b","c"};
		Streamstream3 = Arrays.stream(strs);
		
		//3通过Stream类中的静态方法of()
		Streamstream4 = Stream.of("a","b","c");
		
		//4通过Stream类的iterate方法生成无限流
		Streamstream5 = Stream.iterate(0, (x)->x+1);
		
		//5通过Stream的generate方法生成无限流
		Stream.generate(()->Math.random());
		
	}

中间操作 过滤

使用 filter(Predicate

@Test
	public void test() {
		Listlist = Arrays.asList(1,2,3,4,5);
		Streamstream = list.stream();
		stream = stream.filter((x)->x.compareTo(2)>0);
		
		stream.forEach(System.out::println);
	}
输出：
3
4
5

@Test
	public void test2() {
		Listlist = Arrays.asList(1,2,3,4,5);
		Streamstream = list.stream();
		stream = stream.filter(
				(x)->{
			System.out.println(x);
			return x.compareTo(2)>0;}
			);
	}
结果：没有任何输出，这也就是前面说的Stream操作是延迟执行的，只有当终止操作这些中间操作才会依次执行

截断

使元素的个数不超过指定的数目

@Test
	public void test() {
		Listlist = Arrays.asList(1,2,3,4,5);
		Streamstream = list.stream();
		stream=stream.limit(3);
		stream.forEach(System.out::println);
	}
输出：
1
2
3
可以看到只输出了给定个元素

跳过元素

跳过流中前几个元素

@Test
	public void test4() {
		Listlist = Arrays.asList(1,2,3,4,5);
		Streamstream = list.stream();
		stream=stream.skip(2);
		stream.forEach(System.out::println);
	}
输出:
3
4
5
跳过了前两个元素

唯一筛选

两个元素通过hashCode()判断两个元素是否相同

@Test
	public void test5() {
		Listlist = Arrays.asList(1,2,3,4,5,5);
		Streamstream = list.stream();
		stream.distinct().forEach(System.out::println);
	}
输出:
1
2
3
4
5

映射

map(method)接受一个方法，把流中的元素按照方法进行转换

@Test
	public void test() {
		Listlist = Arrays.asList("a","b","c");
		Streamstream = list.stream();
		stream=stream.map((x)->x.toUpperCase());
		stream.forEach(System.out::println);
	}
输出：
A
B
C

flatMap(method)也是接受一个函数作为参数，但是与map，不同的是如果这个函数生成的本来就是流，它会把函数生成流中的元素加到流中

//这个函数本身就生成流
public static StreamtoStream(String s){
  Listlist=new ArrayList();
  char[] chs = s.toCharArray();
  for (char c : chs) {
    list.add(c);
  }
  Streamstream = list.stream();
  return stream;
}
@Test
public void test() {
  Listlist = Arrays.asList("aaa","bbb","ccc");
  Stream<Stream> stream = 
  //由于函数本身就生成流，所以流中加入的还是流
  list.stream().map(StreamTest::toStream);
  //遍历的时候需要先从流中取出流，在遍历
  stream.forEach((s)->s.forEach(System.out::println));
}

//然而我们可以使用flatMap进行改进
@Test
public void test() {
  Listlist = Arrays.asList("aaa","bbb","ccc");
  list.stream().flatMap(StreamTest::toStream).forEach(System.out::println);
}
输出：
a
a
a
b
b
b
c
c
c

终止操作 所有匹配

当所有元素都匹配时，allMatch(Predicate

@Test
public void test() {
  Listlist = Arrays.asList("aaa","bbb","ccc");
  boolean allMatch = list.stream().allMatch((s)->s.length()>2);
  System.out.println(allMatch);
}
输出：
true

任一匹配

当Stream中任一一个元素匹配时，anyMatch(Predicate

@Test
public void test() {
  Listlist = Arrays.asList("aaa","bbb","ccc");
  boolean anyMatch = list.stream().anyMatch((s)->s.equals("bbb"));
  System.out.println(anyMatch);
}
输出：
true

所有不匹配

当Stream中所有的元素都不匹配时，noneMatch(Predicate

@Test
public void test() {
  Listlist = Arrays.asList("aaa","bbb","ccc");
  boolean noneMatch = list.stream().noneMatch((s)->s.equals("ddd"));
  System.out.println(noneMatch);
}
输出：
true

第一个元素

返回当前流中的第一个元素

@Test
public void test() {
  Listlist = Arrays.asList(1,2,3,4,5);
  OptionalfindFirst = list.stream().findFirst();
  System.out.println(findFirst.get());
}
输出：
1

任一一个元素

返回当前流中的任一一个元素

@Test
public void test() {
  Listlist = Arrays.asList(1,2,3,4,5);
  OptionalfindAny = list.stream().findAny();
  System.out.println(findAny.get());
}
输出：
1

//使用并行流试试
@Test
public void test13() {
	Listlist = Arrays.asList(1,2,3,4,5);
	OptionalfindAny =   		list.parallelStream().findAny();
	System.out.println(findAny.get());
}
输出：
3

流中元素个数

返回流中的元素个数

@Test
public void test14() {
  Listlist = Arrays.asList(1,2,3,4,5);
  long count = list.stream().count();
  System.out.println(count);
}
输出：
5

流中的最大值

返回流中元素的最大值

@Test
public void test15() {
  Listlist = Arrays.asList(1,2,3,4,5);
  Optionalmax = list.stream().max(Integer::compare);
  System.out.println(max.get());
}
输出：
5

流中的最小值

返回流中的最小值

@Test
public void test16() {
  Listlist = Arrays.asList(1,2,3,4,5);
  Optionalmin = list.stream().min(Integer::compare);
  System.out.println(min.get());
}
输出：
1

规约

将流中的元素反复结合得到一个最终值

@Test
public void test() {
  Listlist = Arrays.asList(1,2,3,4,5);
  Optionalreduce = list.stream().reduce(Integer::sum);
  System.out.println(reduce.get());

  Integer reduce2 = list.stream().reduce(0, (x,y)->{
    System.out.println(x+"->"+y);
    return x+y;
  });
  System.out.println(reduce2);
}
输出：
15
0->1
1->2
3->3
6->4
10->5
15

可以看到当使用(T identity, BinaryOperator

收集

将流转换成其他形式

@Test
public void test() {
  Listlist = Arrays.asList(1,2,3,4,5,5);
  Setcollect = list.stream().collect(Collectors.toSet());
  System.out.println(collect);
}
输出：
[1, 2, 3, 4, 5]

@Test
public void test() {
		Listlist = Arrays.asList(1,2,3,4,5,5);
		Optionalcollect = list.stream().collect(Collectors.maxBy(Integer::compareTo));
		System.out.println(collect.get());
}
输出：
5

class Stu{
	String name;
	Integer age;
	String gender;
	public Stu(String name, Integer age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Stu [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
	
}
//一级分组
@Test
	public void test() {
		Listlist = Arrays.asList(
				new Stu("张三",20,"男"),
				new Stu("李四",22,"女"),
				new Stu("王五",18,"男"),
				new Stu("赵六",20,"女"),
				new Stu("田七",22,"女")
				);
		Map<String, List> collect = 				list.stream().collect(Collectors.groupingBy(Stu::getGender));
		System.out.println(collect);
	}
输出：
{女=[Stu [name=李四, age=22, gender=女], Stu [name=赵六, age=20, gender=女], Stu [name=田七, age=22, gender=女]], 男=[Stu [name=张三, age=20, gender=男], Stu [name=王五, age=18, gender=男]]}

//二级分组
@Test
public void test21() {
  Listlist = Arrays.asList(
    new Stu("张三",20,"男"),
    new Stu("李四",22,"女"),
    new Stu("王五",18,"男"),
    new Stu("赵六",20,"女"),
    new Stu("田七",22,"女")
  );
  Map<Integer, Map<String, List>> collect = list.stream()
    .collect(Collectors.groupingBy(Stu::getAge, Collectors.groupingBy(Stu::getGender)));
  System.out.println(collect);
}
输出：
{18={男=[Stu [name=王五, age=18, gender=男]]}, 20={女=[Stu [name=赵六, age=20, gender=女]], 男=[Stu [name=张三, age=20, gender=男]]}, 22={女=[Stu [name=李四, age=22, gender=女], Stu [name=田七, age=22, gender=女]]}}

//分区
@Test
public void test22() {
  Listlist = Arrays.asList(
    new Stu("张三",20,"男"),
    new Stu("李四",22,"女"),
    new Stu("王五",18,"男"),
    new Stu("赵六",20,"女"),
    new Stu("田七",22,"女")
  );
  Map<Boolean, List> collect = list.stream()
    .collect(Collectors.partitioningBy((e)->((Stu)e).getAge()>20));
  System.out.println(collect);
}
输出：
{false=[Stu [name=张三, age=20, gender=男], Stu [name=王五, age=18, gender=男], Stu [name=赵六, age=20, gender=女]], true=[Stu [name=李四, age=22, gender=女], Stu [name=田七, age=22, gender=女]]}

本文链接：https://f.ynicp.com/news/content/3839.html 复制本文链接 链接已复制
/template/Home/Zkeys/PC/Static
加入我们，立即开启您的云服务之旅！
免费注册
  • 100倍故障赔偿
  • 5天无理由退款
  • 7x24小时服务
  • 0元快速备案
  • 1V1专席秘书
阿里云云南电信商务中国西部数码中资源ZOL软件下载PC下载网非凡软件站下载之家天极网绿软基地宝塔面板绿色下载站浙联集团华彩软件站起点软件园急速下载站

Copyright © 2004-2024 Ynicp.com 版权所有 法律顾问:建纬(昆明)律师事务所　昆明市网翼通科技有限公司　滇ICP备08002592号-4

ipv6 ready 国家IPv6监测