jdk1.8新特新

Lamdba表达式

1.Java8概述

Java8，也就是jdk1.8，是意义深远的一个新版本

是Java5之后一个大的版本升级，让Java语言和库仿佛获得了新生

2.什么是Lambda表达式

带有参数变量的表达式，是一段可以传递的代码，可以被一次或多次执行

是一种精简的字面写法，其实就是把匿名内部类中“一定”要做的工作省略掉

然后由JVM通过推导把简化的表达式还原

格式： (parameters参数) -> expression表达式或方法体

paramaters：

类似方法中的形参列表，这里的参数是函数式接口里的参数

->：可理解为“被用于”的意思

方法体：

可以是表达式也可以代码块，是函数式接口里方法的实现

如果负责运算的代码无法用表达式表示，可以使用编写方法实现

但必须用{}包围并按需明确使用 return语句

需求：对字符串数组按字符串长度排序

package org.xxxx.demo;
 
import java.util.Arrays;
import java.util.Comparator;
 
public class Demo {
	public static void main(String[] args) {
		// 定义字符串数组
		String[] strArr = { "abc", "cd", "abce", "a" };
 
		// 传统方法
		// 匿名内部类
		Arrays.sort(strArr, new Comparator<String>() {
 
			@Override
			public int compare(String s1, String s2) {
				return Integer.compare(s2.length(), s1.length());
			}
		});
 
		// 输出排序结果
		for (String s : strArr) {
			System.out.println(s);
		}
		System.out.println("---------------------");
 
		// Lambda表达式
		Arrays.sort(strArr, (s1, s2) -> Integer.compare(s2.length(), s1.length()));
 
		// 输出
		for (String s : strArr) {
			System.out.println(s);
		}

Stream()流

常用操作:

1.forEach

迭代集合中元素。接收一个 Lambda 表达式

然后在 Stream 的每一个元素上执行该表达式

此操作是及早求值方法

2.collect(toList())

由Stream 里的值生成一个列表，是一个及早求值操作

很多Stream 操作都是惰性求值，因此调用Stream 一系列方法之后

还需最后再调用一个类似collect 的及早求值方法返回集合

开篇的例子：(再将符合要求的字符串放到一个新的集合里)

使用filter过滤器：遍历数据并检查其中的元素

package org.xxxx.demo;
 
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
 
public class Demo {
	public static void main(String[] args) {
		// 创建集合
		List<String> list = new ArrayList<>();
 
		// 添加元素
		list.add("sdf");
		list.add("a");
		list.add("asdf");
		list.add("d");
		list.add("basdfgh");
 
		// 统计长度大于2的
		long count = list.stream().filter((s) -> s.length() > 2).count();
 
		// 将符合要求的放入集合
		List<String> list2 = list.stream().filter((s) -> s.length() > 2).collect(Collectors.toList());
 
		System.out.println(count);
		list2.forEach(System.out :: println);
	}
}

map:
如果有一个函数可以将一种类型的值转换成另外一种类型
map 操作就可以使用该函数，将一个流中的值转换成一个新的流
需求：将字符串全转换成大写

package org.xxxx.demo;
 
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
 
public class Demo {
	public static void main(String[] args) {
		// 创建集合
		List<String> list = new ArrayList<>();
 
		// 添加元素
		list.add("sdf");
		list.add("a");
		list.add("asdf");
		list.add("d");
		list.add("basdfgh");
		
		// 转换为大写
		List<String> list2 = list.stream().map((s) -> s.toUpperCase()).collect(Collectors.toList());
		
		list2.forEach(System.out :: println); 
	}
}

filter:
遍历数据并检查其中的元素。例如获取字符串List中以数字开始的字符集合

package org.xxxx.demo;
 
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
 
public class Demo {
	public static void main(String[] args) {
		// 创建集合
		List<String> list = new ArrayList<>();
 
		// 添加元素
		list.add("1sdf");
		list.add("a");
		list.add("2asdf");
		list.add("d");
		list.add("basdfgh");
 
		// 获取数字开头的
		List<String> list2 = list.stream().filter((s) -> Character.isDigit(s.charAt(0))).collect(Collectors.toList());
 
		list2.forEach(System.out::println);
	}
}

max 和 min:
获取Stream中最大值或最小值，获取字符串List中长度最长的字符串长度

package org.xxxx.demo;
 
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
 
public class Demo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		
		list.add("abc");
		list.add("ab");
		list.add("abcd");
		list.add("abcde");
		
		// 获取最大值
		int max = list.stream().map((s) -> s.length()).max(Integer :: compareTo).get();
		System.out.println(max);
		
		// 获取最小值，另一种方法
		int min = list.stream().min(Comparator.comparing((s) -> s.length())).get().length();
		System.out.println(min);
	} 
}

reduce:

通过指定的函数把stream中的多个元素汇聚为一个元素，min max等是它的特例
格式：reduce(初始值，(r, i) -> r + i) 或者 reduce((r, i) -> r + “*” i)
计算1~100的和

package org.xxxx.demo;
 
import java.util.ArrayList;
import java.util.List;
 
public class Demo {
	public static void main(String[] args) {
		List<Long> list = new ArrayList<>();
		
		// 封装到集合
		for (long i = 1; i <= 100; i++) {
			list.add(i);
		}
		
		// 计算
		// reduce：参1，和的初始值
		Long sum = list.stream().parallel().reduce(0L, (r, l) -> r + l);
		
		System.out.println(sum);
	}

过滤包含不相同id的集合：

lists = 
	lists.stream().filter(item -> idList.contains(item.getId()))
		.collect(Collectors.toList());

List 转 Map：
toMap 如果集合对象有重复的key，会报错Duplicate key …
apple1,apple12的id都为1。
可以用 (k1,k2)-> k1 来设置，如果有重复的key,则保留key1,舍弃key2
或者可以用 (k1,k2)-> k2 来设置，如果有重复的key,则保留key2,舍弃key1

Map<String, Student> maps = 
	students.stream().collect(Collectors.toMap(Student::getName,Function.identity(), (k1,k2)-> k1));

通过比较将相同姓名过滤为集合：

List<Student> list =
       list.stream().filter(item -> item.getName().equals("比较的值"))
       		.collect(Collectors.toList());

判断姓名不为空，就获取姓名且过滤为集合：

List<String> nameList = studentList .stream()
	.filter(item -> StringUtils.isNotBlank(item.getName()))
			.map(Student::getName).collect(Collectors.toList());