1,为什么要介绍java8的相关特性?
因为现在的企业大部分已经从java7向java8开始迈进了,用java8的公司越来越多了,java8中的一些知识还是需要了解一些的;
java8具有以下特点:
速度更快（底层的数据结构做了一些更新和改动，垃圾回收机制内存结构做了一些改动）
代码更少（增加了新的语法 Lambda 表达式）
强大的 StreamAPI
便于并行
最大化减少空指针异常（Optional 容器类）
主要内容:
1、Lambda 表达式
2、函数式接口
3、方法引用与构造器引用
4、StreamAPI
5、接口中的默认方法与静态方法
6、新时间日期 API
7、其他新特性
一,Lambda表达式
什么是lambda表达式?
Lambda 表达式是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的
代码风格，使得 Java 语言表达能力得到了提升。Java8 中引入了一个新的操作符”->”该操作符称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分为两部分：
左侧：Lambda 表达式的参数列表。对应接口中抽象方法的参数列表。右侧：Lambda 表达式中所需要执行的功能，即 Lambda 体。对应接口中抽象方法的实现。
Lambda 表达式的基础语法
public class Java8Test {
/*
无参数,无返回值
* */
@Test
public void test01(){
Runnable r=new Runnable() {
@Override
public void run() {
System.out.println("liuqingfeng");
}
};
r.run();
System.out.println("****************");
Runnable r2= () -> System.out.println("hello lambda!");
r2.run();
}
//有一个参数,无返回值
@Test
public void test02(){
Consumer<String> con=(t) -> System.out.println(t);
con.accept("1");
}
//只有一个参数，小括号可以省略不写
@Test
public void test03(){
Consumer<String> con= t -> System.out.println(t);
con.accept("2");
}
//有两个以上的参数 ，有返回值 ， 并且Lambda体中有多条语句
@Test
public void test04(){
Comparator<Integer> com=(x,y) ->{
System.out.println("hello world");
Integer a=Integer.compare(x,y);
System.out.println(a);
return a;
};
int i = com.compare(8, 4);
System.out.println(i);
}
//若Lambda体中只有一条语句，return 和大括号都可以省略不写
@Test
public void test05(){
Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
System.out.println(com.compare(1,2));
}
//Lambda 表达式的参数列表的数据类型可以省略不写，因为 JVM 编译器通过上下文推断出
//数据类型，即“类型推断”
@Test
public void test06(){
Comparator<Integer> com = (Integer x, Integer y) -> Integer.compare(x, y);
show(new HashMap<>());// jdk1.8 以后
}
public void show(Map<String, Integer> map) {
}
//使用函数式接口
@Test
public void test7() {
Integer result = operation(100, (x) -> x * x);
System.out.println(result);
result = operation(200, (y) -> y - 100);
System.out.println(result);
}
public Integer operation(Integer num, MyFunction<Integer> mf) {
return mf.getValue(num);
}
@FunctionalInterface
public interface MyFunction<T> {
public T getValue(T o);
}
}二,四大内置核心函数式接口
public class test8_02 {
/*
* Consumer<T> 消费型接口
* void accept(T t);
*/
@Test
public void test01(){
happy(10000,(m)->System.out.println("杜立宏要去大保健"));
}
public void happy(double money, Consumer<Double> con){
con.accept(money);
}
//供给型接口
@Test
public void test02(){
List<Integer> numlist=getNumList(10,()->(int)(Math.random()*100));
System.out.println(numlist.toString());
}
public List<Integer> getNumList(int num,Supplier<Integer> sup){
List<Integer> list=new ArrayList<>();
for(int i=0;i<num;i++){
list.add(sup.get());
}
return list;
}
//函数型接口
@Test
public void test03(){
String newStr=strHandler(" shsxt ",(str)->str.trim());
System.out.println(newStr);
System.out.println("**********************");
newStr=strHandler("bjsxt",(str)->str.substring(1,3));
System.out.println(newStr);
}
public String strHandler(String str, Function<String,String> fun){
return fun.apply(str);
}
//断言型接口
@Test
public void test04(){
List<String> list= Arrays.asList("hello","world","123","ok","God");
list= stringFilter(list,(str)->str.length()>3);
System.out.println(list.toString());
}
public List<String> stringFilter(List<String> list, Predicate<String> pre){
List<String> li=new ArrayList<>();
for(String str:list){
if(pre.test(str)){
li.add(str);
}
}
return li;
}