一、基础
基本语法
[接口声明] = (参数)-> {代码。。。}；
具体使用
1.表达式必须和接口绑定使用，符合接口的方法声明。
如某个接口：
public interface A {
String get(int i);
}
声明接口时：
A a = new A() {
@Override
public String get(int i) {
return "hello " + i;
}
};
使用lambda
A la = (int i) -> {
return "lambda " + i;
};
但如果一个接口有多个方法，则无法使用lambda表达式。如
public interface B {
String get(int i);
void set();
}
default和static方法除外
public interface A {
String get(int i);
default int fun1() {
return 0;
}
static String fun2() {
return "A";
}
}
2.参数：可以是0到n个参数，具体根据绑定的接口而定，且参数类型可以不写。
A la = (i) -> {
return "lambda " + i;
};
3.返回值：如果代码块只有一行，可以没有大括号。
没有大括号时，不能用return关键字。
如果添加了大括号，或者有多行代码，必须通过关键字return返回。
//可以这样
A la2 = (i) -> "lambda " + i;
//也可以这样
A la2 = (i) -> {
return "lambda " + i;
};
//而不能这样
A la2 = (i) -> return "lambda " + i;
java.util.function提供了大量的函数式接口供我们使用
Predicate，传入T类型，返回boolean
Consumer，传入T类型，消耗掉，返回void
function，传入T类型，返回E类型
Supplier，传入返回T类型
UnaryOperator，传入T，返回T
BinaryOperator，传入两个T类型，返回T类型
emmm，记不住~~~
如Predicate
Predicate<String> pre1 = (name) -> "admin".equals(name);
System.out.println(pre1.test("admin") ? "管理员" : "普通用户");
打印结果：
管理员
lambda对this关键字的优化
使用lambda表达式时，在表达式内部this代表的是该lambda表达式所属的对象。
正常情况下，在接口内部使用this，该this指的是这个接口，而不是声明该接口的对象（或者说该接口所属的对象）
public class Test{
String s1 = "全局变量";
public void testLambda() {
String s2 = "局部变量";
new Thread(new Runnable() {
@Override
public void run() {
String s3 = "内部变量";
System.out.println(this.s1);//报错！！！
System.out.println(s2);
System.out.println(s3);
}
}).start();
}
public static void main(String[] args) {
new App().testLambda();
}
}
public class Test {
String s1 = "全局变量";
public void testLambda() {
String s2 = "局部变量";
new Thread(() -> {
String s3 = "内部变量";
System.out.println(this.s1);//不报错！！！
System.out.println(s2);
System.out.println(s3);
}).start();
}
public static void main(String[] args) {
new App().testLambda();
}
}
打印结果：
全局变量
局部变量
内部变量
方法重载对lambda表达式的影响
当遇到重载方法时，如果方法中传入的接口中的方法参数类型和返回值一样，则无法使用lambda。如
public class Test {
public static void main(String[] args) {
test(() ->{//报错！！！
System.out.println("I1");
return 1;
});
}
//重载方法
private static void test(A a) {
a.printString();
}
private static void test(B b) {
b.printInt();
}
}
interface A {
void printString();
}
interface B {
void printInt();
}
二、lambda在集合中的应用
方法引用
1. 静态方法、实例方法引用
以List.sort() 为例
实体类：
class Person {
private String name;
private int age;
public static int compareByAge(Person p1, Person p2) {
return p1.age - p2.age;
}
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
setter and getter...
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
数据源
List<Person> persons = new ArrayList<>();
persons.add(new Person("Tom", 28));
persons.add(new Person("Jack", 30));
persons.add(new Person("Dav", 20));
使用内部类方式
//使用内部类方式
persons.sort(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int i = o1.getAge() - o2.getAge();
return i;
}
});
使用lambda方式
//使用lambda方式
persons.sort((a, b) -> a.getAge() - b.getAge());
persons.sort(Comparator.comparingInt(Person::getAge));
先在任意一个类中定义参数为(Person p1, Person p2)，返回类型为 int 的静态方法和普通方法
class PersonUtil {
public int compareByAge(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
public static int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
}
静态方法引用，类名::静态方法名
//静态方法的引用，会默认将（Person, Person）参数传递给PersonUtil的compare方法
persons.sort(PersonUtil::compare);
实例方法引用，对象::普通方法名
//实例方法的引用
PersonUtil pu = new PersonUtil();
persons.sort(pu::compareByAge);
2. 构造方法引用
除了静态方法引用和实例方法引用还有构造方法引用。
interface IPerson {
//通过指定类型的构造方法初始化对象数据，
//即：Person类中必须有(String name, int age)类型参数的构造方法。
Person initPerson(String name, int age);
}
//构造方法的引用
IPerson ip = Person::new;
Person wang = ip.initPerson("wang", 25);
Stream
Stream解耦了对数据的各种操作，比起传统的手动操作数据更方便。
例如：
List<String> list = new ArrayList<>();
list.add("abc");
list.add("adcd");
list.add("adcde");
list.add("adcdef");
//传统方式获取list中元素长度>=4的数据
List<String> result = new ArrayList<>();
for (String s : list) {
if (s.length() >= 4) {
result.add(s);
}
}
System.out.println(result);
//使用Stream方式获取list中元素长度>=4的数据
List<String> collect = list.stream().filter(s -> s.length() >= 4).collect(Collectors.toList());
System.out.println(collect);
打印结果：
[adcd, adcde, adcdef]
[adcd, adcde, adcdef]
Stream概述
/**
* 1. 获取Stream对象
* 1. 从集合或数组中获取[**]
* Collection.stream(),如list.stream()
* Collection.parallelStream()
* Arrays.stream()
* 2. BufferReader
* BufferReader.lines()
* 3. 静态方法
* java.util.stream.IntStream.range()..
* java.nio.file.Files.walk()..
* 4. 自定义构建
* java.util.Spliterator
* 5. 更多方式。。
* Random.ints()
* Pattern.splitAsStream()..
* 2. 中间操作api
* 操作结果是一个Stream，中间操作可以有一个或多个连续的中间操作，需要注意的是，中间操作只记录操作方式，
* 不做具体执行，直到借宿操作发生时，才做数据的最终执行。
* 中间操作：就是业务逻辑处理。
* 中间操作过程：
* 无状态：数据处理是，不搜前置中间操作的影响。
* map/filter/peek/parallel/sequential/unordered
* 有状态：数据处理时，受前置中间操作的影响。
* distinct/sorted/limit/skip
* 3. 终结操作 | 结束操作{Terminal}
* 需要注意：一个Stream对象，只能由一个Terminal操作，这个操作一旦发生，就会真实的处理数据。
* 终结操作：
* 非短路操作：当前的Stream对象必须处理完集合中所有数据才能得到结果。
* forEach/forEachOrdered/toArray/reduce/collect/min/max/count/iterator
* 短路操作：当前的Stream对象在处理过程中，一旦满足某个条件，就可以得到结果。
* anyMatch/allMatch/noneMatch/findFirst/findAnd等
*/
对比上面例子
list.stream() //获取Stream
.filter(s -> s.length() >= 4) //中间操作，返回一个Stream对象
.collect(Collectors.toList()); //终结操作
Stream的获取
//多个数据
Stream<String> stream1 = Stream.of("A", "B", "C");
//数组
String[] strArray = new String[]{"A", "B", "C"};
Stream<String> stream2 = Stream.of(strArray);
//列表
ArrayList<Object> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
Stream<Object> stream3= list.stream();
//集合
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");
Stream<String> stream4 = set.stream();
//map
HashMap<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
Stream<Map.Entry<String, Integer>> stream5 = map.entrySet().stream();
Stream对象对于基本数据类型的封装
// int / long / double
IntStream.of(new int[] {10, 20, 30}).forEach(System.out::println);
IntStream.range(1,5).forEach(System.out::println);
IntStream.rangeClosed(1,5).forEach(System.out::println);
从Stream中获取指定的类型数据
Stream<String> stream1 = Stream.of("A", "B", "C");
//array
String[] arrayx = stream1.toArray(String[]::new);
//string
String stringx = stream1.collect(Collectors.joining());
//list
List<String> listx = stream1.collect(Collectors.toList());
//set
Set<String> setx = stream1.collect(Collectors.toSet());
//map
Map<String, String> mapx = stream1.collect(Collectors.toMap(x -> "key:" + x, y -> "val:" + y));
