java1.8的几大新特性

 1 public class Test {
 2     public static void main(String[] args) {
 3         Formula a=new For();
 4         a.calculate(1);
 5         System.out.println(a.sqrt(8));
 6 
 7 
 8     }
 9     interface Formula {
10         double calculate(int a);
11         default double sqrt(int a) {//这个方法可以在实现类重写，或者直接使用
12             return Math.sqrt(a);
13         }
14     }
15     static class For implements Formula{
16         @Override
17         public double calculate(int a) {
18             return 0;
19         }
20 
21         @Override
22         public double sqrt(int a) {
23             return 0;
24         }
25     }
26 }

 1 public class Test {
 2     public static void main(String[] args) {
 3         List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
 4         Collections.sort(names, new Comparator<String>() {//java以前老版本的写法
 5             @Override
 6             public int compare(String a, String b) {
 7                 return b.compareTo(a);
 8             }
 9         });
10         for(String name:names){
11             System.out.println(name);
12         }
13     }
14 
15 }

 1 只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。
 2 在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：
 3 复制代码 代码如下:
 4 
 5 Collections.sort(names, (String a, String b) -> {
 6     return b.compareTo(a);
 7 });
 8 
 9 看到了吧，代码变得更段且更具有可读性，但是实际上还可以写得更短：
10 复制代码 代码如下:
11 
12 Collections.sort(names, (String a, String b) -> b.compareTo(a));
13 
14 对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点：
15 复制代码 代码如下:
16 
17 Collections.sort(names, (a, b) -> b.compareTo(a));
18 
19 Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型。接下来我们看看lambda表达式还能作出什么更方便的东西来：

 1 public class Test {
 2     public static void main(String[] args) {
 3         Converter<String, Integer> a = (from) -> Integer.valueOf(from);
 4         
 5         //Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用
 6         Converter<String, Integer> converter = Integer::valueOf;//这个是静态方式导入 
 7 
 8         Integer m=a.convert("123");
 9         System.out.println(m);
10         test test=mmm -> "aaaa";//mmm代表你要传入的参数
11         String testResult=test.aa("");//aa代表你要传入的方法
12         System.out.println(testResult);
13     }
14 
15     @FunctionalInterface
16     interface Converter<F, T> {
17         T convert(F from);
18     }
19 
20     interface test{
21         String aa(String mmm);
22     }
23 
24     //使用函数式接口时，接口的定义只能有一个，@FunctionalInterface注解可有可无
25 }

 1 public class Test {
 2     public static void main(String[] args) {
 3         final int num = 1;
 4         Converter<Integer, String> stringConverter =
 5                 (from) -> String.valueOf(from + num);
 6         String str=stringConverter.convert(2);
 7         System.out.println(str);//输出3
 8         //final关键字可以去掉，但是默认是存在的，所以，对num变量不能再次赋值修改
 9     }
10 
11     @FunctionalInterface
12     interface Converter<F, T> {
13         T convert(F from);
14     }
15 
16 }

 1 public class Test {
 2     public static void main(String[] args) {
 3         Lambda4 lambda4=new Lambda4();
 4         lambda4.testScopes();
 5     }
 6 
 7     @FunctionalInterface
 8     interface Converter<F, T> {
 9         T convert(F from);
10     }
11 
12     static class Lambda4 {
13         static int outerStaticNum=0;
14         int outerNum=0;
15         void testScopes() {
16             Converter<Integer, String> stringConverter1 = (from) -> {
17                 outerNum = 23;
18                 return String.valueOf(outerNum);
19             };
20             String a=stringConverter1.convert(outerNum);
21             System.out.println(a);//输出23
22             Converter<Integer, String> stringConverter2 = (from) -> {
23                 outerStaticNum = 72;
24                 return String.valueOf(outerStaticNum);
25             };
26 
27         }
28     }
29     
30     //这里的意思是outerStaticNum与outerNum两个参数可以多次赋值
31     
32 }