学Java的第十六天

 

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

public class demo {
    public static void main(String[] args) {
        MyInterface my = ()-> System.out.println("函数式接口");
        my.show();

    }
}

 

public class demo {
    public static void main(String[] args) {
       //匿名内部类的方式
        startTread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });
        //lambda表达式
        startTread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));
    }
    private static void startTread(Runnable r){
        new Thread(r).start();
    }
}

 

public class Comparator {
    public static void main(String[] args) {
        //定义集合，储存字符串元素
        ArrayList<String> array = new ArrayList<String>();
        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");
        System.out.println("排序前:"+array);
        Collections.sort(array,getComparator());
        System.out.println("排序后:"+array);

    }
    private static java.util.Comparator<String> getComparator() {
    //匿名内部类
        return (s1, s2) -> s1.length() - s2.length();
    }
}

 

 

 

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(()->"林青霞");
        System.out.println(s);
        Integer i = getInteget(()->30);
        System.out.println(i);

    }
    //定义一个方法，返回一个整数数据
    private static Integer getInteget(Supplier<Integer>sup){
        return sup.get();

    }
    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String>sup){
        return sup.get();
    }
}

 

public class Consumerdemo {
    public static void main(String[] args) {
        //一个
        operatorString("林青霞",s-> System.out.println(s));
        //两个
        operatorString("林青霞",s-> System.out.println(s),s-> System.out.println(new StringBuilder(s).reverse().toString()));


    }
    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operatorString(String name, Consumer<String>con1,Consumer<String>con2){
        con1.andThen(con2).accept(name);
    }
    //定义一个方法，消费一个字符串数据
    private static void operatorString(String name,Consumer<String>con){
        con.accept(name);
    }
}

 

public class PredicateDemo01 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello",s->s.length()>8);
        System.out.println(b1);
        boolean b2 = checkString("helloworld",s->s.length()>8);
        System.out.println(b2);

    }
    private static boolean checkString(String s, Predicate<String>pre){
        //正常判断 return pre.test(s);
        //逻辑非
        return pre.negate().test(s);
    }
}

public class PredicateDemo02 {
    public static void main(String[] args) {
        boolean b3 = checkString("hello",s->s.length()>8,s->s.length()<15);
        System.out.println(b3);
        boolean b4 = checkString("helloworld",s->s.length()>8,s->s.length()<15);
        System.out.println(b4);

    }
    //同一个字符串给出两个不同判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString(String s , java.util.function.Predicate<String> pre1, Predicate<String> pre2){
        //逻辑与(同真则真，一假则假)
        //return pre1.and(pre2).test(s);
        //逻辑或(一真则真，同假则假)
        return pre1.or(pre2).test(s);

    }
}

 

public class FunctionDemo {
    public static void main(String[] args) {
        convert("100",s->Integer.parseInt(s));
        convert(100,i-> String.valueOf(i+566));
        convert("100",s->Integer.parseInt(s),i->String.valueOf(i+566));

    }
    //定义一个方法，把一个字符串转化成int类型，往控制台输出
    private static void convert(String s, Function<String,Integer> fun){
        int i = fun.apply(s);
        System.out.println(i);
    }
    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(int i,Function<Integer,String>fun){
        String s = fun.apply(i);
        System.out.println(s);
    }
   // 定义一个方法，把一个字符串转换成int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(String s, Function<String,Integer>fun1,Function<Integer,String>fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}