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 get();
}

设计方法

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

代码实现

/*
匿名内部类形式
*/
String s = testLambda(new Supplier){
@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{
void accept(T t);
}

方法设计

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

public static void testLambda(String str , Consumer handle){
//需要方法外部针对传入的字符串参数有处理能力
//通过Consumer接口传入
handle.accept(str);
}/*
匿名内部类方式
*/
testLambda(“字符串”，Consumer(){
@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{
int compare(T o1,T o2);
}

比较器案例

/*生成数据*/
Person[] array = new Person[5];
for(int i = 0; i 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 filter){
Person[] temp = new Person[array.length];
int count = 0;
for(int i = 0; i

过滤器接口

接口设计

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

类型转换接口

接口设计

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

代码实现

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

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

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

3.stream流

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

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

案例

ArrayList 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 list1 = list.stream().distinct().collect(Collectors.toList());
// Stream 流数据内容转 Set 集合
Set set = list.stream().skip(2).limit(20).collect(Collectors.toSet());

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
机房租用，北京机房租用，IDC机房托管， http://www.e1idc.net