Java基础24 Lambda表达式及省略写法 Steam流函数式接口

阅读：评论：0

一、jdk8&jdk9接口的特性

1.概念：在jdk1.8 之后接口中不仅可以有抽象方法还可以存在其他的成员方法
2.添加的方法
jdk8 增加默认方法与静态方法
jdk9 增加私有的方法
3.影响
接口中不仅只有抽象方法还有普通的方法缩短接口与抽象类之间的差别,接口是可以多继承的
所以以后的趋势接口可能替代抽象类
4.默认方法
概述 默认方法就是使用 default关键字来进行修饰方法
语法：
访问修饰符 default 返回值类型方法名称(参数列表) { 方法体 }
特点：
接口中默认方法是不能是直接进行调用需要通过实例化来进行调用
接口中的默认方法没有强制要求重写可以进行重写
接口中的普通方法不能使用重载
接口的实现类中的其它方法可以调用接口中默认方法
调用的语法:接口的名称.super.方法的名称()
定义接口代码

public interface Inner {
public default void showInfo(){
System.out.println("哈哈");
}
}

实现类代码

public class Impl implements Inner{
@Override
public void showInfo() {
Inner.super.showInfo();
System.out.println("aaaaaa");
}
}

测试类

public class Test {
public static void main(String[] args) {
Inner in = new Impl();
in.showInfo();
}
}

5.静态的方法
1.概念：在jdk1.8 之后可以有静态的方法
2.特点：
接口中的静态方法可以直接通过接口的名称来直接进行调用实现类不能调用接口静态方法
不同的接口中可以定义相同名字的静态方法互不影响
3.代码

就是静态方法直接通过类名调用，接口也算特殊的类
接口1

public interface Inner {
public static void showInfo(){
System.out.println("我是接口的静态方法");
}
}

接口2

public interface Inner1 {
public static void showInfo(){
System.out.println("我是潘金莲 我有药");
}
}

实现类

public class Impl implements Inner,Inner1 {
}

测试类

public class Test {
public static void main(String[] args) {Inner.showInfo();Inner1.showInfo();
}
}

jdk9
概念：jdk9添加私有的方法
特点：
私有的普通方法只能是默认方法来进行调用
私有的静态的方法可以使用默认方法与静态方法调用
代码

st;public interface Inner4 {/* private void show1(){System.out.println("私有的方法");}jdk1.9 才可以*/public default void  show2(){}/*private static void show3(){System.out.println("私有静态方法");}jdk1.9 才可以*/public static void show4(){}}

二、Lambda表达式

1.本质：本质就是一个接口 == > 就是一个匿名的接口
2.前提条件：必须是函数式接口也就是接口中只能有一个抽象方法默认方法与其它方法都是可以
存在的
3.作用:简化匿名内部类(匿名接口)的写法 匿名接口即相当于实例化接口的实现类，需重写接口的方法
4.语法：
(参数) ->{方法体}
（）==>接口中方法的参数
-> 是Lambda 表示特有的语法指向方法体
{} ==> 就是方法体执行的操作
5.例子

st;public class Test03 {public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}}).start();//使用lamdba表达式new Thread(()->{System.out.println(Thread.currentThread().getName());}).start();}
}

6.自定义没有返回值接口使用lambda表达式
接口

public interface Inner {
public void showInfo();
}

测试类

st;public class Test04 {public static void main(String[] args) {show(()->{System.out.println("lamba表达式测试成功");});}public static void show(Inner inner){inner.showInfo();}}

7.带返回使用lambda表达式

st;import java.util.Arrays;public class Test05 {public static void main(String[] args) {Stundent [] stundents = new Stundent[3];stundents[0] = new Stundent("张三",20);stundents[1] =new Stundent("李四",18);stundents[2] =new Stundent("王五",25);/*Arrays.sort(stundents, new Comparator<Stundent>() {@Overridepublic int compare(Stundent o1, Stundent o2) {Age()-o2.getAge();}});*/Arrays.sort(stundents,(Stundent o1,Stundent o2)->{Age()-o2.getAge();});System.out.String(stundents));}
}

9.自定义一个带参数带返回值的方法
接口

st;public interface Inner01 {public int showInfo(int num1,int num2);
}

测试类

st;public class Test06 {public static void main(String[] args) {int sum = show(10,20,(int num1,int num2)->{return num1+num2;}) ;System.out.println(sum);}
//Multiple non-overriding abstract methods found in interface day24.Innerpublic static int show (int num1,int num2,Inner01 inner01){return inner01.showInfo(num1,num2);}
}

10.Lambda表达式简化方法
第一种情况如果括号中只有一个参数可以省略括号和数据类型
第二种情况方法体只有一句话大括号和分号可以省略
第三种情况方法体只有一句话就是retrun 可以省略大括号分号 retrun

st;public class Test07 {public static void main(String[] args) {show(5,(int num)->{System.out.println(num);});show(5,num -> {System.out.println(num);});show(5,num -> System.out.println(num));//Arrays.sort(students,(Student o1, Student o2)-> o1.getAge()-o2.getAge());}public static void show(int num,Inner02 inner){inner.showInfo(num);}
}

三、函数式接口

1.函数式接口只有一个抽象方法的接口就是函数式接口可以有默认方法与静态方法
2.函数式接口一般会使用一个注解来进行约束
@FunctionalInterface 用于来检查是否是函数式接口
3.代码
@FunctionalInterface
public interface Inner {
public void show();
public default void show1(){
};
}
4.函数式接口两种体现形式
第一种作为方法的参数
第二种作为方法的返回值
5.代码作为方法的参数
接口

@FunctionalInterface
public interface Inner {
public void show();
}

测试类

public class Test {
public static void main(String[] args) {
showInfo(()-> System.out.println("哈哈哈哈"));
}
public static void showInfo(Inner in){
in.show();
}
}

6.作为返回值

pe;import java.util.Arrays;
import java.util.Comparator;public class Test08 {public static void main(String[] args) {String [] arrays ={"aa","a","aaaaa","aacv"};Arrays.sort(arrays,getCon());System.out.String(arrays));}/*private static Comparator<String> getCon() {return new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.length()-o2.length();}};}*/private static Comparator<String> getCon() {return (String o1, String o2)->o1.length()-o2.length();}}

四、Supplier：供给型接口

1.T get() 获取一个结果
2.例子、
函数式接口独有省略，Supplier sup 等各种类型接口形参，在使用lambda表达式可以忽略这个形参

pe;import java.util.function.Supplier;public class Test09 {public static void main(String[] args) {//这是怎么省略的？供给型接口独有省略？函数式接口独有省略，Supplier<String> sup 等各种类型接口形参，在使用lambda表达式可以忽略这个形参String str = showInfo(()->"我是张三");System.out.println(str);}private static String showInfo(Supplier<String> sup) {();}
}

3.求出数组中最大值

pe;import java.util.function.Supplier;public class Test10 {public static void main(String[] args) {Integer sum = getMax(()->{//定义一个数组Integer [] nums={20,30,40,90,60};//定义变量来记录其最大的值int max=nums[0];for (Integer i : nums) {if(i>max){max=i;}}return max;});System.out.println(sum);}private static Integer getMax(Supplier<Integer> sup) {();}
}

五、Consumer：消费型接口

1.void accept(T t) 消费的方法具体消费什么由自己进行设置
2.default Consumer andThen(Consumer<? super T> after) 可以连接多个消费型接口可
以进行多次消费
类型接口.andThen(类型接口).类型接口方法
3.案例消费一个字符打印其结果
就是写一个方法体，没有return的

pe;import java.util.function.Consumer;public class Test11 {public static void main(String[] args) {showInfo("顺哥",(String s)->{System.out.println(s.substring(0,1));});}private static void showInfo(String str, Consumer<String> con) {con.accept(str);}
}

4.案例对一个字符串进行两次消费第一次消费转换为大写第二次消费转换为小写

pe;import java.util.function.Consumer;public class Test12 {public static void main(String[] args) {shoeInfo("aBc",(String s)->{System.out.UpperCase());},(String s)->{System.out.LowerCase());});}private static void shoeInfo(String str, Consumer<String> con1,Consumer<String> con2) {con1.andThen(con2).accept(str);}
}

5.案例将一个字符串的数组 String [] arrays={“张三:30”,“李四:20”,“王五:10”} ==>

pe;import java.util.function.Consumer;public class Test13 {public static void main(String[] args) {showInfo(new String[]{"张三:30","李四:20","王五:10"},(String s)->{System.out.print("姓名:"+s.split(":")[0]+",");},(String s)->{System.out.print("年龄:"+s.split(":")[1]+" ");});}private static void showInfo(String[] arrays, Consumer<String> con1,Consumer<String> con2) {for (String s : arrays) {con1.andThen(con2).accept(s);}}
}

六 Predicate：断言型接口

1.boolean test(T t) 主要用于做判断
2.default Predicate and(Predicate<? super T> other) 用于连接两个断言型接口 and
&& 并且
3.default Predicate or(Predicate<? super T> other)用于连接两个断言型接口 or
|| 或者
4.ddefault Predicate negate() ！非
5.案例
使用断言型接口来判断一个字符串的长度是否大于5
使用断言型接口来判断一个字符串的长度是否大于5 字符串中包含a
就是写一个方法体，有return的，且return 条件判断表达式

pe;import java.util.function.Predicate;public class Test14 {public static void main(String[] args) {boolean flag = isFlag("dfss",(String s)->{return s.length()>5;});System.out.println(flag);boolean flag1 =isFlag1("bcderff",(String s)->{return s.length()>5;},(String s)->{ains("a");});System.out.println(flag1);}private static boolean isFlag1(String s, Predicate<String> pre1,Predicate<String> pre2) {return pre1.and(pre2).test(s);}private static boolean isFlag(String s, Predicate<String> pre) {st(s);}
}

6.案例

pe;import java.util.function.Predicate;public class Test15 {public static void main(String[] args) {boolean flag= isFlag("abcdefgh",(String s)->{return s.length() >5;});System.out.println(flag);}private static boolean isFlag(String s, Predicate<String> pre1) {ate().test(s);}
}

7.案例:定义一个字符数组 String[] str={“杨一”,“杨二”,“杨三”,“迪一二三”};
获取到数组名字包含迪并且长度 ==4 数组存入集合中 == > 打印输出集合
分析：
定义一个方法返回值的是集合参数数组两个断言式接口
判断是否满足这个条件满足这个条件存入到集合
代码：

pe;import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;public class Test16 {public static void main(String[] args) {String[] str ={"杨一","杨二","杨三","迪一二三"};List<String> li = getList(str,(String s)->{return s.length()==4;},(String s)->{ains("迪");});System.out.println(li);}private static List<String> getList(String [] arrays, Predicate<String> pre1,Predicate<String> pre2) {List<String> list = new ArrayList<String>();for (String s : arrays) {if(pre1.and(pre2).test(s)){list.add(s);}}return list;}
}

七、Function<T, R>：函数型接口

1.Function<T, R> 主要是用于来转换
T==> 表示被转换的类型
R==>表示转换的类型
2.方法
default Function<T,V> andThen(Function<? super R,? extends V> after)
用于连接两个函数型的接口
R apply(T t) ==> 用于来做转换
3.定义一个字符串需要使用函数型的接口转换为Integer类型载将Interger类型转换字符串类型
就是写一个方法体，有return的，且return 数据

pe;import java.util.function.Function;public class Test17 {public static void main(String[] args) {String num =show("123",(String s)->{return Integer.parseInt(s);},(Integer n)->{return n+" ";});System.out.println(num);}private static String show(String s, Function<String,Integer> fun1,Function<Integer,String> fun2) {return fun1.andThen(fun2).apply(s);}
}

4.定义一个字符串 String str=“123 刘正武” ==>123 Function函数型接口
==>第一次是将String 转换为 String
第二次将String 转换为 int

pe;import java.util.function.Function;public class Test18 {public static void main(String[] args) {Integer count =showInfo("123 顺哥加油",(String s)->{return s.split(" ")[0];},(String s)->{return Integer.parseInt(s);});System.out.println(count);}private static Integer showInfo(String s, Function<String,String> fun1,Function<String,Integer> fun2) {return fun1.andThen(fun2).apply(s);}}

八、Stream流

1.概念: Stream 是一个接口 Stream 接口的作用就类似于流水线工厂的作用
2.作用:主要用于对数据进行过滤
与Predicate：断言型接口类似
3.主要提供两类方法延迟方法终结方法
延迟方法: 调用方法之后返回值还是Stream流对象还可以继续进行操作
终结方法: 调用方法之后返回值不是Stream流对象不可以再调用Strea流对象的方法
4.使用方法

代码


pe;import java.util.ArrayList;
import java.util.List;public class Test19 {//第一个对象 向集合中添加 数据//把集合的姓名包含张 过滤出来//把名字的长度 大于=3 过滤出来//对集合进行遍历输出public static void main(String[] args) {List<String> list1 = new ArrayList<>();list1.add("张三丰");list1.add("张无忌");list1.add("大张三");list1.add("赵敏");list1.add("灭绝师太");list1.add("顺哥");//定义一个新的集合来进行存储List<String> list2 =new ArrayList<>();for (String s : list1){ains("张")){list2.add(s);}}//长度大于=3List<String> list3 = new ArrayList<>();for (String s1 : list2){if (s1.length()>=3){list3.add(s1);}}//对集合进行遍历for(String s: list3){System.out.println(s);}/*list1.stream().filter((String s)->{ains("张");}).filter((String s)->{return s.length()>=3;}).forEach((String s)->{System.out.println(s);});*/list1.stream().filter((String s)-&ains("张")).filter((String s)->s.length()>=3).forEach(s-> System.out.println(s));}
}

5.获取到Stream对象
default Stream stream() == 将集合转换为Stream 的对象集合必须是Collection的子
类
static Stream of(T… values) 将指定的元素转化为Stream流对象
代码

pe;import java.util.*;
import java.util.stream.Stream;public class Test20 {public static void main(String[] args) {List<String> list =new ArrayList<>();list.add("张三");list.add("李四");Stream<String> stre = list.stream();stre.forEach((String s)->{System.out.println(s);});Stream<Integer> s1 = Stream.of(new Integer[]{20,80,90,300});s1.forEach((Integer n)-> System.out.println(n));//map集合可以转换Stream对象 不能直接转换Stream 间接的进行转换//将键和值分别转为单独的集合，然后就集合使用原理Map<String,String> map = new HashMap<>();map.put("admin","123456");map.put("username","23456");Set<String> s = map.keySet();//获取所有的值xCollection<String> con = map.values();s.stream();con.stream();}
}

6.方法的使用

pe;import java.util.stream.Stream;public class Test21 {public static void main(String[] args) {// Stream<T> filter(Predicate<? super T> predicate)//void forEach(Consumer<? super T> action)Stream.of(new Integer[]{3,20,40,60,80,90}).filter((Integer n)-> {return  n>80;}).forEach(n-> System.out.println(n));// <R> Stream<R> map(Function<? super T,? extends R> mapper)Stream.of(new String [] {"11","22","33","44","55"}).map((String n)->{return  Integer.parseInt(n);}).forEach((Integer n)->{System.out.println(n+" ");});System.out.println("");//long count()System.out.println(Stream.of(new String[]{"11","22","33"}).count());//Stream<T> skip(long n)Stream.of(new String[]{"11","22","33","44","55"}).skip(3).forEach(s-> System.out.println(s));//static <T> Stream<T> concat(Stream<? extends T> a,Stream<? extends T>b)// Stream.of(new Integer[]{3,20,40,60,80,90}).concat()System.out.println("=======");Stream<Integer> str1 = Stream.of(new Integer[]{3,20,40,60,80,90});Stream<Integer> str2 = Stream.of(new Integer[]{100,101,102,103,104,105});at(str1,str2).forEach(n-> System.out.println(n));}
}

案例

package day24.work;public class Person {private String name;public Person() {}public Person(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Person{" +"name='" + name + ''' +'}';}
}

Stream筛选只要三个用limit(3) 不要前三个要后面所有的skip(3) 转类型 map(（原来的数据类型形参名）->{ retrun 将原来数据类型转为其他类型的代码语句}) 例 map((String n)->{return new Person(n); 极简省略 map(n->new Person(n));
list 类型筛选用subList(i,j) 包头不包尾同String 的subString用法

package day24.work;import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;public class Work {public static void main(String[] args) {List<String> list1 =new ArrayList<>();List<String> list2 =new ArrayList<>();list1.add("宫本武藏");list1.add("苏一二");list1.add("宋一明");list1.add("石头人");list1.add("时一二");list1.add("李耳");list1.add("庄子");list1.add("洪七公");list2.add("帕瓦一二");list2.add("张三丰");list2.add("赵薇薇");list2.add("张一二");list2.add("波尔至济南铁一二");list2.add("张一二");list2.add("张翠花");Stream<String> stre1 = list1.stream().filter((String s) -> s.length() == 3).limit(3);/*.forEach(s -> System.out.println(s));*/Stream<String> stre2 = list2.stream().filter((String s) -> s.contains("张")).skip(2);/*.forEach(s -> System.out.println(s));*//*at(stre1,stre2).map((String s)->{return new Person(s);}).forEach((Person p)-> System.out.println(p));*/List<Person> personList = new ArrayList<>();at(stre1,stre2).map((String n)->{return new Person(n);}).forEach((Person p)->{personList.add(p);});System.out.println(personList);//至臻极简版list1.stream().filter(s-> s.length() == 3).limit(3).forEach(s -> System.out.println(s));list2.stream().filter(s-> s.contains("张")).skip(2).forEach(s -> System.out.println(s));list1.stream().filter(s-> s.length() == 3).limit(3).map(s -> new Person(s)).forEach(s -> System.out.println(s));}
}

本文发布于:2024-02-01 21:47:40，感谢您对本站的认可！

本文链接：https://www.4u4v.net/it/170679526239621.html

上一篇：hadoop4.3

下一篇：思维导图0.0

标签：表达式写法函数接口基础

留言与评论（共有 0 条评论）

Java基础24 Lambda表达式及省略写法 Steam流 函数式接口