1.Java 7 和 Java 8 的编程格式对数组的排序区别：
package com.javanew; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class Java8Tester { public static void main(String[] args) { List<String> names1 = new ArrayList<String>(); names1.add("Google "); names1.add("Runoob "); names1.add("Taobao "); names1.add("Baidu "); names1.add("Sina "); List<String> names2 = new ArrayList<String>(); names2.add("Google "); names2.add("Runoob "); names2.add("Taobao "); names2.add("Baidu "); names2.add("Sina "); Java8Tester tester = new Java8Tester(); System.out.println("使用 Java 7 语法: "); tester.sortUsingJava7(names1); System.out.println(names1); //[Baidu , Google , Runoob , Sina , Taobao ] System.out.println("使用 Java 8 语法: "); tester.sortUsingJava8(names2); System.out.println(names2); //[Baidu , Google , Runoob , Sina , Taobao ] } // 使用 java 7 排序 private void sortUsingJava7(List<String> names) { Collections.sort(names, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }); } // 使用 java 8 排序 private void sortUsingJava8(List<String> names) { Collections.sort(names,(s1,s2)->s1.compareTo(s2)); } }
执行以上脚本，输出结果为：
使用 Java 7 语法: [Baidu , Google , Runoob , Sina , Taobao ] 使用 Java 8 语法: [Baidu , Google , Runoob , Sina , Taobao ]
2.Lambda 表达式实例
package com.javanew; public class Java8Tester2 { public static void main(String args[]){ Java8Tester2 tester = new Java8Tester2(); // 类型声明 MathOperation addition = (int a, int b) -> a + b; // 不用类型声明 MathOperation subtraction = (a, b) -> a - b; // 大括号中的返回语句 MathOperation multiplication = (int a, int b) -> { return a * b; }; // 没有大括号及返回语句 MathOperation division = (int a, int b) -> a / b; System.out.println("10 + 5 = " + tester.operate(10, 5, addition)); System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction)); System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication)); System.out.println("10 / 5 = " + tester.operate(10, 5, division)); // 不用括号 GreetingService greetService1 = message -> System.out.println("Hello " + message); // 用括号 GreetingService greetService2 = (message) -> System.out.println("Hello " + message); greetService1.sayMessage("Runoob"); greetService2.sayMessage("Google"); } interface MathOperation { int operation(int a, int b); } interface GreetingService { void sayMessage(String message); } private int operate(int a, int b, MathOperation mathOperation){ return mathOperation.operation(a, b); } }
执行以上脚本，输出结果为：
10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Runoob
Hello Google
使用 Lambda 表达式需要注意以下两点：
- Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
- Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。
3.变量作用域
lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
package com.javanew; /** * lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。 * * 在 Java8Tester.java 文件输入以下代码： */ public class Java8Tester3 { final static String salutation = "Hello! "; public static void main(String[] args) { GreetingService greetingService = message -> System.out.println(salutation + message); greetingService.sayMessage("Runoob"); } interface GreetingService { void sayMessage(String message); } }
执行以上脚本，输出结果为：
Hello! Runoob
我们也可以直接在 lambda 表达式中访问外层的局部变量：
package com.javanew; /** * lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义） */ public class Java8Tester4 { public static void main(String[] args) { final int num = 1; Converter<Integer, String> s = (param) -> System.out.println(param + num); s.convert(2); //在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。 //String first = ""; //Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length()); //编译会出错 } interface Converter<T1, T2> { void convert(int i); } }
执行以上脚本，输出结果为：
3
lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）
int num = 1; Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num)); s.convert(2); num = 5; //报错信息：Local variable num defined in an enclosing scope must be final or effectively final
在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。
String first = ""; Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length()); //编译会出错
4.Java 8 Stream
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
4.1 生成流
在 Java 8 中, 集合接口有两个方法来生成流：
-
stream() − 为集合创建串行流。
-
parallelStream() − 为集合创建并行流。
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
strings.forEach(s -> System.out.println(s));
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
filtered.forEach(s -> System.out.println(s));
执行以上脚本，输出结果为：
abc
bc
efg
abcd
jkl
abc
bc
efg
abcd
jkl
4.2 forEach
Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数：
Random random = new Random(); random.ints().limit(10).forEach(System.out :: println);
执行以上脚本，输出结果为：
-1116307658 113713667 713709096 -1553924501 1540493620 1139141172 1647851419 -2141871504 1467377428 1094015625
4.3 map
map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); // 获取对应的平方数 List<Integer> collect = numbers.stream().map(i -> i * i).distinct().collect(Collectors.toList()); collect.forEach(integer -> System.out.println(integer));
执行以上脚本，输出结果为：
9 4 49 25
4.4 filter
filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：
List<String> strings1 = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
// 获取空字符串的数量
long count = strings1.stream().filter(s -> s.isEmpty()).count();
System.out.println("空字符串的数量" + count);
执行以上脚本，输出结果为：
空字符串的数量2
4.5 limit
limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据：
Random random1 = new Random(); random1.ints().limit(10).forEach(System.out::println);
执行以上脚本，输出结果为：
101296541 -298086596 7541451 430084941 26151896 -839265452 -1012172747 -484220720 -1185963928 -2000924441
4.6 sorted
sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：
Random random2 = new Random(); random2.ints().limit(10).sorted().forEach(System.out::println);
执行以上脚本，输出结果为：
-1878753021 -680235572 -500874087 450643516 825222740 946536649 1528564237 1673649567 1857591683 1996823357
4.7 并行（parallel）程序
parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：
List<String> strings2 = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
// 获取空字符串的数量
Long count2 = strings.parallelStream().filter(string -> string.isEmpty()).count();
System.out.println("并行（parallel）程序空字符串的数量" + count2);
我们可以很容易的在顺序运行和并行直接切换。
执行以上脚本，输出结果为：
并行（parallel）程序空字符串的数量2
4.8 Collectors
Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
List<String> strings3 = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered1 = strings3.stream().filter(s -> !s.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered1);
String mergedString = strings3.stream().filter(s -> !s.isEmpty()).collect(Collectors.joining(","));
System.out.println("合并字符串: " + mergedString);
执行以上脚本，输出结果为：
筛选列表: [abc, bc, efg, abcd, jkl]
合并字符串: abc,bc,efg,abcd,jkl
4.9 统计
另外，一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。
List<Integer> numbers2 = Arrays.asList(3, 2, 2, 3, 7, 3, 5); IntSummaryStatistics stats = numbers2.stream().mapToInt((x) -> x).summaryStatistics(); System.out.println("列表中最大的数 : " + stats.getMax()); System.out.println("列表中最小的数 : " + stats.getMin()); System.out.println("所有数之和 : " + stats.getSum()); System.out.println("平均数 : " + stats.getAverage()); List<Users> list = new ArrayList<>(); Users users1 = new Users(); users1.setName("aaa"); users1.setMoney(100); Users users2 = new Users(); users2.setName("bbb"); users2.setMoney(300); list.add(users1); list.add(users2); List<Integer> collect1 = list.stream().map(users -> users.getMoney()).collect(Collectors.toList()); List<Integer> collect2 = list.stream().map(Users::getMoney).collect(Collectors.toList()); System.out.println("collect1输出"); collect1.forEach(System.out :: println); System.out.println("collect2输出"); collect2.forEach(i -> System.out.println(i)); LongSummaryStatistics statistics = collect1.stream().mapToLong((x) -> x).summaryStatistics(); System.out.println("列表中最大的数 : " + statistics.getMax()); System.out.println("列表中最小的数 : " + statistics.getMin()); System.out.println("所有数之和 : " + statistics.getSum()); System.out.println("平均数 : " + statistics.getAverage());
执行以上脚本，输出结果为：
列表中最大的数 : 7 列表中最小的数 : 2 所有数之和 : 25 平均数 : 3.5714285714285716 collect1输出 100 300 collect2输出 100 300 列表中最大的数 : 300 列表中最小的数 : 100 所有数之和 : 400 平均数 : 200.0
MemberInVoice 和 MemberInvoiceItem 是一对多的关系，MemberInvoiceItem有商品和运费的明细数据，现根据MemberInVoice进行分组
1 // 订单下所有的发票明细 2 List<MemberInvoiceItem> orderMemberInvoiceItemList = new ArrayList<>(); 3 // 汇总商品 4 orderMemberInvoiceItemList.addAll(memberInvoiceItems); 5 // 汇总运费 6 orderMemberInvoiceItemList.addAll(feeItems); 7 8 Map<MemberInVoice, List<MemberInvoiceItem>> invoiceGroup = orderMemberInvoiceItemList.stream().collect(Collectors.toMap(memberInvoiceItem -> memberInvoiceItem.getMemberInVoice(), memberInvoiceItem -> memberInvoiceItem.getMemberInVoice().getInvoiceItems())); 9 for (Map.Entry<MemberInVoice, List<MemberInvoiceItem>> entry : invoiceGroup.entrySet()) { 10 entry.getKey().setTotalTax(new BigDecimal(entry.getValue().stream().mapToDouble(memberInvoiceItemTemp -> memberInvoiceItemTemp.getTaxPrice().doubleValue()).sum())); 11 memberInvoiceRepos.saveAndFlush(entry.getKey()); 12 }
5.0 判断一个List对象中某个属性是否相同
1 Map<String, List<InvoiceInfoDto>> collect = invoiceInfos.stream().collect(Collectors.groupingBy(InvoiceInfoDto::getType, Collectors.mapping(invoiceInfo -> invoiceInfo, Collectors.toList())));