Java基础之java8新特性（1）Lambda
一、接口的默认方法、static方法、default方法。
1、接口的默认方法
在Java8之前，Java中接口里面的默认方法都是public abstract 修饰的抽象方法，抽象方法并没有方法实体。
public class Test_interface { public static void main(String[] args) { pubInterface ts = new MyInterface(); ts.fun1(); } } //测试接口 interface pubInterface{ public void fun1();//抽象方法 } //接口的实现类 class MyInterface implements pubInterface{ @Override public void fun1() { System.out.println("你好我是TestStatic的实现类"); } }
2、static方法
在Java8中，接口里面可以用static修饰有方法实体的方法。
（1）、使用static修饰的接口中的方法必须要有实体。
（2）、接口的static方法只能够被接口本身调用：接口名.方法名（…）。
（3）、接口的static方法不能够被子接口继承。
（4）、接口的static方法不能够被实现类重写或者调用。
public class Test_interface { public static void main(String[] args) { //该接口直接可以调用static方法，但是不能够调用普通抽象方法。 StaInterface.fun2(); //报错可以得知，static方法是不能够被继承的 SonInterface.fun2(); } } //测试接口 interface StaInterface{ public void fun1();//抽象方法 static void fun2(){ System.out.println("我是static方法……"); } } //接口的实现类 class MyInterface implements StaInterface{ /**只能够重写抽象方法，不能重写static修饰的方法*/ @Override public void fun1() { } } //子接口 interface SonInterface extends StaInterface{ }
3、default方法：
接口的default方法必须有主体
接口的default方法不能被本身接口调用，
接口的default方法可以被子接口继承
接口的default方法可以被实现类复写以及调用
public class Test_interface { public static void main(String[] args) { //该接口直接可以调用static方法，但是不能够调用普通抽象方法。 StaInterface.fun2(); //报错可以得知，static方法是不能够被继承的 SonInterface.fun2(); //default方法与普通抽象方法是可以 StaInterface sf = new MyInterface(); sf.fun1(); sf.fun3(); } } //测试接口 interface StaInterface{ public void fun1();//抽象方法 //static 方法 static void fun2(){ System.out.println("我是static方法……"); } //default方法 default void fun3(){ System.out.println("我是default方法……"); } } //接口的实现类 class MyInterface implements StaInterface{ /**只能够重写抽象方法，不能重写static修饰的方法*/ @Override public void fun1() { } //是可以重写default方法的。 @Override public void fun3() { } } //子接口 interface SonInterface extends StaInterface{ }
二、函数式接口
1、什么是函数式接口：
函数式接口（Functional Interface）就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为lambda表达式。
接口注解：@FunctionalInterface
初体验：
（1）、两个参数，有返回值
public class Lambda_one { public static void main(String[] args) { //匿名内部类的方式 StaInterface se = new StaInterface() { @Override public int sum(int num1, int num2) { return num1 +num2; } }; System.out.println(se.sum(1,3)); //lambda表达式写法 StaInterface seLa1 = (int num1, int num2) -> { return num1 + num2; }; System.out.println("Lambda表达式一：" + seLa1.sum(1,3)); /** * lambda表达式简写 * 1、形参列表中的表达式可以不写，会自行推断 * 2、如果方法体中的代码只有一句，可以省略{}，如果return返回的是数据，可以省略return */ StaInterface seLa2 = (num1, num2) -> num1 + num2; System.out.println("Lambda表达式二：" + seLa2.sum(1,2)); } } //测试接口 @FunctionalInterface interface StaInterface{ public int sum(int num1,int num2);//抽象方法 }
（2）、一个参数，无返回值
public class Lamdba_two { public static void main(String[] args) { //匿名内部类 StaInterface1 s1 = new StaInterface1() { @Override public void getStr(String str) { System.out.println(str); } }; s1.getStr("HelloWorld!!!"); //lambda表达式写法 StaInterface1 s2 = (String str) -> { System.out.println(str); }; s2.getStr("Lambda表达式一："+ "Helloworld一"); StaInterface1 s3 = str -> System.out.println(str); s3.getStr("Lambda表达式二："+ "Helloworld二"); } } //测试接口 @FunctionalInterface interface StaInterface1{ public void getStr(String str);//抽象方法 }
（3）、无参数，无返回值
public class Lambda_three { public static void main(String[] args) { StaInterface2 s1 = new StaInterface2() { @Override public void getStr() { System.out.println("HelloWorld"); } }; s1.getStr(); //Lambda表达式 StaInterface2 s2 = () -> { System.out.println("Lamdba表达式一：" + "HelloWorld一"); }; s2.getStr(); //Lamdba表达式简化,我们可以这么写，但是没有实际意义 StaInterface2 s3 = () -> {}; s3.getStr(); } } //测试接口 @FunctionalInterface interface StaInterface2{ public void getStr();//抽象方法 }
三、Lambda表达式
1、什么是Lambda表达式
简单的说：可以看成是对匿名内部类的简写，使用Lambda表达式时候，接口必须是函数式接口。
2、Lambda表达式语法
基本语法：
<函数式接口> <变量名> = （参数1，参数2……）->{
//方法体
}
3、特点：
（1）、=右边的类型会根据左边的函数式接口类型自动推断；
（2）、如果形参列表为空，只需要保留（）
（3）、如果形参只有一个，（）可以省略，只需要参数名称即可；
（4）、如果执行语句只有一句，且并没有返回值，{}可以省略，如果有返回值，若想省去{}，则必须同时省略return，并且执行语句也保证只有一句。
（5）、形参列表的数据类型会自动推断。
（6）、Lamdba不会生成一个单独的内部类文件。
（7）、lambda表达式如果访问了局部变量，则局部变量必须是final的，若是局部变量没有加final关键字，系统会自动添加，此后在修改局部变量，会报错。
4、Lambda作用域
在Lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似（我们在学习匿名内部类时候，匿名内部类在访问局部变量的时候，局部变量是被final修饰的），你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量，但是如果访问局部变量，要求局部变量必须是final修饰的。
注意：我们Java8新特性里面，匿名内部类访问局部变量，局部变量不需要再用final修饰了，因为Java8已经帮我们写过了，所以我们可以省略。
（1）、匿名内部类举例
public class Lambda_four { public static void main(String[] args) { int age = 9; StaInterface3 s1 = new StaInterface3() { @Override public void getStr() { System.out.println(age); //注意，当我们在下面对age重新赋值时候，这里的age就报错了， // 因为，Java8隐式的对age加上final了 } }; s1.getStr(); age = 10; } } interface StaInterface3{ public void getStr();//抽象方法 }
（2）、Lambda表达式举例
public class Lambda_four { public static void main(String[] args) { int age = 9; StaInterface3 s2 = () ->{ System.out.println(age); //注意，当我们在下面对age重新赋值时候，这里的age就报错了， // 因为，Java8隐式的对age加上final了 }; age = 10; } } interface StaInterface3{ public void getStr();//抽象方法 }
四、方法的引用
1、构造方法的引用
public class Lambda_five { /*需求： * 1、有一个Person类 * 2、有一个获得Person对象的接口工厂 * 3、想通过工厂获得一个Person对象 * 4、需要现有一个实际的工厂对象 */ public static void main(String[] args) { //使用匿名内部类 PersonFactory py = new PersonFactory() { @Override public Person createPerson(String firstName, String lastName) { return new Person(firstName,lastName); } }; Person person1 = py.createPerson("du", "yahui"); System.out.println(person1); //使用Lambda表达式 PersonFactory py1 = (firstName,lastName) ->{ return new Person(firstName,lastName); }; Person person2 = py1.createPerson("mi", "li"); System.out.println(person2); //简写Lambda表达式 PersonFactory py2 = (firstName,lastName) -> new Person(firstName,lastName); Person person3 = py2.createPerson("haha","gaga"); System.out.println(person3); } }
2、静态方法的引用，把String转成num
public class Lambda_six { public static void main(String[] args) { ParseLambda pa = new ParseLambda() { @Override public int parseInteger(String num) { return Integer.parseInt(num); } }; int i1 = pa.parseInteger("12"); System.out.println(i1); //使用Lambda表达式 // ParseLambda p = (String num) ->{ // return Integer.parseInt(num); // }; ParseLambda pa1 = num -> Integer.parseInt(num); int i2 = pa1.parseInteger("123"); System.out.println(i2); //Lambda简写 ParseLambda pa3 = Integer :: parseInt; int i3 = pa3.parseInteger("777"); System.out.println(i3); } } interface ParseLambda{ int parseInteger(String num); }
五、四大核心函数式接口
/* * Java8 内置的四大核心函数式接口 * * Consumer<T> : 消费型接口 * void accept(T t); * * Supplier<T> : 供给型接口 * T get(); * * Function<T, R> : 函数型接口 * R apply(T t); * * Predicate<T> : 断言型接口 * boolean test(T t); * */ public class Lambda_One { //Consumer<T> 消费型接口 :也就是，给一个参数，操作这个参数 @Test public void test1(){ happy(1000,(money) -> System.out.println("出去共消费了" + money + "元")); } public void happy(double money, Consumer<Double> con){ con.accept(money); } //Supplier<T> 供给型接口 :产生一些对象 @Test public void test2(){ List<Integer> listNum = getListNum(10,() -> (int)(Math.random() * 100)); for (Integer integer : listNum) { System.out.println(integer); } } //需求：产生指定个数的整数，并放入集合中 public List<Integer> getListNum(int num, Supplier<Integer> sup){ List<Integer> list = new ArrayList<Integer>(); for(int i = 0; i < num; i++){ list.add(sup.get()); } return list; } //Function<T, R> 函数型接口：传入一个T，返回一个R @Test public void test3(){ String s1 = stringHander(" Helloworld !!!",(str) -> str.trim()); System.out.println(s1); String s2 = stringHander(" Helloworld !!!",(str) -> str.substring(7)); System.out.println(s2); } //需求：处理字符串 public String stringHander(String str, Function<String,String> fun){ return fun.apply(str); } //Predicate<T> 断言型接口：用于做一下判断 @Test public void test4(){ List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok"); List<String> listStr = filterStr(list,(str) -> str.length() > 3); for (String s : listStr) { System.out.println(s); } } //需求：将满足条件的字符串，放入集合中 public List<String> filterStr(List<String> list, Predicate<String> pre){ List<String> strList = new ArrayList<>(); for (String str : list) { if(pre.test(str)){ strList.add(str); } } return strList; } }
其他接口：
