lambda表达式、Stream流

1.函数式接口

JDK1.8版本以上有效

• @FunctionalInterface语法要求当前接口只有一个尚未完成的省缺属性为public abstract修饰方法。

• 函数式接口里允许定义默认方法和静态方法

• 函数式接口一般用于方法增强，直接作为方法的参数，实现插件式编程。

格式

@FunctionalInterface
interface test{
   void test();
}

用途

lambda表达式和方法引用

2.lambda表达式

基本格式

(联想参数变量) -> {执行任务代码块}

lambda表达式关注的是接口中的方法的返回值和参数。方法名不重要

2.1无参数无返回值

设计接口

函数式接口，当作下面方法的参数

@FunctionalInterface
interface A{
    void 方法名();
}

设计方法

将上面的接口当作参数

public static void testLambda(A a){
    a.方法名;
}

代码实现

/*
匿名内部类方式
*/
testLambda(new A(){
    @Override
    public void 方法名(){
        System,out.println("匿名内部类对象方法实现");
    }
});


/*
lambda表达式实现
*/
testLambda(() -> {
    System.out.println("lambda表达式");
})
    
    
/*
lambda表达式优化
*/
    testLambda(() -> System.out.println("lambda表达式优化"));

/*
方法引用
*/
testLambda(当前类的类名::test);


/*方法引用调用的方法*/
public static void test(){
    System.out.println("方法引用");
}

2.2 无参数有返回值

生产者接口

设计接口

@FunctionalInterface
interface Supplier<T>{
    T get();
}

设计方法

/**
 *返回一个字符串数据内容
 *
 *@params s 生产者
 *@return
 */
public static String testLambda(Supp;ier<String> s){
    return s.get();
}

代码实现

/*
匿名内部类形式
*/
String s = testLambda(new Supplier<String>){
    @Override
    public String get(){
        return "一个字符串";
    }
});
System.out.println(s);

/*
lambda表达式
*/
String s1 = testlambda(() -> {
  return "也是一个字符串“;
})
Sysout.out.println(s1);

/*
lambda优化
*/
String s2 = testLambda(() -> "还是一个字符串");
System.out.println(s2);

/*
lambda使用方法局部变量
*/
String str = "依旧&还是一个字符串";
String s3 = testLambda((str) ->{
    Sttring[] split = str.split(&);
    return split[0];
})
System.out.prinln(s3);

/*
方法引用
*/
String s4 = testLambda(目标方法所处类的类名::方法名);
System.out.println(s4);

//方法引用所使用的方法
public static String 方法名{
    return "被引用的方法";
}

2.3有参数无返回值

消费者接口

接口设计

@Functionalface
public interface Consumer<T>{
   void accept(T t);
}

方法设计

consumer可以传入实现类对象和lambda表达式

public static void testLambda(String str , Consumer<String> handle){
   //需要方法外部针对传入的字符串参数有处理能力
   //通过Consumer接口传入
   handle.accept(str);
}

/*
匿名内部类方式
*/
testLambda("字符串"，Consumer<String>(){
   @Override
   public void accept(String t){
       System.out.println(t);
   }
});

/*
lambda表达式
*/
testLambda("一个字符串",(s) ->{
   System.out.println(Arrays.toString(s.toCharArray())));
});

/*
lambda优化
*/
testLambda("一个字符串",s -> System.out.println(Arrays.toString(s.toCharArray())));

//方法引用
testLambda("还是一个字符串",System.out::println);
testLambda("依旧是一个字符串",方法所属类的类名::方法名);


/*
被引用的方法
*/
public static void test(Stirng str){
   System.out.println(str);
}

2.4有参数有返回值

比较器接口

接口设计

@Functionalinterface
interface Comparator<T>{
    int compare(T o1,T o2);
}

比较器案例

/*生成数据*/
Person[] array = new Person[5];
for(int i = 0; i < array.length;i++){
    int age = (int) Math.random() * 50;
    array[i] = new new Person(i + 1, "张三" + i, age,false);
}


/*
lambda表达式
*/
Preson[] temp = filterPredicate(array,p -> p.getAge() > 10);
for(Person person : temp){
    System.out.println(person);
}



/**
 *利用predicate过滤器接口限制数组内容
 *@param array Person
 *@param filter Predicate
 @return temp 过滤后的心数组
 */
public static Person[] filterPredicate(Person[] array,Predicate<Person> filter){
    Person[] temp = new Person[array.length];
    int count = 0;
    for(int i = 0; i < array.length;i++){
        //判断当前Person对象是否满足要求，如果满足，存储到temp中
        if(filter.test(array[i])){
            temp[count++] = array[i];
        }
    }
    return temp;
}

过滤器接口

接口设计

@FunctionalInterface
interface Predicate<T>{
    boolean test(T t);
}

类型转换接口

接口设计

@FunctionalInterface
interface Function<T, R>{
    R apply(T,t);
}

代码实现

String str = "坠落吧，落吧，想你的雪花放肆在心里落下";


int i = testLambda(str,s -> s.length());
System.out.println(i);


public static int testLambda(String str,Function<String,Integer> fun){
    return fun.apply(str);
}

3.stream流

利用流水线思想怼集合，数组数据就行处理和操作。

例如;排序，筛选，类型转换

案例

ArrayList<String> list = new ArrayList<>();
/**添加数据**/

//处理数据
list.stream()//stream流
         .skip(2)//跳过两个元素
         .limit(8)//保留八个元素
         .filter(s -> s.length() > 4)//过滤长度大于4的元素
         .sorted(Comparator.comparing(String::length))//指定排序规则，按照长度排序
         .forEach(System.out::println);//遍历输出

conllect

// Stream 流数据内容转 List 集合
List<String> list1 = list.stream().distinct().collect(Collectors.toList());
// Stream 流数据内容转 Set 集合
Set<String> set = list.stream().skip(2).limit(20).collect(Collectors.toSet());