
private String value = "Outer scope value";
 
public String scopeExperiment() {
    Usage usage = new Usage() {
        String value = "Inner class value";
 
        @Override
        public String method(String string) {
            return this.value;
        }
    };
    String result = usage.method("");
 
    Usage usageLambda = parameter -> {
        String value = "Lambda value";
        return this.value;
    };
    String resultLambda = usageLambda.method("");
 
    return "Results: result = " + result + 
      ", resultLambda = " + resultLambda;
}

上面的例子将会输出“Results: result = Inner class value, resultLambda = Outer scope value”

2.Lambda表达式对接口的要求

并不是所有的接口都可以使用lambda表达式来简洁实现的。lambda表达式毕竟只是一个匿名方法。当实现的接口中的方法过多或者过少的时候，lambda表达式都是不适用的。

lambda表达式只能实现函数式接口。即一个接口中，要求实现类必须实现的抽象方法，有且只有一个，这样的接口就是函数式接口。JDK的函数式接口都加上了@FunctionalInterface 注解进行标识。但是无论是否加上该注解，只要接口中只有一个抽象方法，都是函数式接口。

函数式接口的使用：一般可以作为方法的参数和返回值类型

3.Lambda表达式的语法

(参数)->{方法体}

参数部分︰方法的参数列表，要求和实现的接口中的方法参数部分一致，包括参数的数量和类型。
方法体部分∶方法的实现部分，如果接口中定义的方法有返回值，则在实现的时候，注意返回值的返回。
->:分隔参数部分和方法体部分。

因为接口中规定了方法参数类型，所以实际写lambda表达式的时候可以省略参数类型。如果只有一个参数，可以省略()
另外如果方法体里只有一个语句，那么可以省略掉 {}，如果该语句是return语句，需要把return也省略掉

省略如下：

4.函数引用

lambda表达式是为了简化接口的实现的。在lambda表达式中，不应该出现比较复杂的逻辑。如果在lambda表达式中出现了过于复杂的逻辑，会对程序的可读性造成非常大的影响。

如果在lambda表达式中需要处理的逻辑比较复杂，一般情况会单独的写一个方法。在lambda表达式中直接引用这个方法即可。或者，在有些情况下，我们需要在lambda表达式中实现的逻辑，在另外一个地方已经写好了。此时我们就不需要再单独写一遍，只需要直接引用这个已经存在的方法即可。

函数引用:引用一个已经存在的方法，使其替代lambda表达式完成接口的实现。

4.1引用一个静态方法

接口依然是上面的MultipleParametersReturn，引用如下

需要注意的是引用的 方法的参数 和 返回值类型 要与接口对应

4.2引用一个非静态方法

4.3引用构造方法

Person类


public class Person {
    private Integer age;
    private String name;
 
    public Person() {
    }
 
    public Person(Integer age) {
        this.age = age;
    }
 
    public Person(Integer age, String name) {
        this.age = age;
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

PersonWithNoParam接口


@FunctionalInterface
public interface PersonWithNoParam {
    Person getPersonWithNoParam();
}

PersonWithOneParam接口


@FunctionalInterface
public interface PersonWithOneParam {
    Person getPersonWithOneParam(Integer age);
}

PersonWithDoubleParams接口


@FunctionalInterface
public interface PersonWithDoubleParams {
    Person getPersonWithDoubleParams(Integer age,String name);
}

Demo


public class Demo1 {
    public static void main(String[] args) {
        //lambda表达式实现PersonWithNoParam接口
        PersonWithNoParam t1=Person::new;//无参构造函数引用
        System.out.println(t1.getPersonWithNoParam());
 
        //lambda表达式实现PersonWithOneParam接口
        PersonWithOneParam t2=Person::new;//单参构造函数引用
        System.out.println(t2.getPersonWithOneParam(10));
 
        //lambda表达式实现PersonWithDoubleParams接口
        PersonWithDoubleParams t3=Person::new;//多参构造函数引用
        System.out.println(t3.getPersonWithDoubleParams(10,"小王"));
 
    }
 
}

lambda表达式会自动根据方法的参数类型匹配Person类中对应的构造方法

5.特殊的函数引用

如果在使用lambda表达式实现某些接口的时候，lambda表达式的参数列表中包含了某一个对象，此时方法体中，直接使用这个对象调用它的某一个方法就可以完成整体的逻辑，并且其他的参数可以作为调用方法的参数。此时，可以对这种实现进行简化。

Person类


public class Person {
    private Integer age;
    private String name;
 
    public Person() {
    }
 
    public Person(Integer age) {
        this.age = age;
    }
 
    public Person(Integer age, String name) {
        this.age = age;
        this.name = name;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

PersonSpecial接口


public interface PersonSpecial {
    void setAge (Person person,Integer age);
}

Demo2


public class Demo2 {
    public static void main(String[] args) {
        //简化前
        PersonSpecial t=(person,age)->person.setAge(age);
        //用对象的特殊引用简化后
        PersonSpecial t2=Person::setAge;
        Person person = new Person();
        t2.setAge(person,13);
        System.out.println(person);
    }
}

6.闭包

如果某一个外部局部变量被用在了某一个代码块中，这其实就形成了对这个局部变量的包围，我们称"闭包"。这个时候这个变量可以读取，但不允许被改变，即final（逻辑上要求，并不强制要求final修饰）

函数可以访问函数外部的局部变量，并且与它建立联系，可以修改变量和读取到外部对局部变量的修改。首先lambda表达式可以使用表达式外的变量，但要求使用的变量是final的（逻辑上要求，并不强制要求final修饰）
内部类也是，要求使用的外部的局部变量是final的（逻辑上要求，并不强制要求final修饰）

如下编译器会报错：

那有什么好的解决办法呢？既能让编译器不发出警告，又能修改变量的值。如下：

把 a 变量声明为 全局变量
把 a 变量声明为 AtomicInteger。AtomicInteger 可以确保 int 值的修改是原子性的，可以使用 set() 方法设置一个新的 int 值，get() 方法获取当前的 int 值。
使用数组

三.Stream流

Java8的使用的是函数式编程模式，可以被用来对集合或数组进行链状流式的操作。有别于IO流，这里是针对集合操作数据的流

创建流

单列集合： 集合对象.stream()


List<String>s=new ArrayList<>();
Stream<String> stream = s.stream();

数组：`Arrays.stream(数组) `或者使用`Stream.of`来创建


Integer[] arr={1,2,3,4,5};
//创建流 法一
Stream<Integer>stream=Arrays.stream(arr);


//创建流 法二
Stream<Integer>stream=Stream.of(arr);

双列集合：转换成单列集合后再创建


Map<String,Integer> map = new HashMap<>();
map.put("蜡笔小新",19);
map.put("黑子",17);
map.put("日向翔阳",16);
Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();

Map的entrySet() 方法返回一个实现Map.Entry接口的对象集合。集合中每个对象都是底层Map中一个特定的键/值对。一般情况下，要输出Map中的key 和 value 是先得到key的集合keySet()，然后再迭代（循环）由每个key得到每个value。values()方法是获取集合中的所有值，不包含键，没有对应关系。而Entry可以一次性获得这两个值。Map.Entry中的常用方法如下所示：

Object getKey(): 返回条目的关键字
Object getValue(): 返回条目的值
Object setValue(Object value): 将相关映像中的值改为value，并且返回旧值

中间操作

filter

可以对流中的元素进行条件过滤，符合过滤条件的才能继续留在流中。

例如：留下所有字符串长度大于2的

我们可以先用匿名内部类的方式实现看看


List<String>strings=new ArrayList<>();
strings.add("abcde");
strings.add("ac");
strings.stream().filter(new Predicate<String>() {
    @Override
    public boolean test(String s) {
         return s.length()>2;
    }
})

Predicate 接口的泛型参数和集合元素类型是一样的，并且所实现的方法参数也是一样的

集合会把每个元素传给test方法，如果test方法返回true，该元素就会被保留，返回false则过滤掉

现在我们可以试着用lambda表达式简化一下

strings.stream().filter(s-> s.length()>2)

注：因为这里还没有加上流的终结操作，所以实际上是不会生效的(下同)，终结操作后面会讲到

map

可以把对流中的元素进行计算或转换。

Author类


@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode//用于后期的去重使用
public class Author {
    //id
    private Long id;
    //姓名
    private String name;
    //年龄
    private Integer age;
    //简介
    private String intro;
    //作品
    private List<Book> books;
}

Book类


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
 
@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode//用于后期的去重使用
public class Book {
    //id
    private Long id;
    //书名
    private String name;
    //分类
    private String category;
    //评分
    private Integer score;
    //简介
    private String intro;
}

数据初始化


private static List<Author> getAuthors() {
        //数据初始化
        Author author = new Author(1L,"蒙多",33,"一个从菜刀中明悟哲理的祖安人",null);
        Author author2 = new Author(2L,"亚拉索",15,"狂风也追逐不上他的思考速度",null);
        Author author3 = new Author(3L,"易",14,"是这个世界在限制他的思维",null);
        Author author4 = new Author(3L,"易",14,"是这个世界在限制他的思维",null);
 
        //书籍列表
        List<Book> books1 = new ArrayList<>();
        List<Book> books2 = new ArrayList<>();
        List<Book> books3 = new ArrayList<>();
 
        books1.add(new Book(1L,"刀的两侧是光明与黑暗","哲学,爱情",88,"用一把刀划分了爱恨"));
        books1.add(new Book(2L,"一个人不能死在同一把刀下","个人成长,爱情",99,"讲述如何从失败中明悟真理"));
 
        books2.add(new Book(3L,"那风吹不到的地方","哲学",85,"带你用思维去领略世界的尽头"));
        books2.add(new Book(3L,"那风吹不到的地方","哲学",85,"带你用思维去领略世界的尽头"));
        books2.add(new Book(4L,"吹或不吹","爱情,个人传记",56,"一个哲学家的恋爱观注定很难把他所在的时代理解"));
 
        books3.add(new Book(5L,"你的剑就是我的剑","爱情",56,"无法想象一个武者能对他的伴侣这么的宽容"));
        books3.add(new Book(6L,"风与剑","个人传记",100,"两个哲学家灵魂和肉体的碰撞会激起怎么样的火花呢？"));
        books3.add(new Book(6L,"风与剑","个人传记",100,"两个哲学家灵魂和肉体的碰撞会激起怎么样的火花呢？"));
 
        author.setBooks(books1);
        author2.setBooks(books2);
        author3.setBooks(books3);
        author4.setBooks(books3);
 
        List<Author> authorList = new ArrayList<>(Arrays.asList(author,author2,author3,author4));
        return authorList;
    }

例如：只取所有作家的姓名

我们可以先用匿名内部类的方式实现看看


//打印所有作家的姓名
List<Author> authors = getAuthors();
authors.stream().map(new Function<Author, String>() {
     @Override
     public String apply(Author author) {
          return author.getName();
     }
})

Function里第一个泛型参数和集合元素类型是一样的，第二个是要转换成的目标类型。上面一段代码将Author集合转成了只包含Name的String集合。

lambda表达式简化如下：


//打印所有作家的姓名
List<Author> authors = getAuthors();
authors.stream().map(author -> author.getName())

distinct

可以去除流中的重复元素。

例如：对作家进行去重。


   List<Author> authors = getAuthors();
   authors.stream().distinct()

注意：distinct方法是依赖Object的equals方法来判断是否是相同对象的。所以需要注意重写equals方法。

sorted

可以对流中的元素进行排序。

例如：对流中的元素按照年龄进行升序排序，并且要求不能有重复的元素。

当我们在调用sorted时会发现它有两种传参形式：

如果调用空参的sorted()方法，需要流中的元素是实现了Comparable接口，否则会抛出java.lang.ClassCastException异常。

所以这里我们先让Author实现 Comparable 接口


@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode//用于后期的去重使用
public class Author implements Comparable<Author> {
    //id
    private Long id;
    //姓名
    private String name;
    //年龄
    private Integer age;
    //简介
    private String intro;
    //作品
    private List<Book>books;
    @Override
    public int compareTo(Author o) {
        return this.getAge()-o.getAge();
    }
}

接下来就可以排序了


        List<Author> authors = getAuthors();
//        对流中的元素按照年龄进行升序排序，并且要求不能有重复的元素。
        authors.stream()
                .distinct()
                .sorted()

当然我们也可以传入对 Comparator 接口的实现，可以用lambda表达式简化


    List<Author> authors = getAuthors();
//        对流中的元素按照年龄进行升序排序，并且要求不能有重复的元素。
         authors.stream()
                .distinct()
                .sorted(new Comparator<Author>() {
                    @Override
                    public int compare(Author o1, Author o2) {
                        return o1.getAge()-o2.getAge();
                    }
                })

limit

可以设置流的最大长度，超出的部分将被抛弃。

例如：对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素,只保留其中年龄最大的两个作家


  List<Author> authors = getAuthors();
         authors.stream()
                .distinct()
                .sorted((o1, o2) -> o2.getAge()-o1.getAge())
                .limit(2)

skip

跳过流中的前n个元素，返回剩下的元素

例如：打印除了年龄最大的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。


//        打印除了年龄最大的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。
        List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted((o1, o2) -> o2.getAge()-o1.getAge())
                .skip(1)

flatMap

map只能把一个对象转换成另一个对象来作为流中的元素。而flatMap可以把一个对象转换成多个对象作为流中的元素。

map和flatMap区别在哪里，我们具体来看一个例子

例：保留所有书籍的名字。要求对重复的元素进行去重。

使用 map 转换后流里面的元素实际上是List<Book>集合而非Book(可以用后面的forEach终端操作打印试试)


List<Author> authors = getAuthors();
authors.stream().map(author->author.getBooks()).distinct()

想要将流里的元素变成Book对象，可以使用flatMap


//打印所有书籍的名字。要求对重复的元素进行去重。
List<Author> authors = getAuthors();
authors.stream()
       .flatMap(author -> author.getBooks().stream())
       .distinct()
       .forEach(book -> System.out.println(book.getName()));

注：所有的中间操作返回的都是一个Stream对象，所以可以一直链式编程

终结操作

forEach

对流中的元素进行遍历操作，我们通过传入的参数去指定对遍历到的元素进行什么具体操作。

例子：输出所有作家的名字


//        输出所有作家的名字
        List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getName())
                .distinct()
                .forEach(name-> System.out.println(name));

count

可以用来获取当前流中元素的个数。

例子：打印这些作家的所出书籍的数目，注意删除重复元素。


//        打印这些作家的所出书籍的数目，注意删除重复元素。
        List<Author> authors = getAuthors();
 
        long count = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .count();
        System.out.println(count);

max&min

可以用来获取流中的最值，返回Optional(后面会讲到)

例子：分别获取这些作家的所出书籍的最高分和最低分并打印。


 //        分别获取这些作家的所出书籍的最高分和最低分并打印。
        //Stream<Author>  -> Stream<Book> ->Stream<Integer>  ->求值
        List<Author> authors = getAuthors();
        Optional<Integer> max = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .map(book -> book.getScore())
                .max(new Comparator<Integer>() {//比较规则
                    @Override
                    public int compare(Integer o1, Integer o2) {
                        return o1-o2;
                    }
                });
        System.out.println(max.get());

collect

把当前流转换成一个集合。

例子：获取一个存放所有作者名字的List集合。


//        获取一个存放所有作者名字的List集合。
        List<Author> authors = getAuthors();
        List<String> nameList = authors.stream()
                .map(author -> author.getName())
                .collect(Collectors.toList());
        System.out.println(nameList);

例子：获取一个所有书名的Set集合。


//        获取一个所有书名的Set集合。
        List<Author> authors = getAuthors();
        Set<Book> books = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .collect(Collectors.toSet());
 
        System.out.println(books);

例子：获取一个Map集合，map的key为作者名，value为List<Book>


//        获取一个Map集合，map的key为作者名，value为List<Book>
        List<Author> authors = getAuthors();
 
        Map<String, List<Book>> map = authors.stream()
                .distinct()
                .collect(Collectors.toMap(author -> author.getName(), author -> author.getBooks()));
 
        System.out.println(map);

查找与匹配

anyMatch

可以用来判断是否有任意符合匹配条件的元素，结果为boolean类型。

例子：判断是否有年龄在29以上的作家


//        判断是否有年龄在29以上的作家
        List<Author> authors = getAuthors();
        boolean flag = authors.stream()
                .anyMatch(author -> author.getAge() > 29);
        System.out.println(flag);

allMatch

可以用来判断是否都符合匹配条件，结果为boolean类型。如果都符合结果为true，否则结果为false。

例子：判断是否所有的作家都是成年人


//        判断是否所有的作家都是成年人
        List<Author> authors = getAuthors();
        boolean flag = authors.stream()
                .allMatch(author -> author.getAge() >= 18);
        System.out.println(flag);

noneMatch

可以判断流中的元素是否都不符合匹配条件。如果都不符合结果为true，否则结果为false

例子：判断作家是否都没有超过100岁的。


//        判断作家是否都没有超过100岁的。
        List<Author> authors = getAuthors();
 
        boolean b = authors.stream()
                .noneMatch(author -> author.getAge() > 100);
 
        System.out.println(b);

findAny

获取流中的任意一个元素。该方法没有办法保证获取的一定是流中的第一个元素。用的较少

例子：获取任意一个年龄大于18的作家，如果存在就输出他的名字


//        获取任意一个年龄大于18的作家，如果存在就输出他的名字
        List<Author> authors = getAuthors();
        Optional<Author> optionalAuthor = authors.stream()
                .filter(author -> author.getAge()>18)
                .findAny();
        //如果存在
        optionalAuthor.ifPresent(author -> System.out.println(author.getName()));

findFirst

获取流中的第一个元素。

例子：获取一个年龄最小的作家，并输出他的姓名。


//        获取一个年龄最小的作家，并输出他的姓名。
        List<Author> authors = getAuthors();
        Optional<Author> first = authors.stream()
                .sorted((o1, o2) -> o1.getAge() - o2.getAge())
                .findFirst();
        //如果存在
        first.ifPresent(author -> System.out.println(author.getName()));

reduce归并

对流中的数据按照你指定的计算方式计算出一个结果。（缩减操作）

reduce的作用是把stream中的元素给组合起来，我们可以传入一个初始值，它会按照我们的计算方式依次拿流中的元素和初始化值进行计算，计算结果再和后面的元素计算。

reduce有好几种重载形式，两个参数的重载形式

内部的计算方式如下：


T result = identity;
for (T element : this stream)
	result = accumulator.apply(result, element)
return result;

其中 identity 就是我们可以通过方法参数传入的初始值，accumulator的apply具体进行什么计算也是我们通过方法参数来确定的。

我们来看一个例子：使用reduce求所有作者年龄的和


  //        使用reduce求所有作者年龄的和
        List<Author> authors = getAuthors();
        Integer sum = authors.stream()
                .distinct()
                .map(author -> author.getAge())
                .reduce(0, new BinaryOperator<Integer>() {
                    @Override
                    public Integer apply(Integer result, Integer element) {
                        return result+element;
                    }
                });//.reduce(0, (result, element) -> result + element);
        System.out.println(sum);

一个参数的重载形式

内部的计算方式如下：


 boolean foundAny = false;
     T result = null;
     for (T element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.apply(result, element);
     }
     return foundAny ? Optional.of(result) : Optional.empty();

实际上就是把第一个元素作为初始化值，再拿和这个变量进行相应的计算

如果用一个参数的重载方法去求最小值代码如下：


        //        使用reduce求所有作者中年龄的最小值
        List<Author> authors = getAuthors();
        Optional<Integer> minOptional = authors.stream()
                .map(author -> author.getAge())
                .reduce((result, element) -> result > element ? element : result);
        minOptional.ifPresent(age-> System.out.println(age));

注意事项

惰性求值（如果没有终结操作，没有中间操作是不会得到执行的）
流是一次性的（一旦一个流对象经过一个终结操作后。这个流就不能再被使用）
不会影响原数据（我们在流中可以多数据做很多处理。但是正常情况下是不会影响原来集合中的元素的。这往往也是我们期望的）

四.Optional

1.引入

我们在编写代码的时候出现最多的就是空指针异常。所以在很多情况下我们需要做各种非空的判断。例如：


Author author = getAuthor();
if(author!=null){
     System.out.println(author.getName());
}

尤其是对象中的属性还是一个对象的情况下，这种判断会更多。而过多的判断语句会让我们的代码显得臃肿不堪。

所以在JDK8中引入了Optional,养成使用Optional的习惯后你可以写出更优雅的代码来避免空指针异常，并且在很多函数式编程相关的API中也都用到了Optional。

2.使用

2.1创建对象

Optional就好像是包装类，可以把我们的具体数据封装Optional对象内部。然后我们去使用Optional中封装好的方法操作封装进去的数据就可以非常优雅的避免空指针异常。

我们一般使用Optional的静态方法ofNullable来把数据封装成一个Optional对象。无论传入的参数是否为null都不会出现问题。


Author author = getAuthor();
Optional<Author> authorOptional = Optional.ofNullable(author);

2.2安全消费值

我们获取到一个Optional对象后肯定需要对其中的数据进行使用。这时候我们可以使用其ifPresent方法对来消费其中的值。

这个方法会判断其内封装的数据是否为空，不为空时才会执行具体的消费代码。这样使用起来就更加安全了。

例如,以下写法就优雅的避免了空指针异常：


Optional<Author> authorOptional = Optional.ofNullable(getAuthor());
 
authorOptional.ifPresent(author -> System.out.println(author.getName()));

2.3安全获取值

不推荐使用get，因为当Optional内部的数据为空的时候会出现异常。而是使用Optional提供的以下方法。

orElseGet：获取数据并且设置数据为空时的默认值。如果数据不为空就能获取到该数据。如果为空则根据你传入的参数来创建对象作为默认值返回。


Optional<Author> authorOptional = Optional.ofNullable(getAuthor());
Author author1 = authorOptional.orElseGet(() -> new Author(3L,"易",14,"是这个世界在限制他的思维",null));//默认值

orElseThrow：获取数据，如果数据不为空就能获取到该数据。如果为空则根据你传入的参数来创建异常抛出。


        Optional<Author> authorOptional = Optional.ofNullable(getAuthor());
        try {
            Author author = authorOptional.orElseThrow((Supplier<Throwable>) () -> new RuntimeException("author为空"));
            System.out.println(author.getName());
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

这里的异常处理在spring框架中可以统一处理

2.4过滤

我们可以使用filter方法对数据进行过滤。如果原本是有数据的，但是不符合判断，也会变成一个无数据的Optional对象。


Optional<Author> authorOptional = Optional.ofNullable(getAuthor());
   if (authorOptional.isPresent()) {
        System.out.println(authorOptional.get().getName());
   }

2.5数据转换

Optional还提供了map可以让我们的对数据进行转换，并且转换得到的数据也还是被Optional包装好的，保证了我们的使用安全。

例如我们想获取作家的书籍集合：


        Optional<Author> authorOptional = getAuthorOptional();
        Optional<List<Book>> optionalBooks = authorOptional.map(author -> author.getBooks());
        optionalBooks.ifPresent(books -> System.out.println(books));

四.Stream高级用法

1.基本数据类型优化

我们之前用到的很多Stream的方法都使用了泛型，所以涉及到的参数和返回值都是引用数据类型。JDK5中引入的自动装箱和自动拆箱让我们在使用对应的包装类时就好像使用基本数据类型一样方便。但是如果在大量数据下可能需要不断的重复装箱、拆箱，这个时间损耗就不能忽略了。

为了让我们能够对这部分的时间消耗进行优化。Stream还提供了很多专门针对基本数据类型的方法。例如：mapToInt,mapToLong,mapToDouble,flatMapToInt,flatMapToDouble等。

优化前：


 List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getAge())
                .map(new Function<Integer, Integer>() {
 
                    @Override
                    public Integer apply(Integer age) {
                        return age+10;
                    }
                })
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer age) {
                        return age>18;
                    }
                })
                .map(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(Integer age) {
                        return age+2;
                    }
                })
                .forEach(System.out::println);

优化后


        List<Author> authors = getAuthors();
        authors.stream()
                .mapToInt(author -> author.getAge())
                .map(age -> age + 10)
                .filter(age->age>18)
                .map(age->age+2)
                .forEach(System.out::println);

2.并行流

当流中有大量元素时，我们可以使用并行流去提高操作的效率。其实并行流就是把任务分配给多个线程去完成。如果我们自己去用代码实现的话其实会非常的复杂，并且要求对并发编程有足够的理解和认识。而如果我们使用Stream的话，我们只需要修改一个方法的调用就可以使用并行流来帮我们实现，从而提高效率。

parallel方法可以把串行流转换成并行流

补充：peek()方法有助于调试


Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = stream.parallel()//并行流
                .peek(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer num) {
                        System.out.println(num+Thread.currentThread().getName());
                    }
                })
                .filter(num -> num > 5)
                .reduce((result, ele) -> result + ele)//求和
                .get();
        System.out.println(sum);

运行后：

去掉parallel()后就是单线程串行流，运行如下：

parallelStream直接获取并行流对象


 List<Author> authors = getAuthors();
        authors.parallelStream()
                .map(author -> author.getAge())
                .map(age -> age + 10)
                .filter(age->age>18)
                .map(age->age+2)
                .forEach(System.out::println);

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/289782