.Net转Java自学之路—基础巩固篇二十（Lambda）
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了.Net转Java自学之路—基础巩固篇二十（Lambda），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5698字，纯文字阅读大概需要9分钟。
内容图文
Lambda表达式
语义本身就代表了做事情的动作，没有对象的概念在其中。
Java中使用Lambda表达式的前提：必须有 函数式接口。
概念：有且只有一个的抽象方法的接口就叫函数式接口。
为确保当前接口为函数式接口，在定义接口的前一行加 @FunctionalInterface
格式：
@FunctionalInterface
public interface 函数式接口名{
//Code...
}
Lambda表达式使用必须要有函数式接口的推断环境。
1、要么通过方法的参数类型类确定是那个函数式接口。
2、要么通过复制操作来确定是那个函数式接口。
Lambda的格式就是将抽象方法分解成为以下三点：
1、参数
2、箭头
3、代码
例：
public sbstract int sum(int a,int b);
//Lambda的标准格式：
(int a,int b) -> {return a+b;}
//Lambda的简化格式：
(a,b) -> a+b
//若参数有且只有一个参数，可以省略小括号。
实例：
@FunctionalInterface
public interface Calculator{
public sbstract int sum(int a,int b);//int sum(int a,int b);
}
public class CalculatorImpl implements Calculator{
public int sum(int a,int b){
return a+b;
}
}
public static void main(String[] args){
Calculator calculator=new CalculatorImpl();
method(calculator);
//等于
method((a,b) -> a+b);
}
public static void method(Calculator calculator){
int result=calculator.sum(1,2);
System.out.println(result);
}
View Code
方法引用：
防止Lambda表达式的代码冗余。
若Lambda表达式定义的动作在其他类中已经定义，那么使用方法引用来解决。
第一种：类名引用静态方法格式
类名::静态方法
第二种：对象名引用成员方法格式
对象名::成员方法名
实例：
@FuncationalInterface
pulic interface Calculator{
void show(string str);
}
public class Test{
public static void methodShow(String str){
System.out.println(str);
}
}
public static void main(String[] args){
method(str -> System.out.println(str));
//或者
method(Test::methodShow);
//或者
Test test=new Test();
method(test::methodShow);
//或者
method(System.out::println);//System.out其实就是jdk创建好的对象，println时System.out的成员方法
/*总结:
1、一定要有函数式接口，才能使用lambda
2、对于重复的lambda场景，可以使用方法引用来进行简化。
*/
}
public static void method(Calculator calculator){
calculator.show("内容");
}
实例：使用 集合for遍历冗余场景 去掉成绩不及格的成员
ArrayList<String> arr=new ArrayList<String>();
arr.add("a,90");
arr.add("ab,70");
arr.add("abc,50");
//截取
ArrayList<String> scoreList=new ArrayList<String>();
for(int i=0;i>arr.size();i++){
String[] strList=arr.get(i);
String score=strList[1];
scoreList.add(score);
}
//String转int
ArrayList<Integer> numList=new ArrayList<Integer>();
for(int i=0;i<scoreList.size(); i++){y8
int num=Integer.parseInt(scoreList.get(i));
numList.add(num);
}
//过滤
ArrayList<String> resultList=new ArrayList<String>();
for(int i=0; i<numList.size(); i++){
int num=numList.get(i);
if(num>60){
resultList.add(num);
}
}
//打印输出
for(int i=0; i<resultList.size();i++){
System.out.println(resultList.get(i));
}
View Code
//java8的简化stream流式操作
ArrayList<String> arr=new ArrayList<String>();
arr.add("a,90");
arr.add("ab,70");
arr.add("abc,50");
//Stream API更优写法 map映射 filter过滤 forEach遍历
arr.stream().map(s -> s.split(",")[1]).map(Integer::parseInt)
.filter(n -> n>60).forEach(System.out::println);
Stream API 流式操作
Java 8当中的“流”其实就是Stream接口的对象。
JDK提供了一个流接口，java.util.stream.Stream<T>
获取流的方式：
1、根据集合获取流：集合对象名称.stream();
2、分解数组获取流：Stream.of(数组名称) 数组当中的元素必须是引用类型
//实例1
ArrayList<String> arr=new ArrayList<String>();
arr.add("a");
arr.add("ab");
arr.add("abc");
Stream<String> streamA=arr.stream();
//实例2
String[] strList={"","",""};
Stream<String> streamS=Stream.of(strList);
流的映射map：
获取流之后，使用映射方法：map（用于转换的Lambda表达式）
映射：就是将一个对象转换成为另一个对象，把老对象映射到新对象上。
ArrayList<String> arr=new ArrayList<String>();
arr.add("1");
arr.add("2");
arr.add("3");
Stream<Integer> streamA=arr.stream().map((String str) -> {
int num=Integer.parseInt(str);
return num;
});
//简化 详细步骤如下：
streamA=arr.stream().map(str -> {
int num=Integer.parseInt(str);
return num;
});
streamA=arr.stream().map(str -> {
return Integer.parseInt(str);
});
streamA=arr.stream().map(Integer::parseInt);//方法引用
实例：
ArrayList<String> arr=new ArrayList<String>();
arr.add("a,90");
arr.add("ab,70");
arr.add("abc,50");
//Lambda的标准写法
Stream<String> streamA=arr.stream().map((String s) -> {
String[] strList=s.split(",");
String result=strList[1];
return result;
});
//简化 步骤：
streamA=arr.stream().map(s -> {
String[] strList=s.split(",");
String result=strList[1];
return result;
});
streamA=arr.stream().map(s -> {
String[] strList=s.split(",");
return strList[1];
});
streamA=arr.stream().map(s -> {
return s.split(",")[1];
});
streamA=arr.stream().map(s -> s.split(",")[1]);
View Code
filter 过滤
filter 能产生boolean结果的Lambda；true则取，false则丢
ArrayList<String> arr=new ArrayList<String>();
arr.add(90);
arr.add(70);
arr.add(50);
Stream<Integer> streamA=arr.stream().filter((int num) -> {
boolean b=num>60;
return num;
});
//简化 步骤：
streamA=arr.stream().filter(num -> {
boolean b=num>60;
return num;
});
streamA=arr.stream().filter(num -> {
return num>60;
});
streamA=arr.stream().filter(num -> num>60);
forEach 遍历
forEach(Lambda表达式);
参数Lambda表达式必须是一个能够消费的一个参数，而且不产生结果的Lambda表达式。
ArrayList<String> arr=new ArrayList<String>();
arr.add(90);
arr.add(70);
arr.add(50);
Stream<Integer> streamA=arr.stream().forEach((int i) -> {
System.out.println(i);
});
//简化 步骤：
streamA=arr.stream().forEach(i -> {
System.out.println(i);
});
streamA=arr.stream().forEach(i -> System.out.println(i));
streamA=arr.stream().forEach(System.out::println);
并发（Paralle）流
对流中的元素进行多个人同时处理，这就是并发。
ArrayList<String> arr=new ArrayList<String>(); //获取一个并发流 arr.parallelStream()......... //或 若已经获取一个普通流，那么只要再调用一下parallel()也会变成并发流 arr.stream().parallel()......
内容总结
以上是互联网集市为您收集整理的.Net转Java自学之路—基础巩固篇二十（Lambda）全部内容，希望文章能够帮你解决.Net转Java自学之路—基础巩固篇二十（Lambda）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。