目录
1. Lambda
1.1 概述
1.2 为什么使用Lambda表达式
1.3 和匿名内部类对比
1.4 语法结构
1.5 案例
1.6 练习
2. 函数式接口
2.1 介绍
2.2 特点
2.3 代码实现
2.3.1 无参情况
2.3.2 有参情况
2.4 JDK自带常用的函数式接口
2.4.1Supplier 接口
2.4.2Consumer 接口
2.4.4 Predicate 接口
3. 方法引用和构造器调用
3.1对象调用成员
3.2类名调用成员
3.3类名调用成员
3.4构造方法调用
3.5数组引用
4. StreamAPI
4.1 概念说明
4.2特点
4.3应用场景
4.4代码实现
4.4.1 运行机制说明
4.4.2创建流的方式
4.4.3 常见中间操作
4.4.4 常见的终止操作
1. Lambda
1.1 概述
Lambda 表达式是一种没有名字的函数,也可称为闭包,是Java 8 发布的最重要新特性。
本质上是一段匿名内部类 , 也可以是一段可以传递的代码
还有叫箭头函数的....
1.2 为什么使用Lambda表达式
Lambda表达式就是一个匿名内部类的简写方式
使程序更加简介清晰,编程效率也得到了提高
1.3 和匿名内部类对比
package _01_Lambda;
public class _01_Lambda {
public static void main(String[] args) {
int[] arr = {1,2,3,4};
//常规遍历
for(int j: arr){
System.out.println(j);
}
//1. 实现类
forEach(arr , new A());
//2. 匿名内部类
forEach(arr, new Array(){
@Override
public void m1(int i ){
System.out.println(i+"=========");
}
});
//3. Lambda 表达式
forEach(arr , (i)->System.out.println(i+1+"000000000"));
}
//封装的功能,完成遍历操作,但是需要传递数组,和要做的事情
private static void forEach(int[] arr, Array array) {
for(int i :arr){
array.m1(i);
}
}
}
//封装要做的事
interface Array{
void m1(int i );
}
class A implements Array {
@Override
public void m1(int i) {
System.out.println(i+"___________");
}
}
1.4 语法结构
可选类型声明 : 不需要声明参数类型 , 编译器可以统一识别参数值
可选的参数圆括号 : 一个参数无需定义圆括号,但多个参数需要定义圆括号
可选的大括号 : 如果主体包含了一个语句,就不需要使用大括号
如果不写{} return 不能写 分号不能写
可选的返回关键字 : 如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明确表达式返回了一个值
如果只有一条语句 ,并且是返回值语句,就可以不写 return 不写{}
如果写上{} 就必须写return 和 ; 分号
如果有 多条语句, 必须写{} return 和 ; 也必须写
1.5 案例
1. 不需要参数 ,返回值为5
()->5
2. 接受一个参数(数字类型),返回其2倍的值
x->x*2
3. 接收2个参数(数字),并返回他们的差值
(x,y)->x-y
1.6 练习
package _01_Lambda;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
public class _02_Lambda {
public static void main(String[] args) {
List list = new ArrayList();
list.add(1);
list.add(22);
list.add(3);
//遍历
//常规写法
for(Integer integer : list){
System.out.println(integer);
}
//匿名内部类写法
list.forEach(new Consumer(){
@Override
public void accept(Integer t){
System.out.println(t);
}
});
//Lambda 写法
list.forEach(q-> System.out.println(q));
}
}
package _01_Lambda;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class _03_Lambda {
public static void main(String[] args) {
List list = new ArrayList();
list.add(1);
list.add(22);
list.add(711);
//Lambda 排序 降序排序
Collections.sort(list, (x,y)->y-x);
System.out.println(list);
//传统的排序
Collections.sort(list , new Comparator(){
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
System.out.println(list);
}
}
class B{
@Override
public boolean equals(Object obj){
return false;
}
}
2. 函数式接口
2.1 介绍
2.1 介绍
英文称为Functional Interface
其本质是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
核心目标是为了给Lambda表达式的使用提供更好的支持，进一步达到函数式编程的目标，可通过运用函数式编程极大地提高编程效率。
其可以被隐式转换为 lambda 表达式。
2.2 特点
函数式接口是仅制定一个抽象方法的接口
可以包含一个或多个静态或more方法
专用注解即@FunctionalInterface 检查它是否是一个函数式接口，也可不添加该注解
如果有两个或以上 抽象方法,就不能当成函数式接口去使用,也不能添加@FunctionalInterface这个注解
如果只有一个抽象方法,那么@FunctionalInterface注解 加不加 都可以当做函数式接口去使用
2.3 代码实现
2.3.1 无参情况
public class FunInterface_01 {
// 自定义静态方法,接收接口对象
public static void call(MyFunctionInter func) {
// 调用接口内的成员方法
func.printMessage();
}
public static void main(String[] args) {
// 第一种调用 : 直接调用自定义call方法,传入函数
FunInterface_01.call(() -> {
System.out.println("HelloWorld!!!");
});
// 第二种调用 : 先创建函数对象,类似于实现接口的内部类对象
MyFunctionInter inter = () -> {
System.out.println("HelloWorld2!!!!");
};
// 调用这个实现的方法
inter.printMessage();
}
}
// 函数式接口
@FunctionalInterface
interface MyFunctionInter {
void printMessage();
}
2.3.2 有参情况
public class FunInterface_02 {
// 自定义静态方法,接收接口对象
public static void call(MyFunctionInter_02 func, String message) {
// 调用接口内的成员方法
func.printMessage(message);
}
public static void main(String[] args) {
// 调用需要传递的数据
String message = "有参函数式接口调用!!!";
// 第一种调用 : 直接调用自定义call方法,传入函数,并传入数据
FunInterface_02.call((str) -> {
System.out.println(str);
}, message);
// 第二种调用 : 先创建函数对象,类似于实现接口的内部类对象
MyFunctionInter_02 inter = (str) -> {
System.out.println(str);
};
// 调用这个实现的方法
inter.printMessage(message);
}
}
// 函数式接口
@FunctionalInterface
interface MyFunctionInter_02 {
void printMessage(String message);
}
2.4 JDK自带常用的函数式接口
2.4.1Supplier 接口
Supplier接口 代表结果供应商,所以有返回值,可以获取数据
有一个get方法,用于获取数据
public class _03_JdkOwn_01 {
private static String getResult(Supplier function) {
return function.get();
}
public static void main(String[] args) {
// 1
String before = "张三";
String after = "你好";
// 把两个字符串拼接起来
System.out.println(getResult(() -> before + after));
// 2 //创建Supplier容器，声明为_03_JdkOwn类型
// 此时并不会调用对象的构造方法，即不会创建对象
Supplier<_03_JdkOwn_01> sup = _03_JdkOwn_01::new;
_03_JdkOwn_01 jo1 = sup.get();
_03_JdkOwn_01 jo2 = sup.get();
}
public _03_JdkOwn_01() {
System.out.println("构造方法执行了");
}
}
package _02_Functions;
import java.util.function.Supplier;
public class _02_Functions {
public static void main(String[] args) {
String string = "张三";
String result = getResult(()->"我是 :"+ string);
System.out.println(result);
}
// f封装 完成指定功能
private static String getResult(Suppliersupplier) {
return supplier.get();
}
}
2.4.2Consumer 接口
Consumer 接口 消费者接口所以不需要返回值
有一个accept(T)方法,用于执行消费操作,可以对给定的参数T 做任意操作
public class _04_JdkOwn_02 {
private static void consumeResult(Consumer function, String message) {
function.accept(message);
}
public static void main(String[] args) {
// 传递的参数
String message = "消费一些内容!!!";
// 调用方法
consumeResult(result -> {
System.out.println(result);
}, message);
}
}
package _02_Functions;
import java.util.function.Consumer;
public class _01_Functions {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, };
// 常规遍历
for (int j : arr) {
System.out.println(j);
}
// 3. lambda 表达式
forEach(arr , (i)->System.out.println(i));
}
//封装的功能,完成遍历操作,但是需要传递数组,和要做的事
//该方法只是帮我们遍历而已
public static void forEach(int[] arr , Consumer c){
for(int i : arr){
c.accept(i);
}
}
}
2.4.3 FUnction 接口
Function 接口 , 表示接收一个参数并产生结果的函数
顾名思义,是函数操作的
有一个Rapply(T)方法,Function中没有具体的操作,具体的操作需要我们去为它指定,因此apply具体返回的结果取决于传入的lambda表达式
public class _05_JdkOwn_03 {
// Function<参数, 返回值>
public static void convertType(Function function,
String str) {
int num = function.apply(str);
System.out.println(num);
}
public static void main(String[] args) {
// 传递的参数
String str = "123";
// s是说明需要传递参数, 也可以写 (s)
convertType(s -> {
int sInt = Integer.parseInt(s);
return sInt;
}, str);
}
}
package _02_Functions;
import java.util.function.Function;
public class _03_Functions {
public static Integer m1(String string, Functionfun) {
return fun.apply(string);
}
public static void main(String[] args) {
String string = "123";
int result = m1(string , s->Integer.parseInt(s));
System.out.println(result);
}
}
2.4.4 Predicate 接口
public class _06_JdkOwn_04 {
// 自定义方法,并且 Predicate 接收String字符串类型
public static void call(Predicate predicate, String isOKMessage) {
boolean isOK = predicate.test(isOKMessage);
System.out.println("isOK吗：" + isOK);
}
public static void main(String[] args) {
// 传入的参数
String input = "ok";
call((String message) -> {
// 不区分大小写比较,是ok就返回true,否则返回false
if (message.equalsIgnoreCase("ok")) {
return true;
}
return false;
}, input);
}
}
3. 方法引用和构造器调用
3.1对象调用成员
package _03_FunCall;
import java.util.function.Supplier;
public class _01_FunCall {
public static void main(String[] args) {
Integer i1 = new Integer(123);
//常规lambda写法
Suppliersu = ()-> i1.toString();
System.out.println(su.get());
//方法引用写法
su = i1 :: toString;
System.out.println(su.get());
}
}
3.2类名调用成员
package _03_FunCall;
import java.util.function.BiFunction;
import java.util.function.Function;
public class _02_FunCall {
public static void main(String[] args) {
Function fun = Integer:: parseInt;
System.out.println(fun.apply("123"));
fun = new Function(){
@Override
public Integer apply(String t) {
return null;
}
};
fun = x-> Integer.parseInt(x);
fun = Integer::parseInt;
//前面两个是入参 , 第三个是返回值
//类名:: 静态
BiFunctionbif = Integer :: max;
}
//静态方法
public static void test(A a){
}
}
//接口
interface A{
public void m1(B b);
}
class B{}
3.3类名调用成员
package _03_FunCall;
import java.util.function.BiPredicate;
public class _03_FunCall {
public static void main(String[] args) {
//判断字符串是否相等
BiPredicate bp = String::equals;
System.out.println(bp.test("abc", "abc"));
}
}
3.4构造方法调用
package _01_Lambda;
import java.util.function.Function;
import java.util.function.Supplier;
public class _04_Constryctarcakk {
public static void main(String[] args) {
//无参构造
Supplier
3.5数组引用
package _01_Lambda;
import java.util.function.Function;
public class _05_ArrayCall {
public static void main(String[] args) {
Function function = Integer[] :: new;
Integer[] arr = function.apply(6);
for(Integer integer : arr){
System.out.println(integer);
}
}
}
4. StreamAPI
4.1 概念说明
数据渠道、管道 , 用于操作数据源(集合、数组等)所生成的元素序列
集合讲的是数据,流讲的是计算
即一组用来处理数组,集合的API
4.2特点
Stream 不是数据结构,没有内部存储,自己不会存储元素
Stream 不会改变源对象. 相反,他们会返回一个持有结果的新Stream
Stream 操作是延迟执行的.这意味着他们会等到需要结果的时候才执行
不支持索引访问
延迟计算
支持并行
很容易生成数据或集合
支持过滤, 查找 , 转换, 汇总, 聚合等操作
4.3应用场景
流式计算处理,需要延迟计算、更方便的并行计算
更灵活、简介的集合处理方式场景
4.4代码实现
4.4.1 运行机制说明
Stream分为源source , 中间操作,终止操作
流的源可以是一个数组,集合,生成器方法,I/O通道等等
一个流可以有零个或多个中间操作,每一个中间操作都会返回一个新的流,供下一个操作使用,一个流只会有一个终止操作
中间操作也称为算子-transformation
Stream 只有遇到终止操作,它的数据源会开始执行遍历操作
终止操作也称为动作算子-action
因为动作算子的返回值不再是 stream,所以这个计算就终止了
只有碰到动作算子的时候,才会真正的计算
4.4.2创建流的方式
package _04_Stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class _01_Stream {
public static void main(String[] args) {
//1. 数组转换位流
String[] strings = {"q","w","e","r"};
Stream streaml = Stream.of(strings);
System.out.println(streaml);
//java.util.stream.ReferencePipeline$Head@6d06d69c
//2. 通过集合
//Arrays.asList : 把数组转换位集合
Listlist = Arrays.asList(strings);
streaml=list.stream();
//3. 通过Stream的generate创建
//但是是一个无限流(无限大), 所以经常结合limit一起使用,来限制最大个数
//generate参数是一个Supplier , 而Supplier中有一个get方法用于获取数据
//而get方法的返回值,会作为数据保存到这个流中,下面程序也就意味着该流中的数据全部都是1
Streamstream2 = Stream.generate(()->1);
//limit 是中间操作,设置流的最大个数
//forEach 遍历 ,是终止操作
stream2.limit(5).forEach(x->System.out.println(x));
// 4. 通过String.iterate
//同上,是无限流
//参数1 是起始值 ,参数二是function , 有参有返回值
//x+2 等于 步长位二 for (int i =1; true ; i+=2)
Streamstreams = Stream.iterate(1, x->x+2);
streams.limit(10).forEach(x->System.out.println(x));
// 5 . 已有类的API
String string = "abc";
//string转为char类型 输出值位对应的ASCII值
IntStream chars = string.chars();
chars.forEach(x->System.out.println(x));
}
}
4.4.3 常见中间操作
4.4.4 常见的终止操作
public class FunInterface_01 {
// 自定义静态方法,接收接口对象
public static void call(MyFunctionInter func) {
// 调用接口内的成员方法
func.printMessage();
}
public static void main(String[] args) {
// 第一种调用 : 直接调用自定义call方法,传入函数
FunInterface_01.call(() -> {
System.out.println("HelloWorld!!!");
});
// 第二种调用 : 先创建函数对象,类似于实现接口的内部类对象
MyFunctionInter inter = () -> {
System.out.println("HelloWorld2!!!!");
};
// 调用这个实现的方法
inter.printMessage();
}
}
// 函数式接口
@FunctionalInterface
interface MyFunctionInter {
void printMessage();
}
2.3.2 有参情况
public class FunInterface_02 {
// 自定义静态方法,接收接口对象
public static void call(MyFunctionInter_02 func, String message) {
// 调用接口内的成员方法
func.printMessage(message);
}
public static void main(String[] args) {
// 调用需要传递的数据
String message = "有参函数式接口调用!!!";
// 第一种调用 : 直接调用自定义call方法,传入函数,并传入数据
FunInterface_02.call((str) -> {
System.out.println(str);
}, message);
// 第二种调用 : 先创建函数对象,类似于实现接口的内部类对象
MyFunctionInter_02 inter = (str) -> {
System.out.println(str);
};
// 调用这个实现的方法
inter.printMessage(message);
}
}
// 函数式接口
@FunctionalInterface
interface MyFunctionInter_02 {
void printMessage(String message);
}
2.4 JDK自带常用的函数式接口
2.4.1Supplier 接口
Supplier接口 代表结果供应商,所以有返回值,可以获取数据
有一个get方法,用于获取数据
public class _03_JdkOwn_01 {
private static String getResult(Supplier function) {
return function.get();
}
public static void main(String[] args) {
// 1
String before = "张三";
String after = "你好";
// 把两个字符串拼接起来
System.out.println(getResult(() -> before + after));
// 2 //创建Supplier容器，声明为_03_JdkOwn类型
// 此时并不会调用对象的构造方法，即不会创建对象
Supplier<_03_JdkOwn_01> sup = _03_JdkOwn_01::new;
_03_JdkOwn_01 jo1 = sup.get();
_03_JdkOwn_01 jo2 = sup.get();
}
public _03_JdkOwn_01() {
System.out.println("构造方法执行了");
}
}
package _02_Functions;
import java.util.function.Supplier;
public class _02_Functions {
public static void main(String[] args) {
String string = "张三";
String result = getResult(()->"我是 :"+ string);
System.out.println(result);
}
// f封装 完成指定功能
private static String getResult(Suppliersupplier) {
return supplier.get();
}
}
2.4.2Consumer 接口
Consumer 接口 消费者接口所以不需要返回值
有一个accept(T)方法,用于执行消费操作,可以对给定的参数T 做任意操作
public class _04_JdkOwn_02 {
private static void consumeResult(Consumer function, String message) {
function.accept(message);
}
public static void main(String[] args) {
// 传递的参数
String message = "消费一些内容!!!";
// 调用方法
consumeResult(result -> {
System.out.println(result);
}, message);
}
}
package _02_Functions;
import java.util.function.Consumer;
public class _01_Functions {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, };
// 常规遍历
for (int j : arr) {
System.out.println(j);
}
// 3. lambda 表达式
forEach(arr , (i)->System.out.println(i));
}
//封装的功能,完成遍历操作,但是需要传递数组,和要做的事
//该方法只是帮我们遍历而已
public static void forEach(int[] arr , Consumer c){
for(int i : arr){
c.accept(i);
}
}
}
2.4.3 FUnction 接口
Function 接口 , 表示接收一个参数并产生结果的函数
顾名思义,是函数操作的
有一个Rapply(T)方法,Function中没有具体的操作,具体的操作需要我们去为它指定,因此apply具体返回的结果取决于传入的lambda表达式
public class _05_JdkOwn_03 {
// Function<参数, 返回值>
public static void convertType(Function function,
String str) {
int num = function.apply(str);
System.out.println(num);
}
public static void main(String[] args) {
// 传递的参数
String str = "123";
// s是说明需要传递参数, 也可以写 (s)
convertType(s -> {
int sInt = Integer.parseInt(s);
return sInt;
}, str);
}
}
package _02_Functions;
import java.util.function.Function;
public class _03_Functions {
public static Integer m1(String string, Functionfun) {
return fun.apply(string);
}
public static void main(String[] args) {
String string = "123";
int result = m1(string , s->Integer.parseInt(s));
System.out.println(result);
}
}
2.4.4 Predicate 接口
public class _06_JdkOwn_04 {
// 自定义方法,并且 Predicate 接收String字符串类型
public static void call(Predicate predicate, String isOKMessage) {
boolean isOK = predicate.test(isOKMessage);
System.out.println("isOK吗：" + isOK);
}
public static void main(String[] args) {
// 传入的参数
String input = "ok";
call((String message) -> {
// 不区分大小写比较,是ok就返回true,否则返回false
if (message.equalsIgnoreCase("ok")) {
return true;
}
return false;
}, input);
}
}
3. 方法引用和构造器调用
3.1对象调用成员
package _03_FunCall;
import java.util.function.Supplier;
public class _01_FunCall {
public static void main(String[] args) {
Integer i1 = new Integer(123);
//常规lambda写法
Suppliersu = ()-> i1.toString();
System.out.println(su.get());
//方法引用写法
su = i1 :: toString;
System.out.println(su.get());
}
}
3.2类名调用成员
package _03_FunCall;
import java.util.function.BiFunction;
import java.util.function.Function;
public class _02_FunCall {
public static void main(String[] args) {
Function fun = Integer:: parseInt;
System.out.println(fun.apply("123"));
fun = new Function(){
@Override
public Integer apply(String t) {
return null;
}
};
fun = x-> Integer.parseInt(x);
fun = Integer::parseInt;
//前面两个是入参 , 第三个是返回值
//类名:: 静态
BiFunctionbif = Integer :: max;
}
//静态方法
public static void test(A a){
}
}
//接口
interface A{
public void m1(B b);
}
class B{}
3.3类名调用成员
package _03_FunCall;
import java.util.function.BiPredicate;
public class _03_FunCall {
public static void main(String[] args) {
//判断字符串是否相等
BiPredicate bp = String::equals;
System.out.println(bp.test("abc", "abc"));
}
}
3.4构造方法调用
package _01_Lambda;
import java.util.function.Function;
import java.util.function.Supplier;
public class _04_Constryctarcakk {
public static void main(String[] args) {
//无参构造
Supplier
3.5数组引用
package _01_Lambda;
import java.util.function.Function;
public class _05_ArrayCall {
public static void main(String[] args) {
Function function = Integer[] :: new;
Integer[] arr = function.apply(6);
for(Integer integer : arr){
System.out.println(integer);
}
}
}
4. StreamAPI
4.1 概念说明
数据渠道、管道 , 用于操作数据源(集合、数组等)所生成的元素序列
集合讲的是数据,流讲的是计算
即一组用来处理数组,集合的API
4.2特点
Stream 不是数据结构,没有内部存储,自己不会存储元素
Stream 不会改变源对象. 相反,他们会返回一个持有结果的新Stream
Stream 操作是延迟执行的.这意味着他们会等到需要结果的时候才执行
不支持索引访问
延迟计算
支持并行
很容易生成数据或集合
支持过滤, 查找 , 转换, 汇总, 聚合等操作
4.3应用场景
流式计算处理,需要延迟计算、更方便的并行计算
更灵活、简介的集合处理方式场景
4.4代码实现
4.4.1 运行机制说明
Stream分为源source , 中间操作,终止操作
流的源可以是一个数组,集合,生成器方法,I/O通道等等
一个流可以有零个或多个中间操作,每一个中间操作都会返回一个新的流,供下一个操作使用,一个流只会有一个终止操作
中间操作也称为算子-transformation
Stream 只有遇到终止操作,它的数据源会开始执行遍历操作
终止操作也称为动作算子-action
因为动作算子的返回值不再是 stream,所以这个计算就终止了
只有碰到动作算子的时候,才会真正的计算
4.4.2创建流的方式
package _04_Stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class _01_Stream {
public static void main(String[] args) {
//1. 数组转换位流
String[] strings = {"q","w","e","r"};
Stream streaml = Stream.of(strings);
System.out.println(streaml);
//java.util.stream.ReferencePipeline$Head@6d06d69c
//2. 通过集合
//Arrays.asList : 把数组转换位集合
Listlist = Arrays.asList(strings);
streaml=list.stream();
//3. 通过Stream的generate创建
//但是是一个无限流(无限大), 所以经常结合limit一起使用,来限制最大个数
//generate参数是一个Supplier , 而Supplier中有一个get方法用于获取数据
//而get方法的返回值,会作为数据保存到这个流中,下面程序也就意味着该流中的数据全部都是1
Streamstream2 = Stream.generate(()->1);
//limit 是中间操作,设置流的最大个数
//forEach 遍历 ,是终止操作
stream2.limit(5).forEach(x->System.out.println(x));
// 4. 通过String.iterate
//同上,是无限流
//参数1 是起始值 ,参数二是function , 有参有返回值
//x+2 等于 步长位二 for (int i =1; true ; i+=2)
Streamstreams = Stream.iterate(1, x->x+2);
streams.limit(10).forEach(x->System.out.println(x));
// 5 . 已有类的API
String string = "abc";
//string转为char类型 输出值位对应的ASCII值
IntStream chars = string.chars();
chars.forEach(x->System.out.println(x));
}
}
4.4.3 常见中间操作
4.4.4 常见的终止操作
2.4.1Supplier 接口
Supplier接口 代表结果供应商,所以有返回值,可以获取数据
有一个get方法,用于获取数据
public class _03_JdkOwn_01 {
private static String getResult(Supplier function) {
return function.get();
}
public static void main(String[] args) {
// 1
String before = "张三";
String after = "你好";
// 把两个字符串拼接起来
System.out.println(getResult(() -> before + after));
// 2 //创建Supplier容器，声明为_03_JdkOwn类型
// 此时并不会调用对象的构造方法，即不会创建对象
Supplier<_03_JdkOwn_01> sup = _03_JdkOwn_01::new;
_03_JdkOwn_01 jo1 = sup.get();
_03_JdkOwn_01 jo2 = sup.get();
}
public _03_JdkOwn_01() {
System.out.println("构造方法执行了");
}
}
package _02_Functions;
import java.util.function.Supplier;
public class _02_Functions {
public static void main(String[] args) {
String string = "张三";
String result = getResult(()->"我是 :"+ string);
System.out.println(result);
}
// f封装 完成指定功能
private static String getResult(Suppliersupplier) {
return supplier.get();
}
}
2.4.2Consumer 接口
Consumer 接口 消费者接口所以不需要返回值
有一个accept(T)方法,用于执行消费操作,可以对给定的参数T 做任意操作
public class _04_JdkOwn_02 {
private static void consumeResult(Consumer function, String message) {
function.accept(message);
}
public static void main(String[] args) {
// 传递的参数
String message = "消费一些内容!!!";
// 调用方法
consumeResult(result -> {
System.out.println(result);
}, message);
}
}
package _02_Functions;
import java.util.function.Consumer;
public class _01_Functions {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, };
// 常规遍历
for (int j : arr) {
System.out.println(j);
}
// 3. lambda 表达式
forEach(arr , (i)->System.out.println(i));
}
//封装的功能,完成遍历操作,但是需要传递数组,和要做的事
//该方法只是帮我们遍历而已
public static void forEach(int[] arr , Consumer c){
for(int i : arr){
c.accept(i);
}
}
}
2.4.3 FUnction 接口
Function 接口 , 表示接收一个参数并产生结果的函数
顾名思义,是函数操作的
有一个Rapply(T)方法,Function中没有具体的操作,具体的操作需要我们去为它指定,因此apply具体返回的结果取决于传入的lambda表达式
public class _05_JdkOwn_03 {
// Function<参数, 返回值>
public static void convertType(Function function,
String str) {
int num = function.apply(str);
System.out.println(num);
}
public static void main(String[] args) {
// 传递的参数
String str = "123";
// s是说明需要传递参数, 也可以写 (s)
convertType(s -> {
int sInt = Integer.parseInt(s);
return sInt;
}, str);
}
}
package _02_Functions;
import java.util.function.Function;
public class _03_Functions {
public static Integer m1(String string, Functionfun) {
return fun.apply(string);
}
public static void main(String[] args) {
String string = "123";
int result = m1(string , s->Integer.parseInt(s));
System.out.println(result);
}
}
2.4.4 Predicate 接口
public class _06_JdkOwn_04 {
// 自定义方法,并且 Predicate 接收String字符串类型
public static void call(Predicate predicate, String isOKMessage) {
boolean isOK = predicate.test(isOKMessage);
System.out.println("isOK吗：" + isOK);
}
public static void main(String[] args) {
// 传入的参数
String input = "ok";
call((String message) -> {
// 不区分大小写比较,是ok就返回true,否则返回false
if (message.equalsIgnoreCase("ok")) {
return true;
}
return false;
}, input);
}
}
3. 方法引用和构造器调用
3.1对象调用成员
package _03_FunCall;
import java.util.function.Supplier;
public class _01_FunCall {
public static void main(String[] args) {
Integer i1 = new Integer(123);
//常规lambda写法
Suppliersu = ()-> i1.toString();
System.out.println(su.get());
//方法引用写法
su = i1 :: toString;
System.out.println(su.get());
}
}
3.2类名调用成员
package _03_FunCall;
import java.util.function.BiFunction;
import java.util.function.Function;
public class _02_FunCall {
public static void main(String[] args) {
Function fun = Integer:: parseInt;
System.out.println(fun.apply("123"));
fun = new Function(){
@Override
public Integer apply(String t) {
return null;
}
};
fun = x-> Integer.parseInt(x);
fun = Integer::parseInt;
//前面两个是入参 , 第三个是返回值
//类名:: 静态
BiFunctionbif = Integer :: max;
}
//静态方法
public static void test(A a){
}
}
//接口
interface A{
public void m1(B b);
}
class B{}
3.3类名调用成员
package _03_FunCall;
import java.util.function.BiPredicate;
public class _03_FunCall {
public static void main(String[] args) {
//判断字符串是否相等
BiPredicate bp = String::equals;
System.out.println(bp.test("abc", "abc"));
}
}
3.4构造方法调用
package _01_Lambda;
import java.util.function.Function;
import java.util.function.Supplier;
public class _04_Constryctarcakk {
public static void main(String[] args) {
//无参构造
Supplier
3.5数组引用
package _01_Lambda;
import java.util.function.Function;
public class _05_ArrayCall {
public static void main(String[] args) {
Function function = Integer[] :: new;
Integer[] arr = function.apply(6);
for(Integer integer : arr){
System.out.println(integer);
}
}
}
4. StreamAPI
4.1 概念说明
数据渠道、管道 , 用于操作数据源(集合、数组等)所生成的元素序列
集合讲的是数据,流讲的是计算
即一组用来处理数组,集合的API
4.2特点
Stream 不是数据结构,没有内部存储,自己不会存储元素
Stream 不会改变源对象. 相反,他们会返回一个持有结果的新Stream
Stream 操作是延迟执行的.这意味着他们会等到需要结果的时候才执行
不支持索引访问
延迟计算
支持并行
很容易生成数据或集合
支持过滤, 查找 , 转换, 汇总, 聚合等操作
4.3应用场景
流式计算处理,需要延迟计算、更方便的并行计算
更灵活、简介的集合处理方式场景
4.4代码实现
4.4.1 运行机制说明
Stream分为源source , 中间操作,终止操作
流的源可以是一个数组,集合,生成器方法,I/O通道等等
一个流可以有零个或多个中间操作,每一个中间操作都会返回一个新的流,供下一个操作使用,一个流只会有一个终止操作
中间操作也称为算子-transformation
Stream 只有遇到终止操作,它的数据源会开始执行遍历操作
终止操作也称为动作算子-action
因为动作算子的返回值不再是 stream,所以这个计算就终止了
只有碰到动作算子的时候,才会真正的计算
4.4.2创建流的方式
package _04_Stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class _01_Stream {
public static void main(String[] args) {
//1. 数组转换位流
String[] strings = {"q","w","e","r"};
Stream streaml = Stream.of(strings);
System.out.println(streaml);
//java.util.stream.ReferencePipeline$Head@6d06d69c
//2. 通过集合
//Arrays.asList : 把数组转换位集合
Listlist = Arrays.asList(strings);
streaml=list.stream();
//3. 通过Stream的generate创建
//但是是一个无限流(无限大), 所以经常结合limit一起使用,来限制最大个数
//generate参数是一个Supplier , 而Supplier中有一个get方法用于获取数据
//而get方法的返回值,会作为数据保存到这个流中,下面程序也就意味着该流中的数据全部都是1
Streamstream2 = Stream.generate(()->1);
//limit 是中间操作,设置流的最大个数
//forEach 遍历 ,是终止操作
stream2.limit(5).forEach(x->System.out.println(x));
// 4. 通过String.iterate
//同上,是无限流
//参数1 是起始值 ,参数二是function , 有参有返回值
//x+2 等于 步长位二 for (int i =1; true ; i+=2)
Streamstreams = Stream.iterate(1, x->x+2);
streams.limit(10).forEach(x->System.out.println(x));
// 5 . 已有类的API
String string = "abc";
//string转为char类型 输出值位对应的ASCII值
IntStream chars = string.chars();
chars.forEach(x->System.out.println(x));
}
}
4.4.3 常见中间操作
4.4.4 常见的终止操作
Supplier
有一个get方法,用于获取数据
public class _03_JdkOwn_01 {
private static String getResult(Supplier function) {
return function.get();
}
public static void main(String[] args) {
// 1
String before = "张三";
String after = "你好";
// 把两个字符串拼接起来
System.out.println(getResult(() -> before + after));
// 2 //创建Supplier容器，声明为_03_JdkOwn类型
// 此时并不会调用对象的构造方法，即不会创建对象
Supplier<_03_JdkOwn_01> sup = _03_JdkOwn_01::new;
_03_JdkOwn_01 jo1 = sup.get();
_03_JdkOwn_01 jo2 = sup.get();
}
public _03_JdkOwn_01() {
System.out.println("构造方法执行了");
}
}
package _02_Functions;
import java.util.function.Supplier;
public class _02_Functions {
public static void main(String[] args) {
String string = "张三";
String result = getResult(()->"我是 :"+ string);
System.out.println(result);
}
// f封装 完成指定功能
private static String getResult(Suppliersupplier) {
return supplier.get();
}
}
2.4.2Consumer 接口
Consumer 接口 消费者接口所以不需要返回值
有一个accept(T)方法,用于执行消费操作,可以对给定的参数T 做任意操作
public class _04_JdkOwn_02 {
private static void consumeResult(Consumer function, String message) {
function.accept(message);
}
public static void main(String[] args) {
// 传递的参数
String message = "消费一些内容!!!";
// 调用方法
consumeResult(result -> {
System.out.println(result);
}, message);
}
}
package _02_Functions;
import java.util.function.Consumer;
public class _01_Functions {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, };
// 常规遍历
for (int j : arr) {
System.out.println(j);
}
// 3. lambda 表达式
forEach(arr , (i)->System.out.println(i));
}
//封装的功能,完成遍历操作,但是需要传递数组,和要做的事
//该方法只是帮我们遍历而已
public static void forEach(int[] arr , Consumer c){
for(int i : arr){
c.accept(i);
}
}
}
2.4.3 FUnction 接口
Function 接口 , 表示接收一个参数并产生结果的函数
顾名思义,是函数操作的
有一个Rapply(T)方法,Function中没有具体的操作,具体的操作需要我们去为它指定,因此apply具体返回的结果取决于传入的lambda表达式
public class _05_JdkOwn_03 {
// Function<参数, 返回值>
public static void convertType(Function function,
String str) {
int num = function.apply(str);
System.out.println(num);
}
public static void main(String[] args) {
// 传递的参数
String str = "123";
// s是说明需要传递参数, 也可以写 (s)
convertType(s -> {
int sInt = Integer.parseInt(s);
return sInt;
}, str);
}
}
package _02_Functions;
import java.util.function.Function;
public class _03_Functions {
public static Integer m1(String string, Functionfun) {
return fun.apply(string);
}
public static void main(String[] args) {
String string = "123";
int result = m1(string , s->Integer.parseInt(s));
System.out.println(result);
}
}
2.4.4 Predicate 接口
public class _06_JdkOwn_04 {
// 自定义方法,并且 Predicate 接收String字符串类型
public static void call(Predicate predicate, String isOKMessage) {
boolean isOK = predicate.test(isOKMessage);
System.out.println("isOK吗：" + isOK);
}
public static void main(String[] args) {
// 传入的参数
String input = "ok";
call((String message) -> {
// 不区分大小写比较,是ok就返回true,否则返回false
if (message.equalsIgnoreCase("ok")) {
return true;
}
return false;
}, input);
}
}
3. 方法引用和构造器调用
3.1对象调用成员
package _03_FunCall;
import java.util.function.Supplier;
public class _01_FunCall {
public static void main(String[] args) {
Integer i1 = new Integer(123);
//常规lambda写法
Suppliersu = ()-> i1.toString();
System.out.println(su.get());
//方法引用写法
su = i1 :: toString;
System.out.println(su.get());
}
}
3.2类名调用成员
package _03_FunCall;
import java.util.function.BiFunction;
import java.util.function.Function;
public class _02_FunCall {
public static void main(String[] args) {
Function fun = Integer:: parseInt;
System.out.println(fun.apply("123"));
fun = new Function(){
@Override
public Integer apply(String t) {
return null;
}
};
fun = x-> Integer.parseInt(x);
fun = Integer::parseInt;
//前面两个是入参 , 第三个是返回值
//类名:: 静态
BiFunctionbif = Integer :: max;
}
//静态方法
public static void test(A a){
}
}
//接口
interface A{
public void m1(B b);
}
class B{}
3.3类名调用成员
package _03_FunCall;
import java.util.function.BiPredicate;
public class _03_FunCall {
public static void main(String[] args) {
//判断字符串是否相等
BiPredicate bp = String::equals;
System.out.println(bp.test("abc", "abc"));
}
}
3.4构造方法调用
package _01_Lambda;
import java.util.function.Function;
import java.util.function.Supplier;
public class _04_Constryctarcakk {
public static void main(String[] args) {
//无参构造
Supplier
3.5数组引用
package _01_Lambda;
import java.util.function.Function;
public class _05_ArrayCall {
public static void main(String[] args) {
Function function = Integer[] :: new;
Integer[] arr = function.apply(6);
for(Integer integer : arr){
System.out.println(integer);
}
}
}
4. StreamAPI
4.1 概念说明
数据渠道、管道 , 用于操作数据源(集合、数组等)所生成的元素序列
集合讲的是数据,流讲的是计算
即一组用来处理数组,集合的API
4.2特点
Stream 不是数据结构,没有内部存储,自己不会存储元素
Stream 不会改变源对象. 相反,他们会返回一个持有结果的新Stream
Stream 操作是延迟执行的.这意味着他们会等到需要结果的时候才执行
不支持索引访问
延迟计算
支持并行
很容易生成数据或集合
支持过滤, 查找 , 转换, 汇总, 聚合等操作
4.3应用场景
流式计算处理,需要延迟计算、更方便的并行计算
更灵活、简介的集合处理方式场景
4.4代码实现
4.4.1 运行机制说明
Stream分为源source , 中间操作,终止操作
流的源可以是一个数组,集合,生成器方法,I/O通道等等
一个流可以有零个或多个中间操作,每一个中间操作都会返回一个新的流,供下一个操作使用,一个流只会有一个终止操作
中间操作也称为算子-transformation
Stream 只有遇到终止操作,它的数据源会开始执行遍历操作
终止操作也称为动作算子-action
因为动作算子的返回值不再是 stream,所以这个计算就终止了
只有碰到动作算子的时候,才会真正的计算
4.4.2创建流的方式
package _04_Stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class _01_Stream {
public static void main(String[] args) {
//1. 数组转换位流
String[] strings = {"q","w","e","r"};
Stream streaml = Stream.of(strings);
System.out.println(streaml);
//java.util.stream.ReferencePipeline$Head@6d06d69c
//2. 通过集合
//Arrays.asList : 把数组转换位集合
Listlist = Arrays.asList(strings);
streaml=list.stream();
//3. 通过Stream的generate创建
//但是是一个无限流(无限大), 所以经常结合limit一起使用,来限制最大个数
//generate参数是一个Supplier , 而Supplier中有一个get方法用于获取数据
//而get方法的返回值,会作为数据保存到这个流中,下面程序也就意味着该流中的数据全部都是1
Streamstream2 = Stream.generate(()->1);
//limit 是中间操作,设置流的最大个数
//forEach 遍历 ,是终止操作
stream2.limit(5).forEach(x->System.out.println(x));
// 4. 通过String.iterate
//同上,是无限流
//参数1 是起始值 ,参数二是function , 有参有返回值
//x+2 等于 步长位二 for (int i =1; true ; i+=2)
Streamstreams = Stream.iterate(1, x->x+2);
streams.limit(10).forEach(x->System.out.println(x));
// 5 . 已有类的API
String string = "abc";
//string转为char类型 输出值位对应的ASCII值
IntStream chars = string.chars();
chars.forEach(x->System.out.println(x));
}
}
4.4.3 常见中间操作
4.4.4 常见的终止操作
Consumer
有一个accept(T)方法,用于执行消费操作,可以对给定的参数T 做任意操作
public class _04_JdkOwn_02 {
private static void consumeResult(Consumer function, String message) {
function.accept(message);
}
public static void main(String[] args) {
// 传递的参数
String message = "消费一些内容!!!";
// 调用方法
consumeResult(result -> {
System.out.println(result);
}, message);
}
}
package _02_Functions;
import java.util.function.Consumer;
public class _01_Functions {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, };
// 常规遍历
for (int j : arr) {
System.out.println(j);
}
// 3. lambda 表达式
forEach(arr , (i)->System.out.println(i));
}
//封装的功能,完成遍历操作,但是需要传递数组,和要做的事
//该方法只是帮我们遍历而已
public static void forEach(int[] arr , Consumer c){
for(int i : arr){
c.accept(i);
}
}
}
2.4.3 FUnction
Function
顾名思义,是函数操作的
有一个Rapply(T)方法,Function中没有具体的操作,具体的操作需要我们去为它指定,因此apply具体返回的结果取决于传入的lambda表达式
public class _05_JdkOwn_03 {
// Function<参数, 返回值>
public static void convertType(Function function,
String str) {
int num = function.apply(str);
System.out.println(num);
}
public static void main(String[] args) {
// 传递的参数
String str = "123";
// s是说明需要传递参数, 也可以写 (s)
convertType(s -> {
int sInt = Integer.parseInt(s);
return sInt;
}, str);
}
}
package _02_Functions;
import java.util.function.Function;
public class _03_Functions {
public static Integer m1(String string, Functionfun) {
return fun.apply(string);
}
public static void main(String[] args) {
String string = "123";
int result = m1(string , s->Integer.parseInt(s));
System.out.println(result);
}
}
2.4.4 Predicate 接口
public class _06_JdkOwn_04 {
// 自定义方法,并且 Predicate 接收String字符串类型
public static void call(Predicate predicate, String isOKMessage) {
boolean isOK = predicate.test(isOKMessage);
System.out.println("isOK吗：" + isOK);
}
public static void main(String[] args) {
// 传入的参数
String input = "ok";
call((String message) -> {
// 不区分大小写比较,是ok就返回true,否则返回false
if (message.equalsIgnoreCase("ok")) {
return true;
}
return false;
}, input);
}
}
3. 方法引用和构造器调用
3.1对象调用成员
package _03_FunCall;
import java.util.function.Supplier;
public class _01_FunCall {
public static void main(String[] args) {
Integer i1 = new Integer(123);
//常规lambda写法
Suppliersu = ()-> i1.toString();
System.out.println(su.get());
//方法引用写法
su = i1 :: toString;
System.out.println(su.get());
}
}
3.2类名调用成员
package _03_FunCall;
import java.util.function.BiFunction;
import java.util.function.Function;
public class _02_FunCall {
public static void main(String[] args) {
Function fun = Integer:: parseInt;
System.out.println(fun.apply("123"));
fun = new Function(){
@Override
public Integer apply(String t) {
return null;
}
};
fun = x-> Integer.parseInt(x);
fun = Integer::parseInt;
//前面两个是入参 , 第三个是返回值
//类名:: 静态
BiFunctionbif = Integer :: max;
}
//静态方法
public static void test(A a){
}
}
//接口
interface A{
public void m1(B b);
}
class B{}
3.3类名调用成员
package _03_FunCall;
import java.util.function.BiPredicate;
public class _03_FunCall {
public static void main(String[] args) {
//判断字符串是否相等
BiPredicate bp = String::equals;
System.out.println(bp.test("abc", "abc"));
}
}
3.4构造方法调用
package _01_Lambda;
import java.util.function.Function;
import java.util.function.Supplier;
public class _04_Constryctarcakk {
public static void main(String[] args) {
//无参构造
Supplier
3.5数组引用
package _01_Lambda;
import java.util.function.Function;
public class _05_ArrayCall {
public static void main(String[] args) {
Function function = Integer[] :: new;
Integer[] arr = function.apply(6);
for(Integer integer : arr){
System.out.println(integer);
}
}
}
4. StreamAPI
4.1 概念说明
数据渠道、管道 , 用于操作数据源(集合、数组等)所生成的元素序列
集合讲的是数据,流讲的是计算
即一组用来处理数组,集合的API
4.2特点
Stream 不是数据结构,没有内部存储,自己不会存储元素
Stream 不会改变源对象. 相反,他们会返回一个持有结果的新Stream
Stream 操作是延迟执行的.这意味着他们会等到需要结果的时候才执行
不支持索引访问
延迟计算
支持并行
很容易生成数据或集合
支持过滤, 查找 , 转换, 汇总, 聚合等操作
4.3应用场景
流式计算处理,需要延迟计算、更方便的并行计算
更灵活、简介的集合处理方式场景
4.4代码实现
4.4.1 运行机制说明
Stream分为源source , 中间操作,终止操作
流的源可以是一个数组,集合,生成器方法,I/O通道等等
一个流可以有零个或多个中间操作,每一个中间操作都会返回一个新的流,供下一个操作使用,一个流只会有一个终止操作
中间操作也称为算子-transformation
Stream 只有遇到终止操作,它的数据源会开始执行遍历操作
终止操作也称为动作算子-action
因为动作算子的返回值不再是 stream,所以这个计算就终止了
只有碰到动作算子的时候,才会真正的计算
4.4.2创建流的方式
package _04_Stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class _01_Stream {
public static void main(String[] args) {
//1. 数组转换位流
String[] strings = {"q","w","e","r"};
Stream streaml = Stream.of(strings);
System.out.println(streaml);
//java.util.stream.ReferencePipeline$Head@6d06d69c
//2. 通过集合
//Arrays.asList : 把数组转换位集合
Listlist = Arrays.asList(strings);
streaml=list.stream();
//3. 通过Stream的generate创建
//但是是一个无限流(无限大), 所以经常结合limit一起使用,来限制最大个数
//generate参数是一个Supplier , 而Supplier中有一个get方法用于获取数据
//而get方法的返回值,会作为数据保存到这个流中,下面程序也就意味着该流中的数据全部都是1
Streamstream2 = Stream.generate(()->1);
//limit 是中间操作,设置流的最大个数
//forEach 遍历 ,是终止操作
stream2.limit(5).forEach(x->System.out.println(x));
// 4. 通过String.iterate
//同上,是无限流
//参数1 是起始值 ,参数二是function , 有参有返回值
//x+2 等于 步长位二 for (int i =1; true ; i+=2)
Streamstreams = Stream.iterate(1, x->x+2);
streams.limit(10).forEach(x->System.out.println(x));
// 5 . 已有类的API
String string = "abc";
//string转为char类型 输出值位对应的ASCII值
IntStream chars = string.chars();
chars.forEach(x->System.out.println(x));
}
}
4.4.3 常见中间操作
4.4.4 常见的终止操作
public class _06_JdkOwn_04 {
// 自定义方法,并且 Predicate 接收String字符串类型
public static void call(Predicate predicate, String isOKMessage) {
boolean isOK = predicate.test(isOKMessage);
System.out.println("isOK吗：" + isOK);
}
public static void main(String[] args) {
// 传入的参数
String input = "ok";
call((String message) -> {
// 不区分大小写比较,是ok就返回true,否则返回false
if (message.equalsIgnoreCase("ok")) {
return true;
}
return false;
}, input);
}
}
3. 方法引用和构造器调用
3.1对象调用成员
package _03_FunCall;
import java.util.function.Supplier;
public class _01_FunCall {
public static void main(String[] args) {
Integer i1 = new Integer(123);
//常规lambda写法
Suppliersu = ()-> i1.toString();
System.out.println(su.get());
//方法引用写法
su = i1 :: toString;
System.out.println(su.get());
}
}
3.2类名调用成员
package _03_FunCall;
import java.util.function.BiFunction;
import java.util.function.Function;
public class _02_FunCall {
public static void main(String[] args) {
Function fun = Integer:: parseInt;
System.out.println(fun.apply("123"));
fun = new Function(){
@Override
public Integer apply(String t) {
return null;
}
};
fun = x-> Integer.parseInt(x);
fun = Integer::parseInt;
//前面两个是入参 , 第三个是返回值
//类名:: 静态
BiFunctionbif = Integer :: max;
}
//静态方法
public static void test(A a){
}
}
//接口
interface A{
public void m1(B b);
}
class B{}
3.3类名调用成员
package _03_FunCall;
import java.util.function.BiPredicate;
public class _03_FunCall {
public static void main(String[] args) {
//判断字符串是否相等
BiPredicate bp = String::equals;
System.out.println(bp.test("abc", "abc"));
}
}
3.4构造方法调用
package _03_FunCall;
import java.util.function.Supplier;
public class _01_FunCall {
public static void main(String[] args) {
Integer i1 = new Integer(123);
//常规lambda写法
Suppliersu = ()-> i1.toString();
System.out.println(su.get());
//方法引用写法
su = i1 :: toString;
System.out.println(su.get());
}
}
3.2类名调用成员
package _03_FunCall;
import java.util.function.BiFunction;
import java.util.function.Function;
public class _02_FunCall {
public static void main(String[] args) {
Function fun = Integer:: parseInt;
System.out.println(fun.apply("123"));
fun = new Function(){
@Override
public Integer apply(String t) {
return null;
}
};
fun = x-> Integer.parseInt(x);
fun = Integer::parseInt;
//前面两个是入参 , 第三个是返回值
//类名:: 静态
BiFunctionbif = Integer :: max;
}
//静态方法
public static void test(A a){
}
}
//接口
interface A{
public void m1(B b);
}
class B{}
3.3类名调用成员
package _03_FunCall;
import java.util.function.BiPredicate;
public class _03_FunCall {
public static void main(String[] args) {
//判断字符串是否相等
BiPredicate bp = String::equals;
System.out.println(bp.test("abc", "abc"));
}
}
3.4构造方法调用
package _03_FunCall;
import java.util.function.BiPredicate;
public class _03_FunCall {
public static void main(String[] args) {
//判断字符串是否相等
BiPredicate bp = String::equals;
System.out.println(bp.test("abc", "abc"));
}
}
3.4构造方法调用
package _01_Lambda;
import java.util.function.Function;
import java.util.function.Supplier;
public class _04_Constryctarcakk {
public static void main(String[] args) {
//无参构造
Supplier
3.5数组引用
package _01_Lambda;
import java.util.function.Function;
public class _05_ArrayCall {
public static void main(String[] args) {
Function function = Integer[] :: new;
Integer[] arr = function.apply(6);
for(Integer integer : arr){
System.out.println(integer);
}
}
}
4. StreamAPI
4.1 概念说明
4.1 概念说明
数据渠道、管道 , 用于操作数据源(集合、数组等)所生成的元素序列
集合讲的是数据,流讲的是计算
即一组用来处理数组,集合的API
4.2特点
Stream 不是数据结构,没有内部存储,自己不会存储元素
Stream 不会改变源对象. 相反,他们会返回一个持有结果的新Stream
Stream 操作是延迟执行的.这意味着他们会等到需要结果的时候才执行
不支持索引访问
延迟计算
支持并行
很容易生成数据或集合
支持过滤, 查找 , 转换, 汇总, 聚合等操作
4.3应用场景
流式计算处理,需要延迟计算、更方便的并行计算
更灵活、简介的集合处理方式场景
4.4代码实现
4.4.1 运行机制说明
Stream分为源source , 中间操作,终止操作
流的源可以是一个数组,集合,生成器方法,I/O通道等等
一个流可以有零个或多个中间操作,每一个中间操作都会返回一个新的流,供下一个操作使用,一个流只会有一个终止操作
中间操作也称为算子-transformation
Stream 只有遇到终止操作,它的数据源会开始执行遍历操作
终止操作也称为动作算子-action
因为动作算子的返回值不再是 stream,所以这个计算就终止了
只有碰到动作算子的时候,才会真正的计算
