java笔记--jdk8新特性

函数式接口

---

有且仅有一个抽象方法的接口，适用于Lambda

格式：
修饰符 interface 接口名称{
publi abstract 返回值类型 方法名称（可选参数信息）；
}

@FunctionalInterface//注解，可以检测接口是否是一个函数式接口
public interface MyFunctionalInterface{
public abstract void method();//定义一个抽象方法
}

public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{
@override
public void method{
System.out.println("使用实现类里重写的方法");
}
}

public class Demo{
public static void show(MyFunctionalInterface meInter){
myInter.method;
}
public static void main(String[] args){
show(new MyFunctionalInterfaceImpl());//当方法参数是接口的时候，直接new上它的实现类

show(new MyFunctionalInterface(){
@override
public void method(){
System.out.println("使用匿名内部类重写接口中的抽象方法");
}
});

show(()->{
System.out.println("使用Lambda表达式重写接口中的抽象方法");})；
//Lambda简化后
show(()->System.out.println("使用Lambda表达式重写接口中的抽象方法"))；
}
}

函数式编程

---

Lambda的延迟执行

@FunctionalInterface
public interface MessadeBuilder{
public abstract String builderMessage();
}

//使用Lambda表达式，前提是存在函数式接口
public class Demo02Lambda{
public static void show(int level,MessadeBuilder mb){
	String msg1="Hello";
	String msg2="World";
	String msg3="Java";

    System.out.println(mb.builderMessage());
}
    public static void main(String[] args) {
    show(1,()->{
        return msg1+msg2+msg3;
    });
    }
}

常用函数式接口

---

Supplier接口
用来获取一个泛型参数指定类型的对象数据
java.util.function.Supplier接口包含一个无参的方法：T get()
默认方法：andThen

public class DemoSupplier{
public static String getString(Supplier<String> sup){
return sup.get();
}
public static void main(String[] args){
String s=getString(()-> "阿巴阿巴"
//因为只有一行代码，可以进行优化
);
System.out.println(s);//阿巴阿巴
}
}

Consumer接口
java.util.function.Caonsumer用于消费数据
抽象方法：void accept(T t)

public class DemoConsumer{
public static void method(String name,Consumer<String> con){
con,accept(name);
}
public static void main(String[] args){
method("阿巴阿巴",()->{
 String str=new StringBuffer(name).reverse().toString();
 System.out.println(str);//反转字符串
});
}
}

方法andThen
需要两个Consumer接口，再进行消费，谁写前面谁先消费

public claa DemoAndThen{
public static void method(String s,Consumer<String> con1,Consumer<String> con2){
	con1.andThen(con2).accept(s);//不用写成con1.accpet(s);con2.accpet(s);
}
public static void main(String[] args){
method("Hello",
(t)->{
System.out.println(t.toUpperCase);
},
(t)->{
System.out.println(t.toLowerCase);
});
}
}

public class DemoTest{
public static void method(String str1,String str2,Consumer con1,Consumer con2){
con1.accept;
con2.acceot;
}
public static void main(String[] args){
String[] arr={"迪丽热巴，女","古力娜扎，女","马尔扎哈，男"};

}
}

Predicate接口
java.util.function.Predicate
包含一个抽象方法：boolean test(T t);

public class DemoPredicate{
public static boolean checkString(String s,Predicate<String s,Predicate<String> pre){
return pre.test(s);
}
public static void main(String[] args){
String s="abcde":
boolean b=checkString(s,(String str)->{
return str.length()>5;
});
System.out.println(b);
}
}

默认方法：and;可以用于连接两个判断条件(相当于&&)

public class Demo02Predicate{
public static boolean checkString(String s,Predicate<String s,Predicate<String> pre1，Predicate<String> pre2){
return pre1.and(pre2).test(s);
}
public static void main(String[] args){
String s="abcde":
boolean b=checkString(s,(String str)->{
return str.length()>5;
},(String str)->{
return str.contains("a");
});
System.out.println(b);
}
}

默认方法：or;可以用于连接两个判断条件 (相当于||)
默认方法：negate，表示取反
Function接口
java.util.function.Function<T,R>;//把T的数据类型转化为R的数据类型
主要抽象方法：R apply(T t);

public class DemoFunction{
public static void method(String s,Function<String,Inteder> fun){
Integer in=fun.apply(s);
System.out.println(in);
}
public static void main(String[] args){
String s="1234";
method(s,(String str)->{
return Integer.parseInt(str);
});
}
}

默认方法：andThen;//用来进行组合操作

Stream流
关注做什么，不是怎么做
属于管道流，只能被消费一次

list.stream().filter(name->name.startsWith("张"))
.filter(name->name.length()==3)
.forEach(name->System.out.println(name));

获取流

---

1.使用Collection单列集合，可以通过stream默认方法获取流
2.Stream接口的静态方法of

常用方法
延迟方法：返回值类型仍是Stream接口自身类型的方法，支持链式调用
终结方法：返回值类型不再是Stream接口自身类型的方法，不支持链式调用（如count和forEach）

forEach

void forEach(Consumer<? super T> action);//用来遍历流中的数据

count:统计个数

long count();

filter(过滤)

Stream<T> filter(Predicate<? super T> predicate);

map:映射

把一种类型的数据转换为另外按一种类型的数据
Stream map(Function<? super T,? extends R>mapper);
limit:用于截取流中的元素

Stream<T> limit(long maxSize);

skip:跳过前几个

Stream<T> skip(long n);

concat:组合

static <T> Stream<T> concat(Stream<? extends  T> a,Stream<? extends T> b);

方法引用

---

例如System.out.println,System.out对象已经存在，println方法也存在

双冒号::为引用运算符，它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者

1.通过对象名引用成员方法

Demo demo=new Demo();
method(demo::print);//print是成员方法

2.通过类名称引用静态方法

method(Math::abs);

3.通过super引用父类的成员方法

method(super::methodFather);//methodFather是父类中的方法

4.通过this引用本类的成员方法

method(this::methodSon)//methodSon是子类的成员方法;

5.类的构造器引用

method(Person::new);//Person是一个类

6.数组的构造器引用

method(int[]::new);