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());

最后

以上就是壮观音响为你收集整理的jdk1.8新特新的全部内容，希望文章能够帮你解决jdk1.8新特新所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。