JavaSE：第十六章：java8新特性（上）

 此类用于演示方法引用
 *  举例：
 *     匿名内部类：
 *    UnaryOperator<Double> up = new UnaryOperator<Double>(){
 *      public Double apply(Double t){
 *            return Math.sqrt(t);
 *          }
 *     };
 *     Lambda：
 *     UnaryOperator<Double> up =d->Math.sqrt(d);
 *     方法引用：
     UnaryOperator<Double> up = Math::sqrt;
 */
public class TestMethodRef {
  //1、对象::普通方法
  @Test 
  public void test1_1() {
    //匿名内部类
//    Runnable r = new Runnable() {
//      @Override
//      public void run() {
//        System.out.println();
//      }
//    };
    //方法引用
    Runnable r2 = System.out::println;
    r2.run();
  }
  //对象::普通方法
  @Test 
  public void test1_2() {
    //匿名内部类
//    Consumer<String> con = new Consumer<String>() {
//      @Override
//      public void accept(String t) {
//        System.out.println(t);
//        
//      }
//    };
    //方法引用
    Consumer<String> con2 = System.out::println;
    con2.accept("赵丽颖和冯绍峰已经结婚了");
  }
  //2、类名::静态方法
  @Test 
  public void test2() {
    //匿名内部类
    Comparator<Double> com = new Comparator<Double>() {
      @Override
      public int compare(Double o1, Double o2) {
        return Double.compare(o1, o2);
      }
    };
    //Lambda
    Comparator<Double> com1 = (o1,o2)->Double.compare(o1, o2);
    //方法引用
    Comparator<Double> com2 =Double::compare;
  }
  //3、类名::普通方法
  @Test 
  public void test3() {
    //匿名内部类
//    Function<Employee,String> fun = new Function<Employee,String>(){
//      @Override
//      public String apply(Employee t) {
//        return t.getName();
//      }
//    };
    //方法引用
    Function<Employee,String> fun2 = Employee::getName;
    System.out.println(fun2.apply(new Employee("张无忌", 12, 1000, '男')));
  }
  //3、类名::普通方法
  @Test 
  public void test3_2() {
    //匿名内部类
//    BiFunction<String, String, Boolean>  bf = new BiFunction<String, String, Boolean>() {
//      @Override
//      public Boolean apply(String t, String u) {
//        return t.equals(u);
//      }
//    };
    //方法引用
    BiFunction<String, String, Boolean>  bf2 = String::equals;
    System.out.println(bf2.apply("hello", "Hello"));
  }
}

 此类用于演示构造器引用
public class TestConstructorRef {
  //案例1：返回new String();
  @Test 
  public void test1() {
    //匿名内部类
//    Supplier<String> sup = new Supplier<String>() {
//      @Override
//      public String get() {
//        return new String();
//      }
//    };
    //构造器引用
    Supplier<String> sup2 = String::new;
    int length = sup2.get().length();
    System.out.println(length);
  }
  //案例2：返回new StringBuffer(int capacity);
    @Test 
    public void test2() {
      Function<Integer,StringBuffer> fun = new Function<Integer,StringBuffer>(){
        @Override
        public StringBuffer apply(Integer t) {
          return new StringBuffer(t);
        }
      };
      Function<Integer,StringBuffer> fun2 = StringBuffer::new;
    }
    //案例3：返回new Employee("段誉", 22, 10000, '男')
    @Test 
    public void test3() {
      A<String,Integer,Double,Character,Employee> a1 = (s,i,d,c)->new Employee(s,i,d,c);
      A<String,Integer,Double,Character,Employee> a = Employee::new;
    }
}
interface A<T,R,U,M,N>{
  N test(T t,R r,U u,M m);
}

此类用于演示数组引用
public class TestArrayRef {
  //案例1：返回一个String[] s = new String[5]
  @Test 
  public void test1() {
    //匿名内部类
//    Function<Integer,String[]>  fun = new Function<Integer,String[]>(){
//      @Override
//      public String[] apply(Integer t) {
//        return new String[t];
//      }
//    };
    //数组引用
    Function<Integer,String[]>  fun2 = String[]::new;
    String[] arr = fun2.apply(5);
    for (String string : arr) {
      System.out.println(string);
    }
  }
  //案例2：返回一个Employee[]
  @Test 
  public void test2() {
    Function<Integer,Employee[]> fun = Employee[]::new;
    Employee[] apply = fun.apply(3);
    for (Employee employee : apply) {
      System.out.println(employee);
    }
  }
}

1、Stream讲究的是“计算”，可以处理数据，但不能更新源数据
2、Stream 属于“惰性操作”，必须等待终止操作执行后，前面的中间操作或开始操作才会处理
3、Stream只能消费一次，一旦消费，就不能再次使用，除非重新创建Stream对象
4、Stream的中间操作可以有0个或多个，每个操作都会返回一个新的Stream
5、Stream相当于一个 更强大的Iterator，可以处理更加复杂的数据，并且实现并行化，效率更高！