一、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添加私有的方法
特点:
私有的普通方法只能是默认方法来进行调用
私有的静态的方法 可以使用 默认方法 与静态方法调用
代码
package day24.test;
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.例子
package day24.test;
public class Test03 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public 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();
}
测试类
package day24.test;
public class Test04 {
public static void main(String[] args) {
show(()->{
System.out.println("lamba表达式测试成功");
});
}
public static void show(Inner inner){
inner.showInfo();
}
}
7.带返回使用lambda表达式
package day24.test;
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>() {
@Override
public int compare(Stundent o1, Stundent o2) {
return o1.getAge()-o2.getAge();
}
});*/
Arrays.sort(stundents,(Stundent o1,Stundent o2)->{
return o1.getAge()-o2.getAge();
});
System.out.println(Arrays.toString(stundents));
}
}
9.自定义一个带参数带返回值的方法
接口
package day24.test;
public interface Inner01 {
public int showInfo(int num1,int num2);
}
测试类
package day24.test;
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.Inner
public static int show (int num1,int num2,Inner01 inner01){
return inner01.showInfo(num1,num2);
}
}
10.Lambda表达式简化方法
第一种情况 如果括号中只有一个参数 可以省略括号 和数据类型
第二种情况 方法体只有一句话 大括号和分号可以省略
第三种情况 方法体只有一句话 就是retrun 可以省略大括号 分号 retrun
package day24.test;
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.作为返回值
package day24.type;
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.println(Arrays.toString(arrays));
}
/*private static Comparator<String> getCon() {
return new Comparator<String>() {
@Override
public 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表达式可以忽略这个形参
package day24.type;
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) {
return sup.get();
}
}
3.求出数组中最大值
package day24.type;
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) {
return sup.get();
}
}
五、Consumer:消费型接口
1.void accept(T t) 消费的方法 具体消费什么 由自己进行设置
2.default Consumer andThen(Consumer<? super T> after) 可以连接多个消费型接口 可
以进行多次消费
类型接口.andThen(类型接口).类型接口方法
3.案例 消费一个字符 打印其结果
就是写一个方法体,没有return的
package day24.type;
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.案例 对一个字符串进行两次消费 第一次消费 转换为大写 第二次消费转换为小写
package day24.type;
import java.util.function.Consumer;
public class Test12 {
public static void main(String[] args) {
shoeInfo("aBc",(String s)->{
System.out.println(s.toUpperCase());
},(String s)->{
System.out.println(s.toLowerCase());
});
}
private static void shoeInfo(String str, Consumer<String> con1,
Consumer<String> con2) {
con1.andThen(con2).accept(str);
}
}
5.案例 将一个字符串的数组 String [] arrays={“张三:30”,“李四:20”,“王五:10”} ==>
package day24.type;
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 条件判断表达式
package day24.type;
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)->{
return s.contains("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) {
return pre.test(s);
}
}
6.案例
package day24.type;
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) {
return pre1.negate().test(s);
}
}
7.案例:定义一个字符数组 String[] str={“杨一”,“杨二”,“杨三”,“迪一二三”};
获取到数组 名字包含 迪 并且长度 ==4 数组 存入集合中 == > 打印输出集合
分析:
定义一个方法 返回值的是集合 参数 数组 两个断言式接口
判断是否满足这个条件 满足这个条件存入到集合
代码:
package day24.type;
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)->{
return s.contains("迪");
});
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 数据
package day24.type;
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
package day24.type;
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.使用方法
代码
package day24.type;
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){
if(s.contains("张")){
list2.add(s);
}
}
//长度大于=3
List<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)->{
return s.contains("张");
}).filter((String s)->{
return s.length()>=3;
}).forEach((String s)->{
System.out.println(s);
});*/
list1.stream().filter((String s)->s.contains("张"))
.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流对象
代码
package day24.type;
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();
//获取所有的值x
Collection<String> con = map.values();
s.stream();
con.stream();
}
}
6.方法的使用
package day24.type;
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});
Stream.concat(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;
}
@Override
public 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));*/
/*Stream.concat(stre1,stre2).map((String s)->{return new Person(s);})
.forEach((Person p)-> System.out.println(p));*/
List<Person> personList = new ArrayList<>();
Stream.concat(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));
}
}