java基础之Lamdba表达式01_表达式基础
Java8提供了Lamdba表达式，通过表达式可以简化一些代码的表达方式，设计思路和javascript的函数类似，此处我不希望花太多的时间来介绍Lambda的作用，对于Lamdba的学习，应该首先看看它是怎么一回事，学会之后通过几个实例即可掌握Lamdba表达式的作用和意义。
Lamdba表达式的表示方式
在java中我们通常都是定义单行变量，就好比如下的操作
int n = 10;
String str = "hello";
boolean b = true;
而Lamdba是函数变量，什么是函数变量呢，就等于我们用一个名称来表示一个函数，如下所示
helloFunction = public void sayHello() {
System.out.println("hello world!");
}
对于上面一个函数变量而言，public是访问控制修饰符，在对于函数的变量而言，没有意义，可以省略，之后就成如下的样子
helloFunction = void sayHello(){
System.out.println("hello world!");
}
对于函数变量而言，我们关心的是函数这个变量的结果，函数的名称就没有任何意义，void表示没有返回值，也没有意义，将这两个删除之后
helloFunction = () {
System.out.println("hello world!");
}
如果这个函数中只有一行代码，我们可以将花括号省略，使用->来替换前花括号，最后就变成了如下的一个样子
helloFunction = ()->System.out.println("hello world!");
已上就是一个Lamdba表达式的写法，通过这个例子各位应该清楚什么是Lamdba了吧，它其实就是一个函数级别的变量，当然这个代码是无法被编译。在继续讲解之前，我们来看一下其他几个函数的转换问题
public int add(int a,int b) {
return a+b;
}
对于以上函数，首先定义一个变量来存储这个函数，然后去掉public和add名称，最后就是返回值的处理，只要直接声明函数的结果是a+b即可
addFunction = (int a,int b)->a+b;
通过java实现Lamdba
下面我们会通过一个例子来实现一个Lamdba表达式，首先看helloFunction，对于helloFunction这个变量而言如果需要符合语法规则，第一是需要一个变量类型，在java8中通过接口来定义这个函数类型，只要创建一个接口，接口中有一个和这个函数的参数和返回值一样的抽象函数即可。
interface HelloFunction {
/**
* helloFunction中的函数没有返回值和没有参数，此时只要HelloFunction接口中
* 有一个不带参数和没有返回值的函数即可
*/
public void foo();
}
此时的helloFunction就可以使用这个接口作为变量类型
public class HelloLambda {
public static void main(String[] args) {
//HelloFunction中要存在一个同样类型和同样返回值的函数
HelloFunction helloFunction = () -> System.out.println("hello world!");
helloFunction.foo();
}
}
此时如果修改HelloFunction中的函数的参数类型和返回值都会报错，而且HelloFunction中也不能添加其他的方法，如果添加其他方法都会报错，所以函数接口中只能有一个方法。Java提供了一个Annotation来声明这种函数接口@FunctionalInterface接下来看看add方法的操作，原理也一样，定义接口，接口中有个方法有两个int的参数和int的返回值。
@FunctionalInterface
interface AddFunction {
public int add(int a,int b);
}
public static void main(String[] args) {
//此时由于确定了函数值的类型，也就等于确定了参数的类型，所以，函数的参数的类型也可以省略
AddFunction addFunction = (a,b) -> a+b;
System.out.println(addFunction.add(12,22));
}
需要注意的是由于在定义函数变量时，可以通过函数变量的类型就可以知道里面的函数参数类型，所以在Lamdba表达式中也不用声明函数类型。
Lamdba表达式和匿名内部类
Lamdba表达式的这种方式非常类似Java的匿名内部类
//匿名内部类，整个操作和Lamdba非常类似
AddFunction af = new AddFunction() {
public int add(int a, int b) {
return a+b;
};
};
System.out.println(af.add(12, 22));
两者的操作非常类似，当然到后面我们会发现他们之间的区别，目前我们所看到的主要区别有这样三点：1、匿名内部类的接口可以有多个方法，但是Lamdba的函数接口只能有一个方法。2、匿名内部类的实现方式比较麻烦一些。3、对于Lamdba表达式而言，并不一定是固定类型的，只要有另外一个接口满足这个函数的基本要求，就可以用来设置Lamdba表达式，这是Lamdba表达式的优点，利用这个优点可以快速的开发多线程的程序。举个例子，java的Runnable接口中只有一个run方法，这个接口和方法完全满足HelloFunction的需求，我们就可以按照下面的方式来定义这种写法。
Runnable rfunction = () -> System.out.println("hello world!");
此时的cfunction其实就是一个实现了Runnable的函数对象，同样可以作为Thread的参数传进去，就可以实现多线程的开发。
Lamdba作为函数的参数值
Lamdba表达式还可以作为函数的参数值来使用，看如下一个例子
public class TypeLamdba {
public static void main(String[] args) {
// StrLengthFunction sf = (s)->s.length();
// printStrLen(sf, "this is a Lamdba!");
//上面的两行代码可以使用下面这种表示方式
printStrLen((s)->s.length(), "this is a Lamdba!");
}
/**
* 该方法的参数使用了函数接口作为第一个参数
*/
private static void printStrLen(StrLengthFunction sl,String value) {
System.out.println(sl.length(value));
}
@FunctionalInterface
interface StrLengthFunction {
public int length(String str);
}
}
通过上面一个例子，我们获取了字符串的长度，并且通过Lamdba表达式将其打印出来，这里大家看起来似乎比较的麻烦，但是这个实例提供一种操作。下面我们将看一个基于Lamdba处理列表的实例。
Lamdba表达式的具体实例
首先创建一个实体类Student
public class Student {
private String name;
private String no;
private int age;
public Student() {}
public Student(String name, String no, int age) {
super();
this.name = name;
this.no = no;
this.age = age;
}
/.省略getter和setter./
}
接着创建一个列表
public class TestStudent {
public static void main(String[] args) {
List<Student> stuList = Arrays.asList(
new Student("张三","001",19),
new Student("李四","005",22),
new Student("王五","010",14),
new Student("赵六","004",18),
new Student("何琦","006",12)
);
}
}
我们先按照传统的方式来完成如下三个操作，根据用户no排序，列表所有的用户信息，显示年龄大于15岁的所有学生。
这三个操作如果不使用Lamdba表达式非常简单，比较大小只要通过Collections.compare()方法即可完成，第二个参数是一个Comparator的接口，我们通过内部类来实现，下面是三个函数的代码
//根据学号排序
public static void sortByNo(List<Student> list) {
Collections.sort(list,new Comparator<Student>() {
public int compare(Student o1, Student o2) {
return o1.getNo().compareTo(o2.getNo());
};
});
}
//列表所有学生信息
public static void listAll(List<Student> stuList) {
for(Student stu:stuList) {
System.out.println(stu);
}
}
//过滤小于15岁的学生
public static void filterAge(List<Student> list) {
for(Student stu:list) {
if(stu.getAge()>15) {
System.out.println(stu);
}
}
}
已上三个代码都是以硬编码的方式实现，这种所带来的问题是不灵活，特别是filterAge，在此处其实除了过滤年龄，我们还可能会有其他的条件过滤需求，所以可以通过传入一个条件接口来实现，看看下面改造后的代码
public static void filterCondition(List<Student> stuList,Condition<Student> c) {
for(Student stu:stuList) {
if(c.test(stu)) {
System.out.println(stu);
}
}
}
interface Condition<T> {
public boolean test(T t);
}
增加了一个Condition的接口，来传入条件，当满足条件之后就执行打印，这个条件可以通过匿名内部类的方式来实现
filterCondition(stuList, new Condition<Student>() {
@Override
public boolean test(Student t) {
if(t.getAge()>15) return true;
return false;
}
});
已上实现了这个操作，这种方式看起来复杂，但是它提供了一个条件检测，只要用不同的方式Condition接口，就可以根据条件来处理不同的信息，这和java中File类的FileFilter非常类似。
以下是该版本的完整代码
public class TestNewStudentByJdk7 {
public static void main(String[] args) {
List<Student> stuList = Arrays.asList(
new Student("张三","001",19),
new Student("李四","005",22),
new Student("王五","010",14),
new Student("赵六","004",18),
new Student("何琦","006",12)
);
sortByNo(stuList);
listAll(stuList);
System.out.println("-------------");
filterCondition(stuList, new Condition<Student>() {
@Override
public boolean test(Student t) {
if(t.getAge()>15) return true;
return false;
}
});
}
//根据学号排序
public static void sortByNo(List<Student> list) {
Collections.sort(list,new Comparator<Student>() {
public int compare(Student o1, Student o2) {
return o1.getNo().compareTo(o2.getNo());
};
});
}
//列表所有学生信息
public static void listAll(List<Student> stuList) {
for(Student stu:stuList) {
System.out.println(stu);
}
}
public static void filterCondition(List<Student> stuList,Condition<Student> c) {
for(Student stu:stuList) {
if(c.test(stu)) {
System.out.println(stu);
}
}
}
interface Condition<T> {
public boolean test(T t);
}
}
下面我们将看一下Lamdba的实现方式，首先看sortByName方法，Comparator接口中只有一个compare的函数，所以我们可以使用Lamdba来简化这一部分的操作。
//根据学号排序
public static void sortByNo(List<Student> list) {
Collections.sort(list,(s1,s2)->s1.getNo().compareTo(s2.getNo()));
}
接下来通过Lamdba的方式来操作filter方法，这个使用了Lamdba之后会简化非常多的操作，看如下三个例子
//查询所有年龄大于15的人
filterCondition(stuList,(t)->t.getAge()>15);
//查询姓张的所有学生
filterCondition(stuList,(t)->t.getName().startsWith("张"));
//查询所有学生对象，条件为true
filterCondition(stuList, (t)->true);
可见使用了Lamdba之后整个代码得到了极大的精简，看一下完整的代码
public class TestStudentByLamdba {
public static void main(String[] args) {
List<Student> stuList = Arrays.asList(
new Student("张三","001",19),
new Student("李四","005",22),
new Student("王五","010",14),
new Student("赵六","004",18),
new Student("何琦","006",12)
);
sortByNo(stuList);
System.out.println("age > 15");
//查询所有年龄大于15的人
filterCondition(stuList,(t)->t.getAge()>15);
System.out.println("name like 张");
//查询姓张的所有学生
filterCondition(stuList,(t)->t.getName().startsWith("张"));
System.out.println("all student");
//查询所有学生对象，条件为true
filterCondition(stuList, (t)->true);
}
//根据学号排序
public static void sortByNo(List<Student> list) {
Collections.sort(list,(s1,s2)->s1.getNo().compareTo(s2.getNo()));
}
public static void filterCondition(List<Student> stuList,Condition<Student> c) {
for(Student stu:stuList) {
if(c.test(stu)) {
System.out.println(stu);
}
}
}
interface Condition<T> {
public boolean test(T t);
}
}
关于Lamdba的讲解第一部分就到这里，相信通过这些实例，会让大家对Lamdba有一个基本的认识，下一部分将会讲解一些相对深入的知识。
