Java基础——方法引用

1.方法引用格式

方法引用符： ：：
引用原则：可推到的即可省略的

public class InterfaceDemo {
    public static void main(String[] args) {
//        useInterface(s-> System.out.println(s));
        //方法引用
        useInterface(System.out::print);
    }
    public static void useInterface(MyInterface myI){
        myI.show("Use Inteface");
    }
}

2.Lambda表达式支持的方法引用

2.1引用类方法

注：lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

public class ConvertDemo {
    public static void main(String[] args) {
        //用lambda表达式
        useconvert(s->Integer.parseInt(s));
        //用方法引用，这里是引用的类中的静态方法
        useconvert(Integer::parseInt);
    }
    public static void useconvert(Covert c) {
        System.out.println(c.convert("666"));
    }
}

2.2引用对象的实例方法

public class PrintDemo {
    public static void main(String[] args) {
        //用lambda表达式
        usePrint(s-> System.out.println(s.toUpperCase()));
        //用引用对象实例方法
        PrintString p = new PrintString();
        usePrint(p::printUpper);//这里PrintString继承Print的类并重写了printUpper方法
    }
    public static void usePrint(Print p){
        p.printUpper("BALBALA");
    }
}

2.3引用类的实例方法

public class MyStringDemo {
    public static void main(String[] args) {
        //lambd表达式
        useMyString((s,beginning,end)-> s.substring(beginning,end));
        //引用类中的实例方法
        useMyString(String::substring);
        //lambda被类的实例方法替代的时候
        //第一个参数作为调用者
        //其余参数全部传递给该方法作为参数
    }
    public static void useMyString(MyString ms){
        System.out.println(ms.mySubString("HelloBala",0,5));
    }
}

2.3引用构造器

public class StudentDemo {
    public static void main(String[] args) {
        //lambda方法
        useStudentBuilder((name,age)-> new Student(name,age));
        //引用构造器
        useStudentBuilder(Student::new);
        //lambda表达式被构造器替代时，它的形式参数全部传递给构造器作为参数
    }

    public static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("Bala",23);
        System.out.println(s.getName()+","+s.getAge());
    }
}

3.函数式接口

函数式接口注解：@FunctionalInterface

@FunctionalInterface
public interface MyInterface {
    void show(String s);
}

注意：如果方法的返回是一个函数式接口，我们可以使用lambda表达式作为结果返回

private static Comparator<String> getComparator(){
	return(s1,s2)->s1.length-s2.length;
}

supplier接口(get)

get()方法，不需要参数，但有返回(可返回任意类型)

public class UseSupplier {
    public static void main(String[] args) {
        System.out.println(useget(()->"使用Supplier"));
    }

    public static String useget(Supplier<String> s) {
        return s.get();
    }
}

public class UseSupplier {
    public static void main(String[] args) {
        int []num = {1,3,9,2,0,4,2};
        System.out.println(getMax(()->{
            int max = -100;
            for(int i: num){
                if(i > max){
                    max = i;
                }
            }
            return max;
        }));
    }

    public static Integer getMax(Supplier<Integer> s) {
        return s.get();
    }
}

Consumer接口(accept)

accept()方法，需要1个参数，无返回

public class UseCosumer {
    public static void main(String[] args) {
        useConsumer("Balala",s -> System.out.println(s));

        //两个
        useConsumer("Balala",s-> System.out.println(s),s-> System.out.println(new StringBuffer(s).reverse().toString()));

    }
    private static void useConsumer(String s, Consumer<String> con1, Consumer<String> con2){
        con1.accept(s);
        con2.accept(s);
        //也可以用Consumer的另外一个方法调用
        con1.andThen(con2).accept(s);
    }
    private static void useConsumer(String s, Consumer<String> con1){
        con1.accept(s);
    }
}

Predicate接口(test)

public class usePredicate {
    public static void main(String[] args) {
        System.out.println(usePredicate("compute",s->s.length() > 8));
    }
    private static boolean usePredicate(String s, Predicate<String> p){
//        return p.test(s);
        return p.negate().test(s);  //取函数的逻辑非
    }
}

短路与和短路或：

public class usePredicate {
    public static void main(String[] args) {
        System.out.println(usePredicate("compute",s->s.length() > 8, s->s.length() < 8));
    }
    private static boolean usePredicate(String s, Predicate<String> p1, Predicate<String> p2){
        //返回短路与
        //return (p1.test(s) && p2.test(s));
        //可改为下
        return p1.and(p2).test(s);

		//返回短路或
        //return (p1.test(s) || p2.test(s));
        //可改为下
        return p1.or(p2).test(s);
    }
}

Function接口（apply）

返回值与参数的类型不同，可用于转化

public class FunctionDemo {
    public static void main(String[] args) {
        useFunction("234",s->Integer.parseInt(s));
        useFunction(100,i->String.valueOf(i+100));
        useFunction(1000,i->String.valueOf(i),s -> Integer.parseInt(s));
    }
    //字符串转整型
    private static void useFunction(String s, Function<String,Integer> f1){
        int integer = f1.apply(s);
        System.out.println(integer);
    }
    //整型转字符串
    private static void useFunction(Integer i,Function<Integer,String> f1){
        String s = f1.apply(i);
        System.out.println(s);
    }
    //整数转字符串再转整数类型
    private static void useFunction(Integer i,Function<Integer,String> f1,Function<String,Integer> f2){
        /*String s = f1.apply(i);
        Integer i1 = f2.apply(s);
        System.out.println(i1);*/
        //可换为andthen
        Integer i1 = f1.andThen(f2).apply(i);
        System.out.println(i1);
    }
}