1、函数式编程思想概述
面向对象编程思想
面向对象强调的是对象 , “必须通过对象的形式来做事情”,相对来讲比较复杂,有时候我们只是为了做某件事情而不得不创建一个对象 , 例如线程执行任务,我们不得不创建一个实现Runnable接口对象,但我们真正希望的是将run方法中的代码传递给线程对象执行
函数编程思想
在数学中,函数就是有输入量、输出量的一套计算方案,也就是“拿什么东西做什么事情”。相对而言,面向对象过分强调“必须通过对象的形式来做事情”,而函数式思想则尽量忽略面向对象的复杂语法——强调做什么,而不是以什么形式做。例如线程执行任务 , 使用函数式思想 , 我们就可以通过传递一段代码给线程对象执行,而不需要创建任务对象
- 函数式编程思想强调做什么,而不是以什么形式做,也就是直接传入一段代码,不需要创建对象
2、Lambda表达式
实现Runnable接口的方式创建线程执行任务
实现类:
1.创建一个实现类,实现Runnable接口
2.在实现类中,重写run()方法,把任务放入run()方法中
3.创建实现类对象
4.创建Thread线程对象,传入实现类对象
5.使用线程对象调用start()方法,启动并执行线程
总共需要5个步骤,一步都不能少,为什么要创建实现类,为了得到线程的任务
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("实现的方法创建线程的任务执行了...");
}
}
public class Demo {
public static void main(String[] args) {
// 实现类的方式:
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
t.start();
}
}
匿名内部类方式创建线程执行任务
匿名内部类:
1.创建Thread线程对象,传入Runnable接口的匿名内部类
2.在匿名内部类中重写run()方法,把任务放入run()方法中
3.使用线程对象调用start()方法,启动并执行线程
总共需要3个步骤,一步都不能少,为什么要创建Runnable的匿名内部类类,为了得到线程的任务
public class Demo {
public static void main(String[] args) {
// 匿名内部类的方式:
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类的方式创建线程的任务执行了");
}
});
t2.start();
}
}
Lambda方式创建线程执行任务
以上2种方式都是通过Runnable接口的实现类对象,来传入线程需要执行的任务(面向对象编程)
思考: 是否能够不通过Runnable接口的实现类对象来传入任务,而是直接把任务传给线程???
Lambda表达式的概述:
它是一个JDK8开始的一个新语法。它是一种“代替语法”——可以代替我们之前编写的“面向某种接口”编程的情况
public class Demo {
public static void main(String[] args) {
// 体验Lambda表达式的方式:
Thread t3 = new Thread(()->{System.out.println("Lambda表达式的方式");});
t3.start();
}
}
2.1 Lambda表达式的格式
作用
- Lambda表达式的作用就是简化代码,省略了面向对象中类和方法,对象的书写。
标准格式
Lambda省去面向对象的条条框框,格式由3个部分组成:
- 一些参数
- 一个箭头
- 一段代码
Lambda表达式的标准格式为:
(参数类型 参数名,参数类型 参数名,...) -> { 代码语句 }
格式说明
- 小括号内的语法与传统方法参数列表一致:无参数则留空;多个参数则用逗号分隔。
->
是新引入的语法格式,代表指向动作。- 大括号内的语法与传统方法体要求基本一致。
线程案例
public class Test {
public static void main(String[] args) {
/*
格式解释:
1.小括号中书写的内容和接口中的抽象方法的参数列表一致
2.大括号中书写的内容和实现接口中的抽象方法的方法体一致
3.箭头就是固定的
*/
// 线程案例
// 面向对象编程思想:
// 匿名内部类方式创建线程执行任务
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程需要执行的任务代码1...");
}
});
t1.start();
// 函数式编程思想: Lambda表达式
Thread t2 = new Thread(()->{ System.out.println("线程需要执行的任务代码2...");});
t2.start();
}
}
比较器案例
public class Test {
public static void main(String[] args) {
/*
格式解释:
1.小括号中书写的内容和接口中的抽象方法的参数列表一致
2.大括号中书写的内容和实现接口中的抽象方法的方法体一致
3.箭头就是固定的
*/
// 比较器案例
// Collections.sort(List<?> list,Comparator<?> comparator);
List<Integer> list = new ArrayList<>();
Collections.addAll(list,100,200,500,300,400);
System.out.println("排序之前的集合:"+list);// [100, 200, 500, 300, 400]
// 面向对象编程思想:
/*Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
// 降序: 后减前
return o2 - o1;
}
});
System.out.println("排序之后的集合:"+list);// [500, 400, 300, 200, 100]*/
// 函数式编程思想:Lambda表达式
Collections.sort(list,(Integer o1, Integer o2)->{return o2 - o1;});
System.out.println("排序之后的集合:"+list);// [500, 400, 300, 200, 100]
}
}
Lambda表达式的使用条件: 接口中有且仅有一个抽象方法的接口,才可以使用Lambda表达式
1.接口中只有一个抽象方法的接口,叫做函数式接口
2.如果是函数式接口,那么就可以使用@FunctionalInterface注解来标识
使用Lambda表达式:
1.判断接口是否是函数式接口
2.如果是函数式接口,那么就直接写()->{}
3.然后填充小括号和大括号中的内容
JDK8新特性:函数式接口@FunctionalInterface的使用说明
我们常用的一些接口Callable、Runnable、Comparator等在JDK8中都添加了@FunctionalInterface注解。
通过JDK8源码javadoc,可以知道这个注解有以下特点:
1、该注解只能标记在"有且仅有一个抽象方法"的接口上。
2、JDK8接口中的静态方法和默认方法,都不算是抽象方法。
3、接口默认继承java.lang.Object,所以如果接口显示声明覆盖了Object中方法,那么也不算抽象方法。
4、该注解不是必须的,如果一个接口符合"函数式接口"定义,那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口,但是加上了@FunctionInterface,那么编译器会报错。
default是在java8中引入的关键字,也可称为Virtual
extension methods——虚拟扩展方法。是指,在接口内部包含了一些默认的方法实现(也就是接口中可以包含方法体,这打破了Java之前版本对接口的语法限制),从而使得接口在进行扩展的时候,不会破坏与接口相关的实现类代码。
2.2 Lambda表达式省略格式
省略规则
在Lambda标准格式的基础上,使用省略写法的规则为:
- 小括号内参数的类型可以省略;
- 如果小括号内有且仅有一个参数,则小括号可以省略;
- 如果大括号内有且仅有一条语句,则无论是否有返回值,都可以一起省略大括号、return关键字及语句分号。
public class Demo_线程演示 {
public static void main(String[] args) {
//Lambda表达式省略规则
Thread t2 = new Thread(()-> System.out.println("执行了"));
t2.start();
}
}
public class Demo_比较器演示 {
public static void main(String[] args) {
//比较器
ArrayList<Integer> list = new ArrayList<>();
//添加元素
list.add(324);
list.add(123);
list.add(67);
list.add(987);
list.add(5);
System.out.println(list);
//Lambda表达式
Collections.sort(list, ( o1, o2)-> o2 - o1);
//打印集合
System.out.println(list);
}
}
2.3 Lambda的前提条件和表现形式
Lambda的前提条件
-
使用Lambda必须具有接口,且要求接口中的抽象方法有且仅有一个。(别的方法没有影响) (条件)
-
使用Lambda必须具有上下文推断。(忽略)
-
如果一个接口中只有一个抽象方法,那么这个接口叫做是函数式接口。
@FunctionalInterface这个注解 就表示这个接口是一个函数式接口
-
Lambda的表现形式
- 变量形式
- 参数形式
- 返回值形式
public class Test {
public static void main(String[] args) {
/*
Lambda的表现形式:
1.变量的形式:变量的类型为函数式接口类型,那么可以赋值一个Lambda表达式
2.参数的形式:方法的形参类型为函数式接口类型,那么就可以传入一个Lambda表达式 常见
3.返回值的形式:方法的返回值类型为函数式接口类型,那么就可以返回一个Lambda表达式 常见
*/
// 变量的形式:
Runnable r = ()->{
System.out.println("任务代码");
};
Comparator<Integer> com = (Integer i1,Integer i2)->{return i2 - i1;};
// 参数形式:
ArrayList<Integer> list = new ArrayList<>();
list.add(300);
list.add(200);
list.add(100);
list.add(500);
list.add(400);
System.out.println("排序前:" + list);
// 对集合中的元素按照降序排序
Collections.sort(list,(Integer i1,Integer i2)->{return i2 - i1;});
System.out.println("排序后:" + list);// 降序
Collections.sort(list, getComparator());
System.out.println("排序后:" + list);// 升序
}
// 返回值形式
public static Comparator<Integer> getComparator(){
return (Integer i1 , Integer i2)->{return i1 - i2;};
}
}
Lambda表达式就是用来替换函数式接口的对象
3、Stream
在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,用于解决已有集合类库既有的弊端。
例如: 有一个List集合,要求:
- 将List集合中A开头的的元素过滤到一个新的集合中
- 然后将过滤出来的A开头的元素,再过滤出长度为3的元素,存储到一个新的集合中
传统方式操作集合
public class Demo {
public static void main(String[] args) {
// 传统方式操作集合:
List<String> list = new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("ACC");
list.add("DDD");
list.add("AD");
// 1.将List集合中A开头的元素过滤到一个新的集合中
// 1.1 创建一个新的集合,用来存储所有姓张的元素
List<String> listB = new ArrayList<>();
// 1.2 循环遍历list集合,在循环中判断元素是否姓张
for (String e : list) {
// 1.3 如果姓张,就添加到新的集合中
if (e.startsWith("A")) {
listB.add(e);
}
}
// 2.然后将过滤出来的A开头的元素,再过滤出长度为3的元素,存储到一个新的集合中
// 2.1 创建一个新的集合,用来存储所有姓张的元素并且长度为3
List<String> listC = new ArrayList<>();
// 2.2 循环遍历listB集合,在循环中判断元素长度是否为3
for (String e : listB) {
// 2.3 如果长度为3,就添加到新的集合中
if(e.length() == 3){
listC.add(e);
}
}
// 3.打印所有元素---循环遍历
for (String e : listC) {
System.out.println(e);
}
}
}
Stream流操作集合
public class Demo {
public static void main(String[] args) {
// 体验Stream流:
list.stream().filter(e->e.startsWith("张")).filter(e->e.length()==3).forEach(e-> System.out.println(e));
System.out.println(list);
}
}
直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:获取流、过滤姓张、过滤长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历,我们真正要做的事情内容被更好地体现在代码中。
流式思想:
1)、搭建好函数模型,才可以执行
函数模型: 一定要有终结的方法,没有终结的方法,这个函数模型是不会执行的
2)、Stream流的操作方式也是流动操作的,也就是说每一个流都不会存储元素
3)、一个Stream流只能操作一次,不能重复使用
4)、Stream流操作不会改变数据源
3.1 获取流方式
根据Collection获取流
- Collection接口中有一个stream()方法,可以获取流
default Stream<E> stream() //返回以此集合为源的顺序Stream 。
default Stream<E> parallelStream() //以此集合为源返回可能并行的Stream 。 此方法允许返回顺序流。
- 通过List集合获取:
- 通过Set集合获取
根据Map获取流
-
使用所有键的集合来获取流
-
使用所有值的集合来获取流
-
使用所有键值对的集合来获取流
根据数组获取流
- Stream流中有一个
public static<T> Stream<T> of(T... values)
- 通过数组获取:
- 通过直接给多个数据的方式
public static<T> Stream<T> of(T t)
public static<T> Stream<T> of(T... values) //返回元素为指定值的顺序有序流 Creating a stream from an array is safe
案例演示
import java.util.*;
import java.util.stream.Stream;
public class Test {
public static void main(String[] args) {
// 创建List集合
List<String> list = new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
list.add("EEE");
Stream<String> stream1 = list.stream();
// 创建Set集合
Set<String> set = new HashSet<>();
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
list.add("EEE");
Stream<String> stream2 = set.stream();
// 创建Map集合
Map<Integer, String> map = new HashMap<>();
map.put(1, "java");
map.put(2, "php");
map.put(3, "c");
map.put(4, "c++");
map.put(5, "Python");
// 1.根据Map集合的键获取流
Set<Integer> keys = map.keySet();
Stream<Integer> stream3 = keys.stream();
// 2.根据Map集合的值获取流
Collection<String> values = map.values();
Stream<String> stream4 = values.stream();
// 3.根据Map集合的键值对对象获取流
Set<Map.Entry<Integer, String>> entrys = map.entrySet();
Stream<Map.Entry<Integer, String>> stream5 = entrys.stream();
// 根据数组获取流
String[] arr = {"AAA",
"BBB",
"CCC",
"DDD",
"EEE"};
Stream<String> stream6 = Stream.of(arr);
// 直接获取流
Stream<String> stream7 = Stream.of("张三", "李四", "王五");
}
}
3.2 Stream流常用方法
流模型的操作很丰富,这里介绍一些常用的API。这些方法可以被分成两种:
- 终结方法:返回值类型不再是
Stream
接口自身类型的方法,因此不再支持类似StringBuilder
那样的链式调用。本小节中,终结方法包括count
和forEach
方法。 - 非终结方法(延迟方法):返回值类型仍然是
Stream
接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余方法均为非终结方法。)
函数拼接与终结方法
在上述介绍的各种方法中,凡是返回值仍然为Stream
接口的为函数拼接方法,它们支持链式调用;而返回值不再为Stream
接口的为终结方法,不再支持链式调用。如下表所示:
方法名 | 方法作用 | 方法种类 | 是否支持链式调用 |
---|---|---|---|
count | 统计个数 | 终结 | 否 |
forEach | 逐一处理 | 终结 | 否 |
filter | 过滤 | 函数拼接 | 是 |
limit | 取用前几个 | 函数拼接 | 是 |
skip | 跳过前几个 | 函数拼接 | 是 |
map | 映射 | 函数拼接 | 是 |
concat | 组合 | 函数拼接 | 是 |
备注:本小节之外的更多方法,请自行参考API文档。
void forEach(Consumer<? super T> action); //逐一处理流中的元素
//该方法接收一个`Consumer`接口函数,会将每一个流元素交给该函数进行处理
long count() //统计流中元素的个数
//过滤
Stream<T> filter(Predicate<? super T> predicate); //返回由与此给定谓词匹配的此流的元素组成的流
//截断
Stream<T> limit(long maxSize) //取用前几个
//如果流的当前长度大于参数则进行截取;否则不进行操作
Stream<T> skip(long n) //如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流
<R> Stream<R> map(Function<? super T,? extends R> mapper)
//返回一个流,该流包含将给定函数应用于此流的元素的结果
//合并
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) //合并2个流
//收集结果
Object[] toArray(); //到数组
<R,A> R collect(Collector<? super T,A,R> collector) //把流中的数据收集到单列集合中
forEach : 逐一处理
虽然方法名字叫forEach
,但是与for循环中的“for-each”昵称不同,该方法并不保证元素的逐一消费动作在流中是被有序执行的。
例如:
public class Test1_forEach {
public static void main(String[] args) {
/*
forEach方法:
void forEach(Consumer<? super T> action);逐一处理流中的元素
参数Consumer<T>: 函数式接口,抽象方法void accept(T t);
注意:
1.方法并不保证元素的逐一消费动作在流中是被有序执行的。
2.Consumer是一个消费接口
*/
List<String> list = new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
list.add("EEE");
// 函数模型: 获取流->逐一消费流中的元素
list.stream().forEach((String e)->{
System.out.println(e);
});
System.out.println("========================================");
// 并行流: 通过Collection的parallelStream()方法可以得到并行流
list.parallelStream().forEach((String e)->{
System.out.println(e);
});
}
}
filter:过滤
可以通过filter
方法将一个流转换成另一个子集流。方法声明:
Stream<T> filter(Predicate<? super T> predicate);
该接口接收一个Predicate
函数式接口参数(可以是一个Lambda或方法引用)作为筛选条件。
基本使用
Stream流中的filter
方法基本使用的代码如:
public class Test3_filter {
/*
filter方法:
Stream<T> filter(Predicate<? super T> predicate);过滤出满足条件的元素
参数Predicate: 函数式接口, 抽象方法 boolean test(T t);
Predicate接口:是一个判断接口
*/
public static void main(String[] args) {
// 获取Stream流
Stream<String> stream = Stream.of("AA", "BBB", "CCC", "DDD", "BEE", "FFF");
// 需求:过滤出A开头的元素
stream.filter((String s) -> {
System.out.println("执行了吗?");
return s.startsWith("B");
}).forEach((String name)->{
System.out.println(name);
});
//stream.count(); //不能再使用了
}
}
limit:取用前几个
limit
方法可以对流进行截取,只取用前n个。方法签名:
Stream<T> limit(long maxSize);
参数是一个long型,如果流的当前长度大于参数则进行截取;否则不进行操作。
skip:跳过前几个
如果希望跳过前几个元素,可以使用skip
方法获取一个截取之后的新流:
Stream<T> skip(long n);
如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。
map:映射
如果需要将流中的元素映射到另一个流中,可以使用map
方法。方法签名:
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
该接口需要一个Function
函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流。
public class Test6_map {
public static void main(String[] args) {
/*
map方法:
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
参数Function<T, R>: 函数式接口,抽象方法 R apply(T t);
Function<T, R>其实就是一个类型转换接口(T和R的类型可以一致,也可以不一致)
*/
// 获取流
Stream<String> stream1 = Stream.of("10", "20", "30", "40");
// 需求:把stream1流中的元素转换为int类型
stream1.map((String s)->{return Integer.parseInt(s);}).forEach((Integer i)->{
System.out.println(i+1);
});
System.out.println("=========================");
// 获取流
Stream<String> stream2 = Stream.of("10", "20", "30", "40");
// 需求:把stream1流中的元素转换为String类型
stream2.map((String s)->{return s+"it";}).forEach((String i)->{
System.out.println(i+1);
});
}
}
map
方法的参数通过方法引用,将字符串类型转换成为了int类型(并自动装箱为Integer
类对象)
concat:合并
如果有两个流,希望合并成为一个流,那么可以使用Stream
接口的静态方法concat
:
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
备注:这是一个静态方法,与
java.lang.String
当中的concat
方法是不同的。
3.3 收集Stream结果
收集到集合中
- Stream流中提供了一个方法,可以把流中的数据收集到单列集合中
- <R,A> R collect(Collector<? super T,A,R> collector): 把流中的数据收集到单列集合中
- 参数Collector<? super T,A,R>: 决定把流中的元素收集到哪个集合中
- 返回值类型是R,也就是说R指定为什么类型,就是收集到什么类型的集合
- 参数Collector如何得到? 使用java.util.stream.Collectors工具类中的静态方法:
- public static Collector<T, ?, List> toList():转换为List集合。
- public static Collector<T, ?, Set> toSet():转换为Set集合。
- <R,A> R collect(Collector<? super T,A,R> collector): 把流中的数据收集到单列集合中
public class Test2_收集到集合中 {
public static void main(String[] args) {
// 传统方式操作集合:
List<String> list = new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
list.add("AR");
// 需求:过滤过滤出A开头的并且长度为3的元素
Stream<String> stream = list.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3);
// 收集到List单列集合中
//List<String> list1 = stream.collect(Collectors.toList());
//System.out.println(list1);// [AAA]
// 收集到Set单列集合中
Set<String> set = stream.collect(Collectors.toSet());
System.out.println(set);// [AAA]
}
}
收集到数组中
Stream提供toArray
方法来将结果放到一个数组中,返回值类型是Object[]的:
Object[] toArray();