java8Lambda-stream常用总结

stream

Stream：流

1. 将dataList中每个Student对象的分数组装成新list

scoreList=dataList.stream().map(Student::getScore).collect(Collectors.toList());

2. 遍历dataList
dataList.forEach(System.out::println)

3. collect：收集器
能够将流转换成其他形式，比如list、set、map

4. filter：过滤器
设置条件过滤掉不需要内容

5. distinct：去重

6. limit：获取流中前n个数据

7. skip：去除流中前n个数据

8. map：映射（转换）每个数据到对应结果

9. flatmap：流的扁平化处理
流中数据元素平铺合并

10. mapToXxx：转换类型
mapToLong...

11. sorted：对流进行排序

12. anyMatch：至少匹配一个元素，返回bollean

13. allMatch：检查是否全匹配，返回Boolean

14. noneMatch：检查是否没有匹配所有元素，返回Boolean

15. findAny：返回流中任意元素

16. findFirst：返回第一个元素

17. reduce：将流中元素反复结合起来，得到一个值

18. count：获取集合元素数量

19. peek：做一些外部处理等

20. Stream.of：初始化集合

import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test8 {
	public static void main(String[] args) {
		new Test8().doWork();

	}

	private List<String> strings;
	private List<Integer> ints;
	private List<String> names;
	private List<Student> students;

	private void doWork() {
		// list转set
		Set<String> c1 = strings.stream().collect(Collectors.toSet());
		// list转map:第一个参数是key，第二个参数是value，第三个参数遇到重复的选newV
		Map<String, String> c2 = strings.stream()
				.collect(Collectors.toMap(v -> "prod_" + v, v -> v, (oldV, newV) -> newV));

		// 将 student 集合按照 id（唯一） 封装成 map 集合
		Map<Integer, Student> sMap = students.stream()
				.collect(Collectors.toMap(stu -> stu.getId(), stu -> stu, (oldV, newV) -> newV));

		// 将 students 集合按照 年龄 封装成 map 集合
		Map<Integer, List<Student>> c3 = students.stream().collect(Collectors.groupingBy(stu -> stu.getAge()));

		// 将 strings 集合中带 f 的字符串筛选出来放如另外一个集合
		List<String> c4 = strings.stream().filter(str -> str.contains("f")).collect(Collectors.toList());

		// 将 students 集合中叫年龄为 18 的同学找出来
		List<Student> c5 = students.stream().filter(stu -> stu.getAge() == 18).collect(Collectors.toList());

		// distinct 去重
		List<String> c6 = strings.stream().distinct().collect(Collectors.toList());

		// limit 获取前几个
		List<String> c7 = strings.stream().limit(3).collect(Collectors.toList());

		// skip 跳过前几个
		List<String> c8 = names.stream().skip(3).collect(Collectors.toList());

		// 将集合 names 中的每个元素都拼接一个 A- str -A
		List<String> c9 = names.stream().map(name -> "A-" + name.concat("-A")).collect(Collectors.toList());

		// 获取 students 集合中每个同学的 名字
		List<String> c10 = students.stream().map(stu -> stu.getName()).collect(Collectors.toList());
		List<String> c11 = students.stream().map(Student::getName).collect(Collectors.toList());

		// map：对元素进行转换（多个元素的流）
		List<Stream<Character>> c12 = strings.stream().map(Test8::getCharacterByString).collect(Collectors.toList());

		// flatMap：流中元素平铺合并（所有元素平铺的流）
		List<Character> c13 = strings.stream().flatMap(Test8::getCharacterByString).collect(Collectors.toList());

		// sorted:流排序
		List<String> c14 = names.stream().sorted().collect(Collectors.toList());

		// sorted:正向中文排序
		List<String> c15 = names.stream().sorted(Collator.getInstance(Locale.CHINA)).collect(Collectors.toList());
		// sorted:反向中文排序
		List<String> c16 = names.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA)))
				.collect(Collectors.toList());

		// 将 students 集合按照年龄进行排序，年龄相同则通过 id 进行排序
		List<Student> c17 = students.stream()
				.sorted(Comparator.comparing(Student::getAge).thenComparing(Student::getId))
				.collect(Collectors.toList());

		// anyMatch:检查集合中是否至少匹配一个元素
		// 检查集合 strings 中是否有包含 bc 的元素
		boolean b1 = strings.stream().anyMatch(str -> str.contains("bc"));

		// 检查集合 students 中是否有同学成绩不存在
		boolean b2 = students.stream().anyMatch(stu -> stu.getScore() == null);

		// allMatch:检查是否匹配所有元素，返回 boolean
		// 检查集合中的元素是否都大于 0
		boolean b3 = ints.stream().allMatch(i -> i > 0);

		// reduce:将流中元素反复结合起来，得到一个值
		/**
		 * acc：初始化值，默认为 null ; item：集合中的元素
		 */
		Optional<String> reduce1 = strings.stream().reduce((acc, item) -> {
			return acc + item;
		});
		reduce1.ifPresent(System.out::println);
		// 获取集合 students 的总体成绩
		Optional<Integer> reduce2 = students.stream().map(stu -> stu.getScore() == null ? 0 : stu.getScore())
				.reduce(Integer::sum);
		reduce2.ifPresent(System.out::println);

		// count:集合元素数量统计
		long l1 = strings.stream().count();
		// 统计成绩大于 90 的分同学的个数
		long l2 = students.stream().filter(stu -> (stu.getScore() == null ? 0 : stu.getScore()) > 90).count();

		// 【错误写法】返回统计是Boolean的数量
		List<Boolean> collect = students.stream().map(stu -> (stu.getScore() == null ? 0 : stu.getScore()) > 90)
				.collect(Collectors.toList());

		// Stream.of 初始化集合
		List<String> list = Stream.of("1", "2", "3").collect(Collectors.toList());
		System.out.println("list = " + list);

		// peek
		// 将学生成绩为空的同学记上 0 分 返回
		List<Student> peekStudents = students.stream().filter(student -> student.getScore() == null)
				.peek(student -> student.setScore(0)).collect(Collectors.toList());
		System.out.println("peekStudents = " + peekStudents);

	}

	/**
	 * 字符串转换为字符流
	 */
	public static Stream<Character> getCharacterByString(String str) {
		List<Character> characterList = new ArrayList<>();
		for (Character character : str.toCharArray()) {
			characterList.add(character);
		}
		return characterList.stream();
	}

	{
		strings = Arrays.asList("abc", "0", "bc", "for", "bc", "e fg", "jse", "Ff", "jkl", "886");
		ints = Arrays.asList(100, 84, 66, 5, 41, 2, 0, -7, 88, -201);
		names = Arrays.asList("张三", "李四", "王二", "麻子", "翠花", "壮壮", "狗蛋", "小红");
		students = new ArrayList<>();
		students.add(new Student(1, "米大傻", 18, 90));
		students.add(new Student(2, "米二傻", 18, 91));
		students.add(new Student(3, "米三傻", 19, 92));
		students.add(new Student(4, "米四傻", 18, null));
		students.add(new Student(5, "米五傻", 20, 88));
		students.add(new Student(6, "米六傻", 18, 98));
		students.add(new Student(7, "米七傻", 21, 100));
		students.add(new Student(7, "米七傻", 21, 100));
		students.add(new Student(9, "米九傻", 19, 73));
		students.add(new Student(10, "米十傻", 22, 90));
	}

	public class Student {
		public Student(Integer id, String name, Integer age, Integer score) {
			super();
			this.id = id;
			this.name = name;
			this.age = age;
			this.score = score;
		}

		private Integer id;
		private String name; // 姓名
		private Integer age; // 年龄
		private Integer score; // 成绩

		@Override
		public String toString() {
			return "Student [id=" + id + ", name=" + name + ", age=" + age + ", score=" + score + "]";
		}

		public Integer getId() {
			return id;
		}

		public void setId(Integer id) {
			this.id = id;
		}

		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 Integer getScore() {
			return score;
		}

		public void setScore(Integer score) {
			this.score = score;
		}
	}
}