java8新特性之lambda表达式小练习+核心函数式接口+源码

1.调用Collection.sort()  方法，通过定制排序比较两个TMsAj(先比较评分，评分相同按当事人个数比较)，使用Lambda作为参数传递

 

2.①声明函数式接口，接口中生命抽象方法，public String  getValue(String str);

②声明类TestLambda，类中编写方法使用接口作为参数，将一个字符串转换成大写，并作为方法的返回值

③在将一个字符串的第二个和第四个索引位置进行截取子串

 

3.①声明一个带两个泛型的函数式接口，泛型类型为<T,R> T为参数，R为返回值

②接口中声明对应抽象方法，使用接口作为参数，计算两个long型参数的和

④在计算两个long型参数的乘积

 

 

 

 

参考答案

第一题 

package com.com.thunisoft.java8.practise;

import com.com.thunisoft.java8.TestLambda2.TMsAj;
import org.junit.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Prictise1 {
    /**
     * 1.  调用Collection.sort()  方法，通过定制排序比较两个TMsAj(先比较评分，评分相同按当事人个数比较)，
     *     使用Lambda作为参数传递
     */
    List<TMsAj> ajs = Arrays.asList(
            new TMsAj("1001","民初1号", 1,11.11),
            new TMsAj("1003","民初3号", 3,33.33),
            new TMsAj("1002","民初2号", 2,22.22),
            new TMsAj("1005","民初5号", 5,55.55),
            new TMsAj("1004","民初4号", 4,44.44),
            new TMsAj("1006","民初6号", 6,66.66)
    );
    @Test
    public void test1(){
        Collections.sort(ajs,(aj1,aj2) ->{
            if(aj1.getScore() == aj2.getScore()){
                return Integer.compare(aj1.getNdsrsl(),aj2.getNdsrsl());
            }else{
                return Double.compare(aj1.getScore(),aj2.getScore());
            }
        });
        //查看排序结果
        for(TMsAj aj:ajs){
            System.out.println(aj);
        }
    }
}

第二题

函数式接口：

package com.com.thunisoft.java8.practise;

@FunctionalInterface
public interface MyFunc {
    public String getValue(String str);

}

实现方法：

package com.com.thunisoft.java8.practise;

import org.junit.Test;

public class Prictise2 {

    public String strHandler(String str,MyFunc myFunc){
        return myFunc.getValue(str);
    }

    @Test
    public void test(){
      String res =  strHandler("java8 so tm easy!",(str)->str.toUpperCase());
        System.out.println(res);
    }
}

第三题

函数式接口

package com.com.thunisoft.java8.practise;

@FunctionalInterface
public interface Myfunc2<T,R> {
    public R getValue(T t1,T t2);
}

实现：

package com.com.thunisoft.java8.practise;

import org.junit.Test;

public class prictise3 {
    public void op(Long l1,Long l2, Myfunc2<Long,Long> mf){
        System.out.println(mf.getValue(l1,l2));
    }

    @Test
    public void test3(){
        op(100L,200L,(x,y) -> x * y);
        op(200L,600L,(x,y) -> x + y);
    }

}

 

 

疑问：每次使用lambda表达式都需要自己定义一个函数式接口吗？

不是的！Java8已经帮咱们提供了！~

四大内置核心函数式接口

函数式接口	参数类型	返回类型	用途
Consumer<T> 消费型接口	T	Void	对类型为T的对象应用操作，包含方法：void accept(T t)
Supplier<T> 供给型接口	无	T	返回类型为T的对象，包含方法T get();
Function<T,R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果类型是R的对象，包含方法： R apply(T t)
Predicate<T> 断言型接口	T	boolean	确定类型为T的对象是否满足约束条件，并返回boolean的值，包含方法boolean test(T t)

 

消费型接口Consumer<T>：有去无回

@Test
public void test1(){
    beatDog(10,(x) -> System.out.println("用"+ x + "个肉包子打狗子"));
}

public void beatDog(int num, Consumer<Integer> con){
    con.accept(num);
}

供给型接口 Supplier<T>：空手套白狼

/产生指定个数的整数，并放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> supplier){
    List<Integer> result = new ArrayList<>();
    for(int i = 0;i<num; i++){
        Integer n = supplier.get();
        result.add(n);
    }
    return result;
}


@Test
public void test2(){
    List<Integer> result = getNumList(10,()->(int)(Math.random()*100));
    for(Integer num:result){
        System.out.println(num);
    }
}

函数型接口：Function<T,R>：捏橡皮泥

需求：字符串首尾空格

public String strHandler(String str, Function<String,String> func){
    return func.apply(str);
}

@Test
public void test3(){
    String result = strHandler("\t\t\t java8 so tm easy! \t\t\t",(str) -> str.trim());
    System.out.println(result);
}

断言型接口，Predicate<String>：包大人

需求：取集合中长度大于3的字符

public List<String> filterStr(List<String> list, Predicate<String> predicate){
        List<String> result = new ArrayList<>();
        for(String str:list){
            if(predicate.test(str)){
                result.add(str);
            }
        }
        return result;
    }

    @Test
    public void test4(){
        List<String> list = Arrays.asList("a","bb","ccc","dddd","eeeee");
        List<String> result = filterStr(list,(x) -> x.length()>3);
        for(String str:result){
            System.out.println(str);
        }

 

其他接口

函数式接口	参数类型	返回类型	用途
BiFunction<Y,U,R>	T,U	R	对类型为T,U参数应用操作，返回R类型的结果，包含方法为R apply(T t,U u);
UnaryOperator<T> (Function子接口)	T	T	对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为T apply(T  t)
BinaryOperator<T> (BiFunction 子接口)	T,T	T	对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为T apply(T  t)
BiConsumer<T,U>	T,U	void	对类型为T,U参数应用操作，包含方法为void accept(T t,U u)
ToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T>	T	int long double	分别计算int、long、double、值的函数
IntFunction<R> LongFunction<R> DoubleFunction<R>	int long double	R	参数分别为int、long、double类型的函数

 

 

下篇

方法引用与构造器引用+StreamAPI