Java8新特性详解-优快云博客

java8新特性

lambda表达式

      语法：(parameters) -> expression 例： 接受2个参数(数字),并返回他们的差值  (x, y) -> x – y  
      用法： 定义一个接口，接口里面定义一个方法，在用这个接口名声明一个对象，对象存表达式，
                     最后用   对象.方法（带实参）
      变量作用域： lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
                                     lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改。
                                    在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

方法引用：

1.构造器引用：

语法是 Class::new，或者更一般的Class< T >::new
例：
    //传统Lambda方式
    Supplier<Student> studentSupplier = ()-> new Student();
  
                                                                   Student student = studentSupplier.get();
    System.out.println(student);//Student{name='null', age=0}


               //构造器引用
    	 studentSupplier = Student::new;
   
			 student = studentSupplier.get();
    System.out.println(student);//Student{name='null', age=0}

2.静态方法引用：

语法是 Class::静态方法名，
例： //传统Lambda表达式
Consumer consumer = (str) -> sop(str);
consumer.accept(“Hello : XiangYang”); //打印：Hello : XiangYang

        //方法引用方式
    consumer = Test::sop;
    consumer.accept("Hello : XiangYang"); //打印：Hello : XiangYang

3.特定类的任意对象的方法引用：

语法是类名::method
例：Student student = new Student(“XiangYang”,23);

       Supplier<String> supplier = ()->student.getName();

System.out.println("Lambda形式： "+supplier.get());

       Supplier<String> supplier1 = student :: getName;
    System.out.println("方法引用形式： "+supplier1.get());

4.特定对象的方法引用：

语法是实例::method
例：final Car police = Car.create( Car::new );
cars.forEach( police::follow );

函数式接口：

1.Predicate <T>  它接受一个输入参数 T以及类型，返回一个布尔值结果。
例：链接：https://www.runoob.com/java/java8-functional-interfaces.html
2.accept(T t)        它接受一个输入参数 T以及类型，没有返回值。
                  例：  Consumer<String> consumer = (x) -> System.out.println(x);
                             consumer.accept("Hi: 我是Lambda表达式实现的！"); //打印：Hi: 我是Lambda表达式实现的！
3.Function<T,R> 接受一个输入参数，返回一个结果。
4.Consumer<T>  代表了接受一个输入参数并且无返回的操作。

Stream流

      Stream 提供了新的方法 'forEach' 来迭代流中的每个数据
                    例： random.ints().limit(10).forEach(System.out::println)
      map 方法用于映射每个元素到对应的结果
                       用法：   涉及到取或者用集合中的元素，用.map(类型：：getValues())
                    例： List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
                              List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());//输出i的平方的集合
                             对字符串操作：
                              memberNames.stream().filter((s) -> s.startsWith("A")).map(String toUpperCase) .forEach(System.out::println);   //输出包含A的单词    
                              对键值对操作：
                               stream.map((value) -> value.toUpperCase());      
      filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：
                    例：long count = strings.stream().filter(string -> string.isEmpty()).count();
      limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据：
                    例：random.ints().limit(10).forEach(System.out::println);
      sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：
                     例：random.ints().limit(10).sorted().forEach(System.out::println);
     count()返回符合条件的数量
                     例：long totalMatched = memberNames.stream() .filter((s) -> s.startsWith("A")) .count();
                                  System.out.println(totalMatched);
                                  Output: //输出有2个包含A的单词
     forEach()：遍历流。
     distinct():去掉重复的数据
     min()/max():找到最小/大元素
                       例：Optional<Integer> minNumber = list.stream().min((i, j) -> i.compareTo(j));
                                System.out.println(minNumber.get());//输出最小的元素
     builder模式：（链式调用）下面的属性可随意增减
                                new 类名.Builder(context)
	.setName("kimber.wang")
	.setTiltle("问题")
	.setMessage("请问你多大了")
	.build()

第一步创建流：

     1.Stream.of(val1, val2, val3….)
    例：Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9);
             stream.forEach(p -> System.out.println(p));
     2.Stream.of(arrayOfElements)
    例：Stream<Integer> stream = Stream.of( new Integer[]{1,2,3,4,5,6,7,8,9} );
             stream.forEach(p -> System.out.println(p));
      3.List.stream()
    例：  List<Integer> list = new ArrayList<Integer>();
                for(int i = 1; i< 10; i++){
                list.add(i);
              }
            stream<Integer> stream = list.stream();
            stream.forEach(p -> System.out.println(p));

第二步把流转换成list(collectors.toList())

             创建一个list集合，同上
             stream<Integer> stream = list.stream();
             List<Integer> evenNumbersList = stream.filter(i -> i%2 == 0).collect(Collectors.toList());
              转换成array ( Stream.toArray( EntryType[]::new ))
            （Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);）
              System.out.print(evenNumbersList);