1 Lambda表达式
1.1 体验Lambda表达式
-
package com.itheima.lambda_demo; /* Lambda表达式体验 : */ public class LambdaDemo { public static void main(String[] args) { // 匿名内部类方式完成 goSwimming(new Swimming() { @Override public void swim() { System.out.println("铁汁 , 我们去游泳吧...."); } }); // lambda表达式的方式完成 goSwimming(() -> System.out.println("铁汁 , 我们去游泳吧....")); } public static void goSwimming(Swimming swimming) { swimming.swim(); } } interface Swimming { public abstract void swim(); } -
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的
-
面向对象思想 :
- 强调的是用对象去完成某些功能
-
函数式编程思想 :
- 强调的是结果 , 而不是怎么去做
1.2 函数式接口
-
只有一个抽象方法需要重写的接口，函数式接口。函数式接口是允许有其他的非抽象方法的存在例如静态方法，默认方法，私有方法。
-
为了标识接口是一个函数式接口，可以在接口之上加上一个注解： @FunctionalInterface 以示区别
-
在JDK中 java.util.function 包中的所有接口都是函数式接口。我们之前学习线程时学习的Runnable也是函数式接口
1.3 Lambda表达式的使用
-
使用前提
- 必须存在一个接口
- 接口中有且只有一个抽象方法
-
格式 : ( 形式参数 ) -> { 代码块 }
- 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
- ->：由英文中画线和大于符号组成，固定写法。代表指向动作
- 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
1.4 Lambda表达式的案例
package com.itheima.lambda_test;
/*
练习1：
1 编写一个接口（ShowHandler）
2 在该接口中存在一个抽象方法（show），该方法是无参数无返回值
3 在测试类（ShowHandlerDemo）中存在一个方法（useShowHandler）
方法的的参数是ShowHandler类型的，在方法内部调用了ShowHandler的show方法
*/
public class LambdaTest1 {
public static void main(String[] args) {
useShowHandler(() -> {
System.out.println("我是一个lambda表达式....");
});
}
public static void useShowHandler(ShowHandler showHandler) {
showHandler.show();
}
}
interface ShowHandler {
public abstract void show();
}
package com.itheima.lambda_test;
/*
1 首先存在一个接口（StringHandler）
2 在该接口中存在一个抽象方法（printMessage），该方法是有参数无返回值
3 在测试类（StringHandlerDemo）中存在一个方法（useStringHandler），
方法的的参数是StringHandler类型的，
在方法内部调用了StringHandler的printMessage方法
*/
public class LambdaTest2 {
public static void main(String[] args) {
useStringHandler((String msg) -> {
System.out.println(msg);
});
}
public static void useStringHandler(StringHandler stringHandler){
stringHandler.printMessage("今天天气不错 , 挺风和日丽的...");
}
}
@FunctionalInterface
interface StringHandler {
public abstract void printMessage(String msg);
}
package com.itheima.lambda_test;
import java.util.Random;
/*
1 首先存在一个接口（RandomNumHandler）
2 在该接口中存在一个抽象方法（getNumber），该方法是无参数但是有返回值
3 在测试类（RandomNumHandlerDemo）中存在一个方法（useRandomNumHandler），方法的的参数是RandomNumHandler类型的
在方法内部调用了RandomNumHandler的getNumber方法
*/
public class LambdaTest3 {
public static void main(String[] args) {
useRandomNumHandler(() -> {
return new Random().nextInt(10) + 1;
});
}
public static void useRandomNumHandler(RandomNumHandler randomNumHandler) {
int number = randomNumHandler.getNumber();
System.out.println(number);
}
}
interface RandomNumHandler {
public abstract int getNumber();
}
package com.itheima.lambda_test;
/*
1 首先存在一个接口（Calculator）
2 在该接口中存在一个抽象方法（calc），该方法是有参数也有返回值
3 在测试类（CalculatorDemo）中存在一个方法（useCalculator）
方法的的参数是Calculator类型的
在方法内部调用了Calculator的calc方法
*/
public class LambdaTest4 {
public static void main(String[] args) {
useCalculator((int a , int b) -> { return a + b;});
}
public static void useCalculator(Calculator calculator) {
int calc = calculator.calc(10, 20);
System.out.println(calc);
}
}
@FunctionalInterface
interface Calculator {
public abstract int calc(int a, int b);
}
2 Stream流
2.1 Stream的体验
package com.itheima.stream_demo;
import java.util.ArrayList;
/*
体验Stream流的好处
需求：按照下面的要求完成集合的创建和遍历
1 创建一个集合，存储多个字符串元素
"张无忌" , "张翠山" , "张三丰" , "谢广坤" , "赵四" , "刘能" , "小沈阳" , "张良"
2 把集合中所有以"张"开头的元素存储到一个新的集合
3 把"张"开头的集合中的长度为3的元素存储到一个新的集合
4 遍历上一步得到的集合
*/
public class StreamDemo {
public static void main(String[] args) {
// 传统方式完成
ArrayList<String> list = new ArrayList<>();
list.add("张无忌");
list.add("张翠山");
list.add("张三丰");
list.add("谢广坤");
list.add("赵四");
list.add("刘能");
list.add("小沈阳");
list.add("张良");
// 把集合中所有以"张"开头的元素存储到一个新的集合
ArrayList<String> list2 = new ArrayList<>();
for (String s : list) {
if (s.startsWith("张")) {
list2.add(s);
}
}
// 把"张"开头的集合中的长度为3的元素存储到一个新的集合
ArrayList<String> list3 = new ArrayList<>();
for (String s : list2) {
if (s.length() == 3) {
list3.add(s);
}
}
// 遍历list3集合
for (String s : list3) {
System.out.println(s);
}
System.out.println("================================");
// Stream流的方式
list.stream().filter(s -> s.startsWith("张") && s.length() == 3).forEach(s -> System.out.println(s));
}
}
2.2 Stream流的三类方法
- 获取Stream流
- 创建一条流水线，并把数据放到流水线上准备进行操作
- 中间方法
- 流水线上的操作。
- 一次操作完毕之后，还可以继续进行其他操作
- 终结方法
- 一个Stream流只能有一个终结方法
- 是流水线上的最后一个操作
2.3 第一类 : 获取方法
package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
/*
Stream流中三类方法之一 : 获取方法
1 单列集合
可以使用Collection接口中的默认方法stream()生成流
default Stream<E> stream()
2 双列集合
双列集合不能直接获取 , 需要间接的生成流
可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流
3 数组
Arrays中的静态方法stream生成流
*/
public class StreamDemo2 {
public static void main(String[] args) {
// 单列集合的获取
// method1();
// 双列集合的获取
// method2();
// 数组获取
// method3();
}
private static void method3() {
int[] arr = {1, 2, 3, 4, 5, 6};
Arrays.stream(arr).forEach(s -> System.out.println(s));
}
private static void method2() {
HashMap<String, String> hm = new HashMap<>();
hm.put("it001", "曹植");
hm.put("it002", "曹丕");
hm.put("it003", "曹熊");
hm.put("it004", "曹冲");
hm.put("it005", "曹昂");
// 获取map集合的健集合 , 在进行输出打印
hm.keySet().stream().forEach(s -> System.out.println(s));
// 获取map集合的entry对象 , 在输出打印
hm.entrySet().stream().forEach(s -> System.out.println(s));
}
private static void method1() {
// 可以使用Collection接口中的默认方法stream()生成流
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
list.add("欧阳娜娜");
list.stream().forEach(s -> System.out.println(s));
}
}
2.4 第二类 : 中间方法
package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Predicate;
import java.util.stream.Stream;
/*
Stream流中三类方法之一 : 中间方法
1 Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
Predicate接口中的方法 : boolean test(T t)：对给定的参数进行判断，返回一个布尔值
2 Stream<T> limit(long maxSize)：截取指定参数个数的数据
3 Stream<T> skip(long n)：跳过指定参数个数的数据
4 static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
5 Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
6 Stream<T> sorted () : 将流中元素按照自然排序的规则排序
7 Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
*/
public class StreamDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张无忌");
list.add("张翠山");
list.add("张三丰");
list.add("谢广坤");
list.add("赵四");
list.add("刘能");
list.add("小沈阳");
list.add("张良");
list.add("张良");
list.add("张良");
list.add("张良");
// Stream<T> limit(long maxSize)：截取指定参数个数的数据
// list.stream().limit(3).forEach(s -> System.out.println(s));
// Stream<T> skip(long n)：跳过指定参数个数的数据
// list.stream().skip(3).forEach(s-> System.out.println(s));
// Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
// list.stream().distinct().forEach(s->{System.out.println(s);});
}
// // Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
private static void method3(ArrayList<String> list) {
list.stream().sorted(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
}).forEach(s->{
System.out.println(s);
});
}
// Stream<T> sorted () : 将流中元素按照自然排序的规则排序
private static void method3() {
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(3);
list2.add(1);
list2.add(2);
list2.stream().sorted().forEach(s->{
System.out.println(s);
});
}
// // static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
private static void method2(ArrayList<String> list) {
ArrayList<String> list2 = new ArrayList<>();
list2.add("迪丽热巴");
list2.add("古力娜扎");
list2.add("欧阳娜娜");
list2.add("马尔扎哈");
Stream.concat(list.stream(), list2.stream()).forEach(s -> {
System.out.println(s);
});
}
// Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
private static void method1(ArrayList<String> list) {
// filter方法会获取流中的每一个数据
// s就代表的是流中的每一个数据
// 如果返回值为true , 那么代表的是数据留下来
// 如果返回值的是false , 那么代表的是数据过滤掉
// list.stream().filter(new Predicate<String>() {
// @Override
// public boolean test(String s) {
// boolean result = s.startsWith("张");
// return result;
// }
// }).forEach(s -> System.out.println(s));
list.stream().filter(s ->
s.startsWith("张")
).forEach(s -> System.out.println(s));
}
}
2.5 第三类 : 终结方法
package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.function.Consumer;
/*
Stream流中三类方法之一 : 终结方法
1 void forEach(Consumer action)：对此流的每个元素执行操作
Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
2 long count()：返回此流中的元素数
*/
public class StreamDemo4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张无忌");
list.add("张翠山");
list.add("张三丰");
list.add("谢广坤");
// long count()：返回此流中的元素数
long count = list.stream().count();
System.out.println(count);
}
// void forEach(Consumer action)：对此流的每个元素执行操作
private static void method1(ArrayList<String> list) {
// 把list集合中的元素放在stream流中
// forEach方法会循环遍历流中的数据
// 并循环调用accept方法 , 把数据传给s
// 所以s就代表的是流中的每一个数据
// 我们只要在accept方法中对数据做业务逻辑处理即可
list.stream().forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
System.out.println("=====================");
list.stream().forEach( (String s) -> {
System.out.println(s);
});
System.out.println("=====================");
list.stream().forEach( s -> { System.out.println(s); });
}
}
2.6 Stream流中的收集方法
package com.itheima.stream_demo;
import java.util.ArrayList;
/*
Stream流的收集操作 : 第一部分
需求：过滤元素并遍历集合
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
将集合中的奇数删除，只保留偶数。
遍历集合得到2，4，6，8，10
结论：在Stream流中无法直接修改集合,数组等数据源中的数据。
*/
public class StreamDemo5 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list.add(i);
}
list.stream().filter(num -> num % 2 == 0).forEach(num -> System.out.println(num));
System.out.println("=============");
// 结论：在Stream流中无法直接修改集合,数组中的数据。
System.out.println(list);
}
}
package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
/*
Stream流的收集操作 : 第二部分
使用Stream流的方式操作完毕之后，我想把流中的数据起来，该怎么办呢？
Stream流的收集方法
R collect(Collector collector) : 此方法只负责收集流中的数据 , 创建集合添加数据动作需要依赖于参数
工具类Collectors提供了具体的收集方式
public static <T> Collector toList()：把元素收集到List集合中
public static <T> Collector toSet()：把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中
需求 :
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
将集合中的奇数删除，只保留偶数。
遍历集合得到2，4，6，8，10
*/
public class StreamDemo6 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list.add(i);
}
list.add(10);
list.add(10);
list.add(10);
list.add(10);
list.add(10);
// collect只负责收集流中的数据
// Collectors.toList()会负责在底层创建list集合 ,并把数据添加到集合中 , 返回集合对象
List<Integer> list2 = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toList());
System.out.println(list2);
Set<Integer> set = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toSet());
System.out.println(set);
}
}
package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
/*
Stream流的收集操作 : 第三部分
1 创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
"zhangsan,23"
"lisi,24"
"wangwu,25"
2 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
收集方法 :
public static Collector toMap(Function keyMapper , Function valueMapper)：把元素收集到Map集合中
*/
public class StreamDemo7 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("zhangsan,23");
list.add("lisi,24");
list.add("wangwu,25");
// collect 只负责收集数据
// Collectors.toMap负责在底层创建集合对象 , 添加元素
// toMap方法中的s就是代表的是集合中的每一个元素
// 第一个参数 : 如何获取map集合中的键
// 第二个参数 : 如何获取map集合中的值
Map<String, String> map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) > 23).collect(
Collectors.toMap(
(String s) -> {
return s.split(",")[0];
}
,
(String s) -> {
return s.split(",")[1];
}
)
);
System.out.println(map);
}
}
2306
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
