Lambda表达式练习与总结

迈不过友情╰ 2024-04-17 05:36 103阅读 0赞

> 1.无参数，无返回值  
>  \*         () -> System.out.println("Hello Lambda!");
> 
> 2.有一个参数，并且无返回值  
>  \*         (x) -> System.out.println(x)
> 
> 3.若只有一个参数，小括号可以省略不写  
>  \*         x -> System.out.println(x)
> 
> 4.有两个以上的参数，有返回值，并且 Lambda 体中有多条语句  
>  \*        Comparator<Integer> com = (x, y) -> \{  
>  \*            System.out.println("函数式接口");  
>  \*            return Integer.compare(x, y);  
>  \*        \};
> 
> 5.若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写  
>  \*         Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
> 
> 6.Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”  
>  \*         (Integer x, Integer y) -> Integer.compare(x, y);

**写一个处理字符串的接口**

接口+实现类

接口：

@FunctionalInterface
    public interface MyFunc {
        /**
         * 处理字符串
         * @param str
         * @return
         */
         String testStr(String str);
    }

普通方法实现：

@Test
        public void test2(){
            String s = testStr("  11  2 33  ", new MyFunc() {
                @Override
                public String testStr(String str) {
                    return str.trim();
                }
            });
            System.out.println(s);
        }
    
        public String testStr(String str, MyFunc func){
            return func.testStr(str);
        }

使用Lambda表达式的实现方式--自由方便实现

@Test
        public void test2(){
            //去除头尾空格
            String s = testStr("   ttpp  ", p -> p.trim());
            System.out.println(s);
            //截取字符串
            String s1 = testStr("0123456", p -> p.substring(0, 3));
            System.out.println(s1);
            //字符串变小写
            String s2 = testStr("ABCD", p -> p.toLowerCase());
            System.out.println(s2);
        }

**定制排序--按年龄排序，如果年龄相同，按姓名排序**

@Test
        public void test1(){
            List<Person> peoples = new ArrayList<>();
            peoples.add(new Person("jack",12));
            peoples.add(new Person("typ",13));
            peoples.add(new Person("typ23",45));
            peoples.add(new Person("typ123",20));
            Collections.sort(peoples,(p1,p2) ->{
                if (p1.getAge().equals(p2.getAge())){
                    return p1.getName().compareTo(p2.getName());
                }else{
                    return -Integer.compare(p1.getAge(),p2.getAge());
                }
            });
            //循环打印
            peoples.forEach(p -> System.out.println(p.toString()));
        }

T作为参数，R作为返回值 ，处理数值

@FunctionalInterface
    public interface MyFunc2<T, R> {
        /**
         * T作为参数，R作为返回值
         * @param t1
         * @param t2
         * @return
         */
        R getValue(T t1,T t2);
    }

@Test
        public void test3(){
            op(1L,2L,(x,y) -> x + y);
            op(1L,2L,(x,y) -> x * y);
        }
    
        public void op(Long l1, Long l2, MyFunc2<Long, Long> func){
            System.out.println(func.getValue(l1, l2));
        }

创建线程的方式

new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("test Runnable..");
                    System.out.println(Thread.currentThread().getName());
                }
            }).start();
    
            new Thread(() -> {
                System.out.println("test Lambda");
                System.out.println(Thread.currentThread().getName());
            }).start();