java8新特性

在前面已经见过一些东西了，但是：挖得有坑儿，主要是为了养成独立思考的习惯

因为：灌入式学习并不好

1、lambda表达式

• lambda表达式是jdk1.8引入的全新语法特性
• 它支持的是:只有单个抽象方法的函数式接口。什么意思？
  • 就是说：这个接口下面只有一个抽象方法是真正属于自己的（ 像那种从Object类里面继承过来的不算 ———— 所以这样严格来讲：这个接口里面就只有一个抽象方法是真正属于自己的

• 什么时候会用这个东西？ ———— 总的一句话是：函数式接口传参的时候会用（ 这句话包含了很多东西，这里不理解没事儿，学完了就懂了 ）
  • 1、简化匿名内部类
    • 以前玩儿匿名内部类的时候不是弄过一点吗，回顾一下

      • package cn.xieGongZi.reviewInnerClass;
        
        import java.util.TreeSet;
        
        // 回顾一下以前玩匿名内部类
        public class Demo {
        
            public static void main(String[] args) {
        
                // 以前在treeSet中研究过它的底层排序原理，所以再来玩儿一下
                TreeSet<Integer> treeSet = new TreeSet<>();
        
                treeSet.add(20);
                treeSet.add(30);
                treeSet.add(1);
                treeSet.add(9);
                treeSet.add(10);
                treeSet.add(18);
        
                System.out.println( treeSet );  // 这是升序排列，那我想降序排列呢？
        
            }
        }

        

         来嘛：改变排序规则

      • package cn.xieGongZi.reviewInnerClass;
        
        import java.util.Comparator;
        import java.util.TreeSet;
        
        // 回顾一下以前玩的匿名内部类
        public class Demo {
        
            public static void main(String[] args) {
        
                // 来吧：改变排序规则 ———— 重写comparator接口（ 匿名内部类 )
                TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {
                    @Override
                    public int compare(Integer o1, Integer o2) {
                        return o2 - o1;   // 改变比较规则
                    }
                });
        
                treeSet.add(20);
                treeSet.add(30);
                treeSet.add(1);
                treeSet.add(9);
                treeSet.add(10);
                treeSet.add(18);
        
                System.out.println(treeSet);
        
            }
        }

        

         

         这样虽然是把排序规则改变了，但是不麻烦吗？

        • 所以：lambda表达式来了————再来回顾一下lambda的表达式是怎么样的？
          • 【 函数式接口】  对象名 ( 参数 )-> { 集合体( 业务代码 ）}　  ———— 那再来玩儿一下

            • package cn.xieGongZi.reviewInnerClass;
              
              import java.util.TreeSet;
              
              public class UseLambda {
              
                  public static void main(String[] args) {
              
              
                      // 来吧：改变排序规则 ———— 使用lambda表达式
                      TreeSet<Integer> treeSet = new TreeSet<>( (o1,o2 )-> {  // 1、为什么这里写两个o1,o2的参数，然后加个{}，这个表达式就可以去执行相应的东西
                                                                              // 即：这个表达式怎么知道  老衲重写的是Comparator接口？
                                                                              // 2、另外一个问题：看起来这个o1,o2貌似没有值吧
                                                                              // 它不是参数吗，在这里看起没赋值啊，所以最后怎么可以得出结果？
              
                              return o2 - o1;   // 改变比较规则————即：业务代码
                      } );
              
                      treeSet.add(20);
                      treeSet.add(30);
                      treeSet.add(1);
                      treeSet.add(9);
                      treeSet.add(10);
                      treeSet.add(18);
              
                      System.out.println(treeSet);
                  }
              }

              效果图如下：
              • 
                
            • 为了解决解决上述代码中的问题，来看一下如下代码（ 顺便引申出函数式接口是什么意思 ）

              • package cn.xieGongZi.functionInterface;
                
                public class Test {
                
                    public static void main(String[] args) {
                
                
                        // 开始玩儿
                        test test = new test();
                        test.doAdd( new TestFunctionInterface() {   // 这中间的这一坨就是一个对象嘛 ———— 一个TestFunctionInterface对象
                                                                    // 这里面是用了这个对象 去 调用了TestFunctionInterface中的add()方法
                                                                    // 所以结果来了：lambda表达式中有一个对象名，这个对象名就是这里的TestFunctionInterface的对象
                                                                    // 参数有没有值：有，为什么？
                                                                    // 就是调用doAdd()方法的时候不得传个参数吗，这里说的参数是TestFunctionInterface这个对象携带进去的
                                                                    // 携带进去之后去了哪里？ ———— 把这个值赋给了重写的add()方法里面需要的参数了嘛
                
                                                                    // 因此：总结一句话就是lambda表达式就是指：把一段代码（ 这段代码里面做了一些事情，如：这里的输出语句 ）传递给了某一个函数，从而让这个函数去执行相关的操作
                                                                    // 要真正理解lambda表达式，关键就是这里的回调，就这里会绕一下
                            @Override
                            public void add() {
                                // 正常是这么玩儿的————重写这个方法
                                System.out.println("老衲自东土大唐而来.....");
                            }
                        });       // 这里面doAdd()中是不是需要传一个TestFunctionInterface类型的参数（ 这个参数指向的那个类型，就是他喵说的函数式接口 ）
                                 // 在java中是不是函数式接口，会有一个注解来进行说明@FunctionalInterface ———— 这个东西就是一个声明性的东西而已
                
                    }
                }
                
                
                // 定义一个接口
                interface TestFunctionInterface{
                
                    // 这里面只有这一个方法是真正属于这个接口的
                    void add();
                }
                
                class test{
                
                    public void doAdd( TestFunctionInterface t ){
                        t.add();    // 这里用TestFunctionInterface类型的对象 回调 TestFunctionInterface中的抽象方法
                    }
                }

                 

                
                

javaSE高级篇6——java8新特性详解