Java8新特性-Stream API

本文主要是介绍Java8新特性-Stream API，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

import org.junit.Test;

public class TestMethods {
  @Test
  public void test() {
  System.out.println("hello world");
    }
}


1：首先需要导入import org.junit.test这个jar包，@Test注解要写在你要测试的方法上面

2：然后点击--运行方式,再点击Junit测试，就可以了。


test()方法里面写你需要测试的方法就可以了
---TestMethods这个类不用new，就可以运行。是因为它是通过org.junit.Test中的API中的类反射生成的，然后调用用@Test注解的方法，有几个@Test注解，就运行几个test方法。

一 Lambda表达式：
/**
 *  一。Lambda 表达式的基础语法大： Java8中引入了一个新的操作符 “->” 该操作符称为箭头操作符或Lambda操作符
 *                              箭头操作符将Lambda 表达式拆分成两部分：
 *
 *  左侧： Lambda 表达式的参数列表
 *  右侧： Lambda 表达式中所需执行的功能， 即Lambda 体
 *
 *  语法格式二： 有一个参数，并且无返回值
 *          (x) -> System.out.println(x);
 *
 *  语法格式三： 若只有一个参数，小括号可以省略不写
 *          x -> System.out.println(x)
 *
 *  语法格式四： 有连个以上的参数，有返回值，并且 Lambda 体中有多条语句
 *         Comparator<Integer> comm = (x,y) -> {
 *             System.out.println("函数式接口");
 *             return Integer.compare(x,y);
 *         };
 *
 *  语法格式五： 若 Lambda 体中只有一条语句， return 和大括号都可以省略不写
 *         Comparator<Integer> com = (x,y) ->Integer.compare(x,y);
 *
 *  语法格式六： Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
 *          "类型推断" 写起来方便了，但还是要过类型的检查
 *         Comparator<Integer> com = (Integer x,Integer y) -> Integer.compare(x,y);
 *
 *  左侧遇一括号省
 *  左侧推断类型省
 *
 * 二： Lambda 表达式需要“函数式接口” 的支持
 *    函数式接口：接口中只有一个抽象的接口， 称为函数时接口，可以使用注解 @FunctionalInterface 修饰
 *              可以检查是否是函数式接口
 * 三:Java8 内置的四大核心函数式接口：
 *
 * Consumer<T> : 消费型接口
 *          void accept(T t);
 *
 * Supplier<T> : 供给型接口
 *          T get();
 *
 * Function<T, R> : 函数式接口
 *          R apply(T t);
 *
 * Predicate<T> : 断言型接口
 *          boolean test(T t);
 *

/**
 * 方法引用： 若 Lambda 体中内容有方法已经实现了，我们可以使用“方法引用”
 *          （可以理解为方法引用是Lambda 表达式的另外一种表现形式）
 *
 *  主要有三种语法格式：
 *
 *  对象::实例方法名
 *
 *  类::静态方法名
 *
 *  类::实例方法名
 *
 *  注意：
 *      ①Lambda 体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！！！
 *      ②若 Lambda 参数列表中的第一参数就是 实例方法的调用者，而第二个参数是实例方法的参数时，可以使用ClassName :: Method
 *
 *  二：构造器引用：
 *      格式：
 *
 *      ClassName::new
 *
 *      注意： 需要调用的构造器的参数列表与函数式接口中抽象方法的参数列表保持一致！
 *
 *  三： 数组引用：
 *
 *    Type[]::new;
 */

package java8.exer;

import java8.Employee;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * 一. Stream 的三个操作步骤：
 *
 * 1. 创建 Stream
 *
 * 2. 中间操作
 *
 * 3。 终止操作（终端操作）
 */
public class TestStreamAPI1 {

    //创建 Stream
    @Test
    public void test1() {
        //1.可以通过 Collection 系列集合提供的stream() 或 parallelStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        //2 通过Arrays 中得到静态方法 stream() 获取数组流
        Employee[] emps  = new Employee[10];
        Stream<Employee> stream2 = Arrays.stream(emps);

        //3. 通过 Stream 类中的静态方法 of()
        Stream<String> stream3 = Stream.of("abc","def","xyz");


        //4.创建无限流
        //迭代 seed是种子
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
        stream4.limit(10).forEach(System.out::println);

        //生成
        Stream.generate(() -> Math.random())
                .limit(5).forEach(System.out::println);
    }
}
```java
package java8.exer;

import java8.Employee;
import org.junit.Test;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

/**
 * 一. Stream 的三个操作步骤：
 *
 * 1. 创建 Stream
 *
 * 2. 中间操作
 *
 * 3。 终止操作（终端操作）
 */
public class TestStreamAPI2 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 38, 5555.99),
            new Employee("王五", 50, 6666.66),
            new Employee("赵六", 16, 3333.33),
            new Employee("田七", 8, 8888.77),
            new Employee("田七", 8, 8888.77),
            new Employee("田七", 8, 8888.77),
            new Employee("田七", 8, 8888.77)
    );
    //中间操作
    /*
           筛片与切片
           filter--接收 Lambda ,从流中排除某些元素。
           limit--截断流，使其元素不超过给定数量。
           skip(n) -- 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足n个，则返回一个空流。与limit(n) 互补
           distinct--筛选，通过流所生成元素的hashCode() 和 equals() 去除重复元素
     */

    @Test
    public void test4(){
        employees.stream()
                .filter((e) -> e.getSalary() > 5000)
                .skip(2)
                .distinct()
                .forEach(System.out::println);

    }

    @Test
    public void test3() {
        employees.stream()
                .filter((e) -> {
                    System.out.println("短路");
                    return e.getSalary() > 5000; // && ||
                })
                .limit(2)
                .forEach(System.out::println);
        /*
        短路
        Employee{name='张三', age=18, salary=9999.99}
        短路
        Employee{name='李四', age=38, salary=5555.99}
         */
    }


    //内部迭代： 迭代操作由Stream API 完成
    @Test
    public void test1() {
        //中间操作： 不会执行任何操作
        Stream<Employee> stream = employees.stream()
                .filter((e) -> {
                    /*
                    多个中间操作可以链接起来信春哥很难过一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！
                    而在终止操作时一次性全部处理，称为”惰性求值“。
                     */
                    System.out.println("Stream API 的中间操作");
                    return e.getAge() > 35;
                });
        //终止操作：一次性执行全部内容，即”惰性求值“
        stream.forEach(System.out::println);
    }

    //外部迭代
    @Test
    public void test2(){
        Iterator<Employee> it = employees.iterator();

        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

这篇关于Java8新特性-Stream API的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！