Lambda表达式和Stream流

第一章.函数式编程思想和Lambda表达式定义格式

1.面向对象思想:重点是找对象,调用对象中的方法帮我们去做事儿,侧重点在找对象
2.函数式编程思想:对面向对象思想进一步简化,不注重过程,只注重结果3.定义格式:()->{}():重写方法的参数位置->:将参数传递到方法体中{}:重写方法的方法体

public class Test01 {public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println("我到达朝鲜了");}}).start();System.out.println("=============================");new Thread(()-> System.out.println("我到达朝鲜了")).start();}
}

第二章.Lambda表达式使用前提

使用前提：a.必须要重写方法b.必须要有函数式接口做方法传递参数函数式接口：接口中必须有且只能有一个抽象方法检测函数式接口：在接口上面@FunctionalInterface

第三章.Lambda表达式省略规则

1.重写方法的参数类型可以省略
2.如果重写方法的参数只有一个，所在的小括号可以省略
3.如果方法体只有一句代码 ，所在的大括号可以省略
4.如果方法体中只有一句代码,所在的大括号可以省略之外,那一句代码后面的;可以省略如果带return,return也可以省略

第四章.函数式接口

使用Lambda表达式前提:函数式接口做方法参数传递

1.定义格式

1.概述:接口中必须有且只能有一个抽象方法
2.如何验证该接口是否为函数式接口:@FunctionalInterface3.定义格式:@FunctionalInterfacepublic interface 接口名{抽象方法}

2.基本使用

@FunctionalInterface
public interface USB {void open(String s);}

public class Test01 {public static void main(String[] args) {method(new USB() {@Overridepublic void open(String s) {System.out.println(s+"打开了");}});System.out.println("=========Lambda========");method((String s)-> {System.out.println(s+"打开了");});System.out.println("=========Lambda最终写法========");method(s-> System.out.println(s+"打开了"));}public static void method(USB usb){usb.open("鼠标");}
}

3.Supplier

1.Supplier接口java.util.function.Supplier<T>接口，它意味着"供给"->我们想要什么就给什么
2.方法:T get()3.需求:使用Supplier接口作为方法的参数用Lambda表达式求出int数组中的最大值

public class Test01_Supplier {public static void main(String[] args) {method(new Supplier<Integer>() {@Overridepublic Integer get() {int[] arr = {3,2,5,3,6,7};Arrays.sort(arr);return arr[arr.length-1];}});System.out.println("========Lambda========");method(()-> {int[] arr = {3,2,5,3,6,7};Arrays.sort(arr);return arr[arr.length-1];});}public static void method(Supplier<Integer> supplier){Integer result = supplier.get();System.out.println("result = " + result);}
}

4.Consumer

java.util.function.Consumer<T>->消费型接口方法:void accept(T t)，意为消费一个指定泛型的数据"消费"即使"操作"

public class Test02_Consumer {public static void main(String[] args) {method(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s.toUpperCase());}},"abcdefg");System.out.println("========Lambda=========");method((String s)-> {System.out.println(s.toUpperCase());},"abcdefg");System.out.println("========Lambda最终写法=========");method(s-> System.out.println(s.toUpperCase()),"abcdefg");}public static void method(Consumer<String> consumer,String s){consumer.accept(s);}
}

5.Function

java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据方法:R apply(T t)根据类型T参数获取类型R的结果

public class Test03_Function {public static void main(String[] args) {method(new Function<Integer, String>() {@Overridepublic String apply(Integer integer) {return integer+"";}},100);System.out.println("=============Lambda表达式============");method((Integer integer)-> {return integer+"";},100);System.out.println("=============Lambda表达式最终写法============");method(integer-> integer+"",100);}public static void method(Function<Integer,String> function,Integer integer){String result = function.apply(integer);System.out.println("result = " + result);}
}

6.Predicate

java.util.function.Predicate<T>接口。->判断型接口boolean test(T t)->用于判断的方法,返回值为boolean型

public class Test04_Predicate {public static void main(String[] args) {method(new Predicate<String>() {@Overridepublic boolean test(String s) {return s.length()==5;}},"abcdefg");System.out.println("=======Lambda========");method((String s)-> {return s.length()==5;},"abcdefg");System.out.println("=======Lambda最终写法========");method(s-> s.length()==5,"abcdefg");}public static void method(Predicate<String> predicate,String s){boolean test = predicate.test(s);System.out.println("test = " + test);}
}

第五章.Stream流介绍,以及初体验

public class Test01_Stream {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("张三丰子");//将姓"张"的留下来 -> 过滤ArrayList<String> list1 = new ArrayList<>();for (String s : list) {if (s.startsWith("张")){list1.add(s);}}System.out.println(list1);//获取名字为三个字的ArrayList<String> list2 = new ArrayList<>();for (String s : list1) {if (s.length()==3){list2.add(s);}}System.out.println(list2);//输出,遍历list2for (String s : list2) {System.out.println(s);}System.out.println("============================");Stream<String> stream = list.stream();/*stream.filter(new Predicate<String>() {@Overridepublic boolean test(String s) {return s.startsWith("张");}}).filter(new Predicate<String>() {@Overridepublic boolean test(String s) {return s.length()==3;}}).forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});*/stream.filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));}
}

第六章.Stream的获取

1.Stream中的forEach方法:void forEach(Consumer<? super T> action);

把数组放在stream流中遍历

1.针对数组static Stream<T> of(T... values)  2.针对集合->单列集合default Stream<E> stream()

public class Test02_Stream {public static void main(String[] args) {/*1.针对数组static Stream<T> of(T... values)*/Stream<String> stream1 = Stream.of("林昌", "鹤洋", "郭乾", "凯旋", "晓鹏");/*2.针对集合->单列集合default Stream<E> stream()  */ArrayList<String> list = new ArrayList<>();list.add("流川枫");list.add("樱木");list.add("三井寿");Stream<String> stream2 = list.stream();}
}

2.Stream中的long count()方法

1.作用:统计元素个数
2注意:count方法是一个终结方法

public class Test04_Count {public static void main(String[] args) {Stream<String> stream = Stream.of("越前龙马", "不二周助", "手冢国光", "桃城武");long count = stream.count();System.out.println("count = " + count);}
}

3.Stream中的Stream filter(Predicate<? super T> predicate)方法

1.方法:Stream<T> filter(Predicate<? super T> predicate)方法,返回一个新的Stream流对象
2.作用:根据某个条件进行元素过滤
3.注意:过滤,不是干掉,而是将符合条件的元素留下

public class Test05_Filter {public static void main(String[] args) {Stream<String> stream = Stream.of("张三丰", "张无忌", "张翠山", "殷素素", "殷天正", "张无忌他舅");//获取姓张的/* Stream<String> stream1 = stream.filter(new Predicate<String>() {@Overridepublic boolean test(String s) {return s.startsWith("张");}});stream1.forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});*//* stream.filter(new Predicate<String>() {@Overridepublic boolean test(String s) {return s.startsWith("张");}}).forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});*/System.out.println("=============");stream.filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));}
}

4.Stream limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象

1.Stream<T> limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象

public class Test06_Limit {public static void main(String[] args) {Stream<String> stream = Stream.of("张三丰", "张无忌", "张翠山", "殷素素", "殷天正", "张无忌他舅");stream.limit(3).forEach(s -> System.out.println(s));}
}

5.Stream skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象

Stream<T> skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象

public class Test06_Skip {public static void main(String[] args) {Stream<String> stream = Stream.of("张三丰", "张无忌", "张翠山", "殷素素", "殷天正", "张无忌他舅");stream.skip(3).forEach(s -> System.out.println(s));}
}

6.static Stream concat(Stream<? extends T> a, Stream<? extends T> b):两个流合成一个流

1.方法:static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b):两个流合成一个流

public class Test08_Concat {public static void main(String[] args) {Stream<String> stream1 = Stream.of("张三丰", "张无忌", "张翠山", "殷素素", "殷天正", "张无忌他舅");Stream<Integer> stream2 = Stream.of(1,2,3,4);Stream.concat(stream1,stream2).forEach(s -> System.out.println(s));}
}

7.将Stream流变成集合

从Stream流对象转成集合对象，使用Stream接口方法collect

public class Test09_Collect {public static void main(String[] args) {Stream<String> stream1 = Stream.of("张三丰", "张无忌", "张翠山", "殷素素", "殷天正", "张无忌他舅","张无忌");//List<String> list = stream1.collect(Collectors.toList());//System.out.println(list);Set<String> set = stream1.collect(Collectors.toSet());System.out.println(set);}
}

Stream流使用场景:1.如果我们要对集合或者数组中的元素进行层层筛选,我们就可以使用Stream流对象2.我们用Stream流筛完之后,我们还要变成集合对象

8.Stream流练习

   1. 第一个队伍只要名字为3个字的成员姓名；//filter2. 第一个队伍筛选之后只要前3个人；//limit3. 第二个队伍只要姓张的成员姓名；//filter4. 第二个队伍筛选之后不要前2个人；//skip5. 将两个队伍合并为一个队伍；//concat6. 打印整个队伍的姓名信息。//forEach

public class Test10_Stream {public static void main(String[] args) {List<String> one = new ArrayList<>();one.add("迪丽热巴");one.add("宋远桥");one.add("苏星河");one.add("老子");one.add("庄子");one.add("孙子");one.add("洪七公");List<String> two = new ArrayList<>();two.add("古力娜扎");two.add("张无忌");two.add("张三丰");two.add("赵丽颖");two.add("张二狗");two.add("张天爱");two.add("张三");//将两个集合变成Stream流Stream<String> streamA = one.stream();Stream<String> streamB = two.stream();Stream<String> stream1 = streamA.filter(s -> s.length() == 3).limit(3);Stream<String> stream2 = streamB.filter(s -> s.startsWith("张")).skip(2);//合并Stream.concat(stream1,stream2).forEach(s -> System.out.println(s));}
}

第八章.方法引用

一.方法引用的介绍

1.概述:在Lambda表达式的基础上再次简化
2.注意:使用场景很局限
3.使用场景:a.方法引用代码,必须在重写的方法中写b.引用的方法要和所在的重写的方法从参数上,返回值值上一致(类型,个数)
4.方法引用:在lambda表达式的基础上,干掉重写方法的参数和箭头以及引用方法的参数都干掉然后将.换成::

二.方法引入的体验

public class Test01 {public static void main(String[] args) {method(new Supplier<String>() {/*1.toUpperCase()在重写的get方法中2.toUpperCase()和重写的get方法从参数上,返回值上都一致3.可以用方法引用*/@Overridepublic String get() {return "abcdefg".toUpperCase();}});System.out.println("=========方法引用==========");method("abcdefg"::toUpperCase);//method("abcdefg"::length);}public static void method(Supplier<String> supplier){String s = supplier.get();System.out.println(s);}
}

三.对象名–引用成员方法

1.使用对象名引用成员方法
2.格式:对象::成员方法名

public class Test02 {public static void main(String[] args) {method(new Supplier<String>() {/*1.要引用的trim无参数,返回值类型String2.所在的get方法,无参,返回值类型String3.所以,要引用的trim方法和get从参数上,返回值上一样,可以引用*/@Overridepublic String get() {return " abc ".trim();}});System.out.println("=========Lambda========");method(()-> " abc ".trim());System.out.println("=========方法引用========");method(" abc "::trim);}public static void method(Supplier<String> supplier){String s = supplier.get();System.out.println(s);}
}

四.类名–引用静态方法

1.格式:类名::静态方法

public class Test03 {public static void main(String[] args) {method(new Supplier<Double>() {/*1.要引用的方法random()返回值类型为double,无参数2.重写的get方法返回值类型double,无参数3.所以可以引用random()*/@Overridepublic Double get() {return Math.random();}});System.out.println("============Lambda===========");method(()-> Math.random());System.out.println("============方法引用===========");method(Math::random);}public static void method(Supplier<Double> supplier){Double aDouble = supplier.get();System.out.println("aDouble = " + aDouble);}
}

五.类–构造引用

1.格式: 类名 对象名 = new 构造方法名()构造方法名::new

public class Test04 {public static void main(String[] args) {method(new Function<String, Person>() {/*1.Person(s)是一个构造方法,此方法有参数,而且是String,返回值Person对象2.apply,是重写的方法,有参数,类型为String,返回值为Person对象3.所以构造方法可以引用*/@Overridepublic Person apply(String s) {return new Person(s);//return new Person("柳岩")}},"柳岩");System.out.println("=========Lambda==========");method(s-> new Person(s)//return new Person("柳岩"),"柳岩");System.out.println("=========方法引用==========");method(Person::new,"柳岩");}public static void method(Function<String,Person> function,String name){Person person = function.apply(name);System.out.println(person);}
}

六.数组–数组引用

1.格式:数组的数据类型[]::new比如:int[]::new  创建一个int型的数组

public class Test05 {public static void main(String[] args) {method(new Function<Integer, int[]>() {/*[]看做是方法的()[]中的长度看做是方法的参数1.要引用的数组有"参数",返回值类型为int[]2.apply方法参数类型为int有参数,返回值类型为int[]3.所以可以引用数组*/@Overridepublic int[] apply(Integer integer) {return new int[integer];}},10);System.out.println("=============Lambda=============");method(integer-> new int[integer],10);System.out.println("=====方法引用=======");method(int[]::new,10);}public static void method(Function<Integer,int[]> function,int length){int[] arr = function.apply(length);System.out.println(arr.length);}
}

Lambda表达式和Stream流相关推荐

Lambda表达式和Stream流式编程
写在前面 IDEA都默认是jdk11了,我这还写着jdk8的新特性呢,惭愧惭愧.其实在学校的时候,基本没咋用过Lambda表达式和Stream流式编程,但是在实习的时候,发现公司的代码好多这样写的,没 ...
JDK8新特性简介、Lambda表达式、Stream流常用api介绍
JDK8新特性简介.Lambda表达式.Stream流常用api介绍接口 Java1.8前接口中是不允许有普通方法的,在Java1.8后允许接口中有普通方法,只需要加上default关键字即可: J ...
Lambda表达式，Stream流，方法引用，Base64（JDK8新特性）
Labda表达式 Lambda表达式演示 Lanbda表达式:是JDK1.8提出的一种新语法.是对之前的某种情况的代码的"简化写法". Lambda表达式演示: public cl ...
函数式编程[Lambda 表达式,Optional,Stream流]从入门到精通(一)
文章目录函数式编程.stream流 1.概述 1.1 学习目的 1.2 函数式编程思想 2.lambda表达式 2.1 概述 2.2 省略规则 3. stream流 3.1 概述 3.2 功能 3. ...
Java函数式编程（Lambda表达式、Stream流用法）
函数式编程 1.函数式编程思想 1.1.1 概念面向对象思想需要关注用什么对象完成什么事情.而函数式编程思想就类似于我们数学中的函数.它主要关注的是对数据进行了什么操作. 1.1.2 优点代码 ...
定时器、Lambda表达式、Stream流
一.定时器 * 定时器Timer类:在java.util包下!线程调度任务以供将来在后台线程中执行的功能. 任务可以安排一次执行,或者定期重复执行.* 构造方法:Timer() 创建一个新的计时器.* ...
JDK8新特性：Lambda表达式、Stream流、日期时间工具类
重要特性: 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值. 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号. 可选的大括号:如果主体包含了一个语句,就不需要大括号. ...
Springboot中Lambda表达式与Stream流
一.基础 1.函数式接口 (1)使用@FunctionalInterface注解标记的接口,接口中有且只有一个抽象方法. 实例: /*** 自定义函数接口*/ @FunctionalInterface ...
Java8函数式编程(Lambda表达式，Stream流，Optional)
目录一.函数式编程思想二.lambda表达式 1.概念 2.Lambda表达式对接口的要求编辑编辑编辑 3.Lambda表达式的语法 4.函数引用 4.1引用一个静态方法 4.2引用一个非 ...

Lambda表达式和Stream流

第一章.函数式编程思想和Lambda表达式定义格式

第二章.Lambda表达式使用前提

第三章.Lambda表达式省略规则

第四章.函数式接口

1.定义格式

2.基本使用

3.Supplier

4.Consumer

5.Function

6.Predicate

第五章.Stream流介绍,以及初体验

第六章.Stream的获取

1.Stream中的forEach方法:void forEach(Consumer<? super T> action);

2.Stream中的long count()方法

3.Stream中的Stream filter(Predicate<? super T> predicate)方法

4.Stream limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象

5.Stream skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象

6.static Stream concat(Stream<? extends T> a, Stream<? extends T> b):两个流合成一个流

7.将Stream流变成集合

8.Stream流练习

第八章.方法引用

一.方法引用的介绍

二.方法引入的体验

三.对象名–引用成员方法

四.类名–引用静态方法

五.类–构造引用

六.数组–数组引用

Lambda表达式和Stream流相关推荐

最新文章

热门文章