Java 8新特性简介:
Java 8(又称为jdk1.8)是Java语言开发的一个主要版本。Java 8是oracle公司于2014年3月发布,就可以看成是Java 5以来最具革命性的版本。Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量的新特性。
优点:
1)速度更快
2)代码更少(增加了新的语法:Lambda 表达式)
3)强大的Stream API
4)便于并行
5)最大化减少空指针异常:Optional
6)Nashorn引擎,允许在JVM上运行JS应用
并行流与串行流:
并行流就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的流。相比较串行的流,并行的流可以很大程度上提高程序的执行效率。
Java 8中将并行进行优化,可以很很容易的对数据进行并行操作。
Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换。
1)使用多核对数组进行排序:
Arrays.parallelSort(numbers);
2)根据特定地条件(比如:素数和非素数)对数组进行分组:
Map<Boolean,List<Integer>> groupByPrimary=numbers.parallelStream().collect(Collectors.groupingBy(s->Utility.isPrime(s)));
3)对数组进行过滤:
Integer[] prims=numbers.parallelStream().filter(s->Utility.isPrime(s)).toArray();
Lambda表达式:
Lambda是一个匿名函数,可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。
使用举例:
import org.junit.Test;
import java.io.OutputStream;
import java.util.Comparator;
/*
Lambda表达式的使用举例
*/
public class LambdaTest {
@Test
public void test1(){
Runnable r1=new Runnable() {
@Override
public void run() {
System.out.println("Beijing");
}
};
r1.run();
Runnable r2=()-> System.out.println("Shanghai");
r2.run();
}
@Test
public void test2(){
Comparator<Integer> com1=new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1,o2);
}
};
int compare1=com1.compare(12,21);
System.out.println(compare1);//-1
System.out.println("*****************");
//Lambda表达式的写法
Comparator<Integer> com2=new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1,o2);
}
};
int compare2=com2.compare(32,21);
System.out.println(compare2);//1
System.out.println("*******************");
//方法引用
Comparator<Integer> com3=Integer::compare;
int compare3=com3.compare(32,21);
System.out.println(compare3);//1
}
}
Lambda表达式的使用:
1)Lambda表达式:在Java 8语言中引入的一种新的语法元素和操作符。这个操作符为“->”,该操作符被称为Lambda操作符或箭头操作符。他将Lambda分为两个部分
2)举例:(o1,o2) -> Integer.compare(o1,o2);
3)格式:->:Lambda操作符或箭头操作符
->左边:Lambda形参列表(其实就是接口中抽象方法的形参列表)
->右边:Lambda体(其实就是重写抽象方法的方法体)
4)Lambda表达式的六种语法格式:
语法格式一:无参,无返回值
Runnable r1=()->{System.out.println("Hello Lambda!");};
语法格式二:Lambda需要一个参数,但是没有返回值
Consummer<String> con=(String str)->{System.out.println(str);};
语法格式三:数据类型可以省略,因为可由编译器推断得出,称为“类型推断”
Consumer<String> con=(str)->{System.out.println(str);};
语法格式四:Lambda若只需要一个参数时,参数的小括号可以省略
Consumer<String> con=str->{System.out.println(str);};
语法格式五:Lambda需要两个或以上的参数,多条执行语句,并且可以有返回值
Comparator<Integer> com=(x,y)->{
System.out.println("实现函数式接口方法");
return Integer.compare(x,y);
}
语法格式六:当Lambda体只有一条语句时,return与大括号若有,都可以省略
Comparator<Integer> com=(x,y)->Integer.compare(x,y);
总结:
->左边:lambda形参列表的参数类型可以省略(类型推断);如果lambda形参列表只有一个参数,其一对()也可以省略
->右边:lambda体应该使用一堆{}包裹;如果lambda体只有一条执行语句(可能是return语句),可以省略这一对{}和return关键字
5)Lambda表达式的本质:作为接口的实例
import org.junit.Test;
import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;
/*
Lambda表达式的使用
*/
public class LambdaTest1 {
//语法格式一:无参,无返回值
//Runnable r1=()->{System.out.println("Hello Lambda!");};
@Test
public void test1(){
Runnable r1=new Runnable() {
@Override
public void run() {
System.out.println("Beijing");
}
};
r1.run();
Runnable r2=()-> {System.out.println("Shanghai");};
r2.run();
}
//语法格式二:Lambda需要一个参数,但是没有返回值
// Consummer<String> con=(String str)->{System.out.println(str);};
@Test
public void test2(){
Consumer<String> con=new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("How are you?");
System.out.println("**************8");
Consumer<String> con1=(String s)->{
System.out.println(s);
};
con1.accept("I'm fine.");
}
//语法格式三:数据类型可以省略,因为可由编译器推断得出,称为“类型推断”
//Consumer<String> con=(str)->{System.out.println(str);};
@Test
public void test3(){
Consumer<String> con1=(String s)->{
System.out.println(s);
};
con1.accept("I'm fine.");
System.out.println("****************");
Consumer<String> con2=(s)->{//类型推断
System.out.println(s);
};
con2.accept("I'm fine.");
System.out.println("*************");
//其他类型推断情况举例
ArrayList<String> list=new ArrayList<>();
int[] arr={1,2,3};
}
//语法格式四:Lambda若只需要一个参数时,参数的小括号可以省略
//Consumer<String> con=str->{System.out.println(str);};
@Test
public void test4(){
Consumer<String> con1=(s)->{//类型推断
System.out.println(s);
};
con1.accept("I'm fine.");
System.out.println("*************");
Consumer<String> con2=s->{//类型推断
System.out.println(s);
};
con2.accept("I'm fine.");
}
//语法格式五:Lambda需要两个或以上的参数,多条执行语句,并且可以有返回值
// Comparator<Integer> com=(x,y)->{
// System.out.println("实现函数式接口方法");
// return Integer.compare(x,y);
// }
@Test
public void test5(){
Comparator<Integer> com1=new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
};
System.out.println(com1.compare(12,21));
System.out.println("**************");
Comparator<Integer> com2=(o1,o2)->{
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(com2.compare(12,6));
}
//语法格式六:当Lambda体只有一条语句时,return与大括号若有,都可以省略
//Comparator<Integer> com=(x,y)->Integer.compare(x,y);
@Test
public void test6(){
Comparator<Integer> com1=(o1,o2)->{
return o1.compareTo(o2);
};
System.out.println(com1.compare(12,6));
System.out.println("**************");
Comparator<Integer> com2=(o1,o2)->o1.compareTo(o2);
System.out.println(com2.compare(12,5));
}
@Test
public void test7(){
Consumer<String> con1=s->{
System.out.println(s);
};
con1.accept("I'm fine");
System.out.println("*************");
Consumer<String> con2=s-> System.out.println(s);
con2.accept("i'm fine");
}
}
函数式(Functional)接口:
1)只包含一个抽象方法的接口,称为函数式接口。
2)可以通过Lambda表达式来创建该接口的对象。(若Lambda表达式抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽象方法上进行声明)。
3)可以在一个接口上使用@Functionallnterface注解,这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明,说明这个接口是一个函数式接口。
4)在java.util.function包下定义了Java 8的丰富的函数式接口。
理解函数式接口:
1)Java从诞生日起就一致倡导“一切皆对象”,在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战,Java不得不做出调整以便支持更加广泛的技术要求,也即java不但可以支持OOP还可以支持OOF(面向函数编程)。
2)在函数式编程语言当中,函数被当作一等公民对