1. Lamdba表达式
Lambda表达式是什么？
Lambda是一个匿名函数，我们可以将Lambda表达式理解为一段可以传递的代码（将代码像数据一样传递）。使用它可以写出简洁、灵活的代码。作为一种更紧凑的代码风格，使java语言表达能力得到提升。
public static void main(String[] args) {
//使用匿名函数
new Thread(new Runnable(){
@Override
public void run(){
System.out.println("我是没有使用Lambda表达式：不简洁");
}
}).start();
//使用Lambda表达式
new Thread(
()->System.out.println("我是使用Lambda表达式：简洁、灵活")
).start();
}
Lambda表达式在java语言中引入了一种新的语法元素和操作。这种操作符号为“->”,Lambda操作符或箭头操作符，它将Lambda表达式分割为两部分。 左边：指Lambda表达式的所有参数 右边：指Lambda体，即表示Lambda表达式需要执行的功能
六种语法格式 ：
-
语法格式一：无参数、无返回值，只需要一个Lambda体
public interface Lock {
public abstract void lockUp(); //上锁
}
public static void main(String[] args) {
Lock lock = ()-> System.out.println("Lambda表达式：简洁、灵活，优雅永不过时");
lock.lockUp();
}
-
语法格式二：lambda有一个参数、无返回值
public interface Lock { public abstract void lockUp(String str); //上锁 } public static void main(String[] args) { Lock lock = (s) -> System.out.println(s+"上锁"); lock.lockUp("张三"); } -
Lambda只有一个参数时，可以省略（）
public interface Lock { public abstract void lockUp(String str); //上锁 } public static void main(String[] args) { Lock lock = s -> System.out.println(s+"上锁"); lock.lockUp("张三"); } -
语法格式四：Lambda有两个参数时，并且有返回值
public interface Lock { public abstract String lockUp(String str,String str2); //上锁 } Lock lock = (s1,s2) -> { System.out.println("门被上锁。。。。。。"); return "上锁"; }; lock.lockUp("张三","李四"); -
语法格式五：当Lambda体只有一条语句的时候，return和{}可以省略掉
public interface Lock { public abstract String lockUp(String str,String str2); //上锁 } Lock lock = (s1,s2) -> "上锁"; lock.lockUp("张三","李四"); -
类型推断：数据类型可以省略，因为编译器可以推断得出，称为“类型推断”
public interface Lock { public abstract void lockUp(String str); //上锁 } public static void main(String[] args) { //可以写类型 Lock lock = (String s) -> System.out.println(s+"上锁"); lock.lockUp("张三"); //可以不写类型 Lock lock = (s) -> System.out.println(s+"上锁"); lock.lockUp("张三"); }
2. forEach+Lambda
-
使用forEach和Lambda循环list集合
List<String> list = new ArrayList<String>(); list.add("A"); list.add("B"); list.add("C"); //使用forEach和Lambda循环list集合 list.forEach(s->System.out.println(s)); public class UserVo { private String userName; public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } } List<UserVo> list = new ArrayList<UserVo>(); list.add(new UserVo()); list.add(new UserVo()); list.add(new UserVo()); //使用forEach和Lambda循环list集合并输出对象信息 list.forEach(s->System.out.println(s.getUserName())); -
使用forEach和Lambda循环Map集合
Map<String, UserVo> map = new HashMap<String, UserVo>(); map.put("A", new UserVo()); map.put("B", new UserVo()); map.put("C", new UserVo()); map.forEach((k,v)->System.out.println(k+"==="+v.getUserName()));
3. 函数式接口
什么是函数式接口？
函数式接口：只包含一个抽象方法的接口，称为函数式接口，并且可以使用lambda表达式来创建该接口的对象，可以在任意函数式接口上使用@FunctionalInterface注解，来检测它是否是符合函数式接口。同时javac也会包含一条声明，说明这个接口是否符合函数式接口
-
函数式接口： 有且仅有一个抽象方法的接口。
-
Java中的函数式编程体现就是Lambda表达式。
-
所以函数式接口即可以适用于Lambda使用的接口。
注意：自定义函数式接口时，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。
//正确 函数式接口
@FunctionalInterface
public interface Lock {
public abstract String lockUp(String str1,String str2); //上锁
//public abstract void openLock(); //开锁
}
//报错
@FunctionalInterface
public interface Lock {
public abstract String lockUp(String str1,String str2); //上锁
public abstract void openLock(); //开锁
}
4. 方法引用和构造器引用
1. 方法引用
当要传递给Lambda体的操作已经有实现方法，可以直接使用方法引用(实现抽象方法的列表，必须要和方法引用的方法参数列表一致)
方法引用：使用操作符“：：”将方法名和（类或者对象）分割开来。
有下列三种情况：
对象：：实例方法
类：：实例方法
类：：静态方法
@FunctionalInterface
public interface Lock {
public abstract void lockUp(String str); //上锁
}
Lock lock = System.out::println;
lock.lockUp("测试。。。");
2. 构造器引用
本质上：构造器引用和方法引用相识，只是使用了一个new方法
使用说明：函数式接口参数列表和构造器参数列表要一致，该接口返回值类型也是构造器返回值类型
格式：ClassName :: new
@FunctionalInterface
public interface Lock {
public abstract String lockUp(String str); //上锁
}
//非构造器引用
Lock lock1 = (s) -> new String(s);
//构造器引用
Lock lock2 = String::new;
5. Stream API
1. 什么是Stream？
Java8中两个最为重要特性：第一个的是Lambda表达式，另一个是Stream API。
StreamAPI它位于java.util.stream包中，StreamAPI帮助我们更好地对数据进行集合操作，它本质就是对数据的操作进行流水线式处理，也可以理解为一个更加高级的迭代器,主要作用是遍历其中每一个元素。简而言之,StreamAP提供了一种高效且易于使用的处理数据方式。
2. Stream特点：
1、Stream自己不会存储数据。
2、Stream不会改变源对象。相反，它们会返回一个持有结果的新Stream对象
3、Stream操作时延迟执行的。这就意味着它们等到有结果时候才会执行。
3. Stream操作的三个步骤？
-
1、创建Stream：一个数据源（例如：set 、list），获取一个流
-
2、中间操作：一个中间操作连接，对数据源的数据进行处理
-
3、终止操作:一个终止操作，执行中间操作连，产生结果。
4. Stream创建可以通过三种方式创建。
-
通过
java.util.Collection.stream()方法用集合创建流 -
使用
java.util.Arrays.stream(T[] array)方法用数组创建流 -
使用
Stream的静态方法：of()、iterate()、generate()
//1.通过 `java.util.Collection.stream()` 方法用集合创建流
List<String> list = Arrays.asList("d","a", "b", "c");
Stream<String> streamList = list.stream();
System.out.println("###############顺序流##############");
streamList.forEach(System.out::print);
System.out.println();
System.out.println("###############并行流##############");
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();
parallelStream.forEach(System.out::print);
System.out.println();
//2.使用`java.util.Arrays.stream(T[] array)`方法用数组创建流
int[] array={1,3,5,6,8};
IntStream streamint = Arrays.stream(array);
streamint.forEach(System.out::print);
System.out.println();
//3.使用`Stream`的静态方法：`of()、iterate()、generate()
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
stream.forEach(System.out::print);
System.out.println();
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::print);
System.out.println();
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::print);
System.out.println();
5. 中间操作
用下面这个集合来举例：
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰","张无忌");
}
（1）.limit(n) 从list中取出n个元素
list.stream().limit(2).forEach(System.out::println);
（2）.skip(n) 从list第n个元素开始，取出所有元素
list.stream().skip(3).forEach(System.out::println);
（3）.distinct() 去除重复
list.stream().distinct().forEach(System.out::println);
（4）.filter(Predicate<? super T> predicate) 筛选条件
括号中的内容为一个断言型函数式接口，其中的T为当前集合中元素的类型。
public static void main(String[] args) {
List<Person> personList = new ArrayList<>();
personList.add(new Person("欧阳雪",18,"中国",'F'));
personList.add(new Person("Tom",24,"美国",'M'));
personList.add(new Person("Harley",22,"英国",'F'));
personList.add(new Person("向天笑",20,"中国",'M'));
personList.add(new Person("李康",22,"中国",'M'));
personList.add(new Person("小梅",20,"中国",'F'));
personList.add(new Person("何雪",21,"中国",'F'));
personList.add(new Person("李康",22,"中国",'M'));
}
找出年龄大于20的人并打印输出：
personList.stream() .filter((person)->person.getAge()>20) .forEach(System.out::println);
（5）.map(Function<? super T,?> mapper ) 将元素转换成其他形式或提取信息。
打印出集合中所有人的年龄：
personList.stream() .map((person -> person.getAge())) .forEach(System.out::println);
（6）.sorted() 对元素进行排序
6. 终端操作
-
forEach() 遍历流中每一个元素，会关闭流
forEach 不能修改自己包含的本地变量值，也不能用 break/return 之类的关键字提前结束循环。
-
findFirst(),findAny()
查找操作，查找第一个、任何一个，返回的类型为Optional。常用于查询集中符合条件的元素，如果流是空的，则返回空大多数情况下，数据量不大的情况下，findAny()也会返回第一个元素，此时效果与findFirst()一致
-
allMatch，anyMatch，noneMatch
allMatch 要求Stream中所有元素都满足条件才返回true
anyMatch， 只要有1个元素满足就返回true
noneMatch 要求所有的元素都不满足条件才返回true
//每个学生年纪都为18才返回true boolean flag = list.stream().allMatch(e -> e.getAge() == 18); //任意一个学生是18，则返回true boolean flag = list.stream().anyMatch(e -> e.getAge() == 18); //学生年纪没有一个是18 ，则返回true boolean flag = list.stream().noneMatch(e -> e.getAge() == 18);
-
reduce:将整个数据流的值规约为一个值，其中count、min、max底层就是使用reduce,也可用于字符串连接
// 字符串连接，concat = "ABCD" String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); // 集合累加求和，另一写法reduce(0,Integer::sum) int sum2=Stream.of(1,2,3,4,5).reduce((t,u)->t+u).get(); //输出最大值，另一写法reduce(Integer::max) int max=Stream.of(1,2,3,4,5).reduce((t,u)-> t>=u? t:u).get(); 2> 有2个参数 T reduce(T identity, BinaryOperator<T> accumulator) 多一个泛型T，实际上相对于在计算值的时候多一个初始化的值 int sum3=Stream.of(1,2,3,4,5).reduce(0,(t,u)->t+u);-
min、max`最值操作：需要自定义比较器，返回数据流中最大、最小的值
//查年纪最大的 Optional<Student> max = list.stream().max(Comparator.comparing(Student::getAge)); if (max.isPresent()) { Student student = max.get(); } -
-
count : 返回Stream中元素的个数
-
toArray数组操作：将数据流的元素转换成数组。List<String> list=Arrays.asList("a","b","c","a"); //返回数组 String[] newArr=list.stream().toArray(String[]::new);
26万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
