Java1.8之Lambda表达式、流Stream学习

1、什么是函数式编程?

答：每个人对函数式编程的理解不尽相同。但其核心是：在思考问题时，使用不可变值和函数，函数对一个值进行处理，映射成另一个值。

2、Java 8的最大变化是引入了Lambda表达式——一种紧凑的、传递行为的方式。

答：和使用匿名内部类的另一处不同在于声明参数的方式。使用匿名内部类时需要显式地声明参数类型，而在Lambda表达式中无需指定类型，程序依然可以编译。这是因为javac根据程序的上下文在后台推断出了参数的类型。这意味着如果参数类型不言而明，则无需显式指定。

　　尽管与之前相比，Lambda表达式中的参数需要的样板代码很少，但是Java 8仍然是一种静态类型语言。为了增加可读性并迁就我们的习惯，声明参数时也可以包括类型信息，而且有时编译器不一定能根据上下文推断出参数的类型！

　　注意：->符号将参数和Lambda表达式的主体分开。

3、Java8之Lambda的简单案例使用，如下所示：

package com.demo.main;

import java.awt.event.ActionListener;
import java.util.function.BinaryOperator;

public class LambdaMain {

    // 目标类型是指Lambda表达式所在上下文环境的类型。
    // 比如，将Lambda表达式赋值给一个局部变量，或传递给一个方法作为参数，局部变量或方法参数的类型就是Lambda表达式的目标类型。
    public static void main(String[] args) {
        // Lambda表达式的不同形式
        // 1、方式一，Lambda表达式不包含参数，使用空括号()表示没有参数。
        // 该Lambda表达式实现了Runnable接口，该接口也只有一个run方法，没有参数，且返回类型为void。
        Runnable noArguments = () -> System.out.println("方式一,hello Lambda!!!");
        noArguments.run();

        // 2、方式二,Lambda表达式包含且只包含一个参数，可省略参数的括号
        ActionListener oneArgument = event -> System.out.println("方式二,button clicked !!!");

        // 3、方式三,Lambda表达式的主体不仅可以是一个表达式，而且也可以是一段代码块，使用大括号（{}）将代码块括起来
        Runnable multiStatement = () -> {
            System.out.println("方式三,hello Lambda first !!!");
            System.out.println("方式三,hello Lambda second!!!");
        };
        multiStatement.run();

        // 4、方式四,Lambda表达式也可以表示包含多个参数的方法。
        // 这行代码并不是将两个数字相加，而是创建了一个函数，用来计算两个数字相加的结果。
        // 变量add的类型是BinaryOperator<Long>，它不是两个数字的和，而是将两个数字相加的那行代码。
        BinaryOperator<Long> add = (x, y) -> x + y;
        System.out.println("方式四,add : " + add.apply(2L, 3L));

        // 5、方式五,有时最好也可以显式声明参数类型，此时就需要使用小括号将参数括起来，多个参数的情况也是如此
        BinaryOperator<Long> addExplicit = (Long x, Long y) -> x + y;
        System.out.println("方式五,addExplicit : " + addExplicit.apply(1L, 2L));

    }

}

4、Java的函数接口？

答：函数接口是只有一个抽象方法的接口，用作Lambda表达式的类型。

package com.demo.main;

public interface LambdaType<T> {

    // 函数接口是只有一个抽象方法的接口，用作Lambda表达式的类型。
    abstract int add(T x,T y);
    
    public static void main(String[] args) {
        LambdaType<Integer> lambdaType =  (x, y) -> x + y;
        System.out.println(lambdaType.add(1, 2));
    }
    
}

5、Java8的Lambda要点内容：

答：1）、Lambda表达式是一个匿名方法，将行为像数据一样进行传递。

　　2）、Lambda表达式的常见结构： BinaryOperator<Integer> add=(x, y) → x+y。

　　3）、函数接口指仅具有单个抽象方法的接口，用来表示Lambda表达式的类型。

6、Stream是用函数式编程方式在集合类上进行复杂操作的工具。

答：1）、Stream里的一些方法却略有不同，它们虽是普通的Java方法，但返回的Stream对象却不是一个新集合，而是创建新集合的配方。

　　2）、像filter这样只描述Stream，最终不产生新集合的方法叫作惰性求值方法，而像count这样最终会从Stream产生值的方法叫作及早求值方法。

　　3）、判断一个操作是惰性求值还是及早求值很简单：只需看它的返回值。如果返回值是Stream，那么是惰性求值；如果返回值是另一个值或为空，那么就是及早求值。使用这些操作的理想方式就是形成一个惰性求值的链，最后用一个及早求值的操作返回想要的结果，这正是它的合理之处。

package com.demo.main;

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

public class StramMain {

    public static void main(String[] args) {
        List<String> lists = new ArrayList<String>();
        lists.add("Java");
        lists.add("SpringCloud");
        lists.add("SpringBoot");
        lists.add("Spring");

        // 习惯写法一
        for (String str : lists) {
            if (str.contains("Spring")) {
                System.out.println("for循环：" + str.toString());
            }
        }
        System.out.println();

        // 习惯写法二,方法是返回一个控制迭代的Iterator对象
        Iterator<String> iterator = lists.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            if (str.contains("Spring")) {
                System.out.println("while循环：" + str.toString());
            }
        }
        System.out.println();

        // Java8流式写法,stream()方法的调用,返回内部迭代中的相应接口:Stream。
        long count = lists.stream().filter(list -> {
            System.out.println("filter是惰性求值方法");
            return list.contains("Spring");
        }).count();
        System.out.println("count及早求值方法: " + count);
        
    }

}

7、Stream常用的流操作。

答：1）、collect(toList())方法由Stream里的值生成一个列表，是一个及早求值操作。

　　2）、Stream的of方法使用一组初始值生成新的Stream。

package com.demo.main;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StramMain {

    public static void main(String[] args) {
        // Stream<String> list = Stream.of("Spring", "SpringBoot", "SpringCloud");
        // List<String> collected = list.collect(Collectors.toList());
        // 可以缩写为下面一句
        List<String> collected = Stream.of("Spring", "SpringBoot", "SpringCloud").collect(Collectors.toList());

        // 使用流Stream进行遍历操作，可以直接打印信息
        collected.forEach((String str) -> System.out.println(str.toString()));
        // 省略Lanbda的参数类型
        collected.forEach(str -> System.out.println(str.toString()));
    }

}

　　3）、map如果有一个函数可以将一种类型的值转换成另外一种类型，map操作就可以使用该函数，将一个流中的值转换成一个新的流。

package com.demo.main;

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

public class StramMain {

    public static void main(String[] args) {
        // 习惯写法，使用for循环将字符串转换为大写
        List<String> list = new ArrayList<String>();
        for (String str : Arrays.asList("Spring", "SpringBoot", "SpringCloud")) {
            String upperStr = str.toUpperCase();
            list.add(upperStr);
        }

        // Stream流式写法,使用map操作将字符串转换为大写形式
        Stream<String> stream = Stream.of("Spring", "SpringBoot", "SpringCloud").map(str -> str.toUpperCase());
        List<String> collected = stream.collect(Collectors.toList());
        collected.forEach(str -> System.out.println(str.toString()));
        System.out.println();

        // 一句写法
        Stream.of("Spring", "SpringBoot", "SpringCloud")
                // 传给map的Lambda表达式只接受一个String类型的参数,返回一个新的String类型。
                .map(str -> str.toUpperCase()) 
                // 参数和返回值不必属于同一种类型，但是Lambda表达式必须是Function接口的一个实例,
                // Function接口是只包含一个参数的普通函数接口。
                .collect(Collectors.toList())
                .forEach(str -> System.out.println(str.toString()));

    }

}

4）、filter遍历数据并检查其中的元素时，可尝试使用Stream中提供的新方法filter。 

package com.demo.main;

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

public class StramMain {

    public static void main(String[] args) {
        // 习惯写法，使用循环遍历列表，使用条件语句做判断
        List<String> list = new ArrayList<String>();
        for (String str : Arrays.asList("Spring", "SpringBoot", "SpringCloud")) {
            if (str.startsWith("Spring")) {
                list.add(str);
            }
        }
        // 这里使用流式遍历
        list.stream().forEach(str -> System.out.println(str.toString()));
        System.out.println();

        // Stream流式写法,使用循环遍历列表，使用条件语句做判断
        Stream<String> stream = Stream.of("Spring", "SpringBoot", "SpringCloud")
                .filter(str -> str.startsWith("Spring"));
        List<String> collected = stream.collect(Collectors.toList());
        collected.forEach(str -> System.out.println(str.toString()));
        System.out.println();
        
        // Stream一句写法
        Stream.of("Spring", "SpringBoot", "SpringCloud")
                // 和map很像，filter接受一个函数(函数接口)作为参数，该函数用Lambda表达式表示。
                .filter(str -> str.startsWith("Spring"))
                .collect(Collectors.toList())
                .forEach(str -> System.out.println(str.toString()));
        
    }

}

5）、flatMap方法可用Stream替换值，然后将多个Stream连接成一个Stream。map操作，它可用一个新的值代替Stream中的值。但有时，如果希望让map操作有点变化，生成一个新的Stream对象取而代之。用户通常不希望结果是一连串的流，此时flatMap最能派上用场。

package com.demo.main;

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

public class StramMain {

    public static void main(String[] args) {
        // 习惯写法，使用循环遍历列表，使用条件语句做判断

        // Stream流式写法,使用循环遍历列表，使用条件语句做判断
        Stream<List<String>> stream = Stream.of(Arrays.asList("Spring"), Arrays.asList("SpringBoot", "SpringCloud"));
        Stream<String> flatMap = stream.flatMap(list -> list.stream());
        List<String> list = flatMap.collect(Collectors.toList());
        list.forEach(str -> System.out.println(str.toString()));
        System.out.println();
        
        // Stream一句写法
        Stream.of(Arrays.asList("Spring"), Arrays.asList("SpringBoot", "SpringCloud"))
                .flatMap(list2 -> list2.stream())
                .collect(Collectors.toList())
                .forEach(str -> System.out.println(str.toString()));
    }

}

6）、Stream上常用的操作之一是求最大值和最小值。Stream API中的max和min操作足以解决这一问题。

package com.demo.main;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

public class StramMain {

    public static void main(String[] args) {
        List<BookInfo> list = Arrays.asList(new BookInfo("Spring", 100), new BookInfo("SpringBoot", 200),
                new BookInfo("SpringCloud", 300));

        // 习惯写法，使用循环遍历列表，使用条件语句做判断
        BookInfo bookInfo = list.get(0);
        for (BookInfo book : list) {
            if (book.getPrice() < bookInfo.getPrice()) {
                bookInfo = book;
            }
        }
        System.out.println(bookInfo.toString());
        System.out.println();

        // Stream流式写法,使用循环遍历列表，使用条件语句做判断
        Optional<BookInfo> optionalMin = list.stream().min(Comparator.comparing(BookInfo::getPrice));
        BookInfo bookStreamMin = optionalMin.get();
        System.out.println(bookStreamMin.toString());
        System.out.println();

        // Stream一句写法
        // 取出最小值
        BookInfo bookStreamMin2 = list.stream().min(Comparator.comparing(BookInfo::getPrice)).get();
        System.out.println(bookStreamMin2.toString());
        System.out.println();

        // 取出最大值
        BookInfo bookStreamMax = list.stream().max(Comparator.comparing(BookInfo::getPrice)).get();
        System.out.println(bookStreamMax.toString());
        System.out.println();

//        java1.8的双冒号（::），双冒号（::）运算符在Java 8中被用作方法引用（method reference），方法引用是与lambda表达式相关的一个重要特性。它提供了一种不执行方法的方法。为此，方法引用需要由兼容的函数接口组成的目标类型上下文。
//        大致意思是，使用lambda表达式会创建匿名方法， 但有时候需要使用一个lambda表达式只调用一个已经存在的方法（不做其它）， 所以这才有了方法引用！

//        以下是Java 8中方法引用的一些语法：
//        1)、静态方法引用（static method）语法：classname::methodname 例如：Person::getAge
//        2)、对象的实例方法引用语法：instancename::methodname 例如：System.out::println
//        3)、对象的超类方法引用语法： super::methodname
//        4)、类构造器引用语法： classname::new 例如：ArrayList::new
//        5)、数组构造器引用语法： typename[]::new 例如： String[]:new
        
    }

}

7）、reduce操作可以实现从一组值中生成一个值。如count、min和max方法，因为常用而被纳入标准库中。事实上，这些方法都是reduce操作。

package com.demo.main;

import java.util.Arrays;
import java.util.function.BinaryOperator;
import java.util.stream.Stream;

public class StramMain {

    public static void main(String[] args) {
        // 习惯写法，使用命令式编程方式求和
        int sum = 0;
        for (Integer nums : Arrays.asList(1, 2, 3, 4)) {
            sum = sum + nums;
        }
        System.out.println("sum : " + sum);

        // Stream流式写法,使用reduce求和
        // Lambda表达式的返回值是最新的sum2。
        // Lambda表达式就是reducer，它执行求和操作，有两个参数：传入Stream中的当前元素num2和sum2。将两个参数相加，sum2是累加器，保存着当前的累加结果。
        BinaryOperator<Integer> accumulator = (acc, element) -> acc + element;
        int count = accumulator.apply(accumulator.apply(accumulator.apply(accumulator.apply(0, 1), 2), 3), 4);
        System.out.println("count: " + count);

        // Stream一句写法
        Integer sumStream = Stream.of(1, 2, 3, 4).reduce(0, (sum2, num2) -> sum2 + num2);
        System.out.println("sumStream : " + sumStream);

    }

}

8）、综合案例，如何根据图书列表，找出图书所属的公司团队，如下所属：

package com.demo.main;

import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StramMain {

    private Set<BookInfo> getAllBookInfos() {
        Set<BookInfo> set = new HashSet<BookInfo>();
        // 维护图书集合
        set.add(new BookInfo("Spring", "Pivotal-1", 100));
        set.add(new BookInfo("SpringBoot", "Pivotal-2", 200));
        set.add(new BookInfo("SpringCloud", "Pivotal-3", 300));
        return set;
    }

    private Set<String> getAllBookNames() {
        Set<BookInfo> bookInfos = this.getAllBookInfos();
        Set<String> set = new HashSet<String>();
        // 遍历获取到图书名称
        for (BookInfo bookInfo : bookInfos) {
            set.add(bookInfo.getBookname());
        }
        return set;
    }

    public static void main(String[] args) {
        // 习惯写法

        // Stream流式写法，找出图书技术所属的公司
        StramMain stramMain = new StramMain();
        // 首先获取到所有的图书信息并过滤到自己想要的图书信息
        Stream<BookInfo> stream = stramMain.getAllBookInfos().stream()
                .filter(bookInfo -> bookInfo.getBookname().startsWith("Spring"));
        // 使用map将技术图书映射为所属的公司
        Stream<String> streaMap = stream.map(bookInfo -> bookInfo.getTeam());
        // 使用collect(Collectors.toList())方法将图书所属的公司放入一个列表。
        Set<String> collect = streaMap.collect(Collectors.toSet());
        // 循环遍历输出
        collect.forEach(bookTeam -> System.out.println(bookTeam.toString()));

        // Stream一句写法
        // filter和map方法都返回Stream对象，因此都属于惰性求值，而collect方法属于及早求值。
        // List或Set这样的集合类,只要调用List或Set的stream方法就能得到一个Stream对象。
        stramMain.getAllBookInfos().stream()
                .filter(bookInfo -> bookInfo.getBookname().startsWith("Spring"))
                // map方法接受一个Lambda表达式，使用该Lambda表达式对Stream上的每个元素做映射，形成一个新的Stream。
                .map(bookInfo -> bookInfo.getTeam())
                .collect(Collectors.toSet())
                .forEach(bookTeam -> System.out.println(bookTeam.toString()));
    }

    class BookInfo {
        private String bookname;
        private String team;
        private int price;

        public String getBookname() {
            return bookname;
        }

        public void setBookname(String bookname) {
            this.bookname = bookname;
        }

        public String getTeam() {
            return team;
        }

        public void setTeam(String team) {
            this.team = team;
        }

        public int getPrice() {
            return price;
        }

        public void setPrice(int price) {
            this.price = price;
        }

        @Override
        public String toString() {
            return "BookInfo [bookname=" + bookname + ", team=" + team + ", price=" + price + "]";
        }

        public BookInfo(String bookname, String team, int price) {
            super();
            this.bookname = bookname;
            this.team = team;
            this.price = price;
        }

        public BookInfo() {
            super();
        }
    }

}

8、如何使用Stream流和Lambda重构遗留代码。

package com.demo.main;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.stream.Collectors;

public class StramMain {

    private Set<BookInfo> getAllBookInfos() {
        Set<BookInfo> set = new HashSet<BookInfo>();
        // 维护图书集合
        set.add(new BookInfo("Spring", "Pivotal-1", 100));
        set.add(new BookInfo("SpringBoot", "Pivotal-2", 200));
        set.add(new BookInfo("SpringCloud", "Pivotal-3", 300));
        return set;
    }

    private Set<String> getAllBookNames() {
        Set<BookInfo> bookInfos = this.getAllBookInfos();
        Set<String> set = new HashSet<String>();
        // 遍历获取到图书名称
        for (BookInfo bookInfo : bookInfos) {
            set.add(bookInfo.getBookname());
        }
        return set;
    }

    public static void main(String[] args) {
        StramMain stramMain = new StramMain();
        // 习惯写法，找出图书价格大于等于200的图书信息列表
        Set<BookInfo> seBookInfos = new HashSet<BookInfo>();
        for (BookInfo bookInfo : stramMain.getAllBookInfos()) {
            // 如果图书价格大于等于200
            if (bookInfo.getPrice() >= 200) {
                seBookInfos.add(bookInfo);
            }
        }
        // 循环输出
        Iterator<BookInfo> iterator = seBookInfos.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().toString());
        }
        System.out.println();

        
        
        // Stream流式写法，找出图书价格大于等于200的图书信息列表
        Set<BookInfo> bookInfoStream = new HashSet<BookInfo>();
        stramMain.getAllBookInfos().stream().forEach(bookInfo -> {
            if (bookInfo.getPrice() >= 200) {
                bookInfoStream.add(bookInfo);
            }
        });
        bookInfoStream.forEach(bookInfo -> System.out.println(bookInfo.toString()));
        System.out.println();

        
        
        // Stream一句写法，找出图书价格大于等于200的图书信息列表
        Set<BookInfo> bookInfoStream2 = new HashSet<BookInfo>();
        stramMain.getAllBookInfos().stream()
                // 找出满足图书价格大于200的
                .filter(bookInfo -> bookInfo.getPrice() >= 200)
                // 将满足条件的图书列表生成一个新的Stream流
                .map(bookInfo -> bookInfo)
                // 使用循环将新生成的流Stream循环遍历到Set集合中
                .forEach(bookInfo -> bookInfoStream2.add(bookInfo));
        // 循环遍历输出
        bookInfoStream2.forEach(bookInfo -> System.out.println(bookInfo.toString()));
        System.out.println();
        
        
        
        // Stream一句写法，找出图书价格大于等于200的图书信息列表
        // 使用collect(Collectors. toList())可以将Stream中的值转换成一个列表，
        // 使用collect(Collectors.toSet())可以将Stream中的值转换成一个集合。
        stramMain.getAllBookInfos().stream()
            // 找出满足图书价格大于200的
            .filter(bookInfo -> bookInfo.getPrice() >= 200)
            // 将满足条件的图书列表生成一个新的Stream流
            .map(bookInfo -> bookInfo)
            // 将生成的stream流转换为set集合
            .collect(Collectors.toSet())
            .forEach(bookInfo -> System.out.println(bookInfo.toString()));;
            
    }

    class BookInfo {
        private String bookname;
        private String team;
        private int price;

        public String getBookname() {
            return bookname;
        }

        public void setBookname(String bookname) {
            this.bookname = bookname;
        }

        public String getTeam() {
            return team;
        }

        public void setTeam(String team) {
            this.team = team;
        }

        public int getPrice() {
            return price;
        }

        public void setPrice(int price) {
            this.price = price;
        }

        @Override
        public String toString() {
            return "BookInfo [bookname=" + bookname + ", team=" + team + ", price=" + price + "]";
        }

        public BookInfo(String bookname, String team, int price) {
            super();
            this.bookname = bookname;
            this.team = team;
            this.price = price;
        }

        public BookInfo() {
            super();
        }
    }

}

9、高阶函数是指接受另外一个函数作为参数，或返回一个函数的函数。高阶函数不难辨认：看函数签名就够了。如果函数的参数列表里包含函数接口，或该函数返回一个函数接口，那么该函数就是高阶函数。

/**
     * Returns a stream consisting of the results of applying the given
     * function to the elements of this stream.
     *
     * <p>This is an <a href="package-summary.html#StreamOps">intermediate
     * operation</a>.
     *
     * @param <R> The element type of the new stream
     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
     *               <a href="package-summary.html#Statelessness">stateless</a>
     *               function to apply to each element
     * @return the new stream
     */
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

10、Java 8中的另一个变化是引入了默认方法和接口的静态方法，它改变了人们认识类库的方式，接口中的方法也可以包含代码体了。

答：1）、Java1.8的默认方法，如果子类未实现父接口的方法，则使用父接口里面的方法，这样的方法叫作默认方法，在任何接口中，无论函数接口还是非函数接口，都可以使用该方法。

　　2）、和类不同，接口没有成员变量，因此默认方法只能通过调用子类的方法来修改子类本身，避免了对子类的实现做出各种假设。

11、Java 8中的默认方法，理解：

答：1）、类胜于接口。如果在继承链中有方法体或抽象的方法声明，那么就可以忽略接口中定义的方法。

　　2）、子类胜于父类。如果一个接口继承了另一个接口，且两个接口都定义了一个默认方法，那么子类中定义的方法胜出。

　　3）、如果上面两条规则不适用，子类要么需要实现该方法，要么将该方法声明为抽象方法。

 

 

 

 

。