1、lambda
使用格式:
(参数列表)->{
方法体
}
方法体:用于执行业务逻辑,可以是单一语句,亦可以是语句块,当时一个单一的语句时,可以省略花括号。当需要返回值的时候,如果方法体中只有一个语句,可以省略return,会自动根据结果进行返回。
-
没有参数的
()-> new Student();
-
只有一个参数的
x->{
System.out.println(x);
return x;
}
-
多个参数
(int x,int y)->{
System.out.println(x);
System.out.println(y);
return x+y;
}
参数类型可以省略哦
遍历集合:
list.forEach(v->{
System.out.println(v);
});
list.forEach(v-> System.out.println(v));
list.forEach(System.out::println);
改造匿名内部类:
Runnable runnable = new Runnable(){
@Override
public void run() {
}
};
Runnable runnable1= ()->{
System.out.println("111");
};
集合排序:
Arrays.sort(ints, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return (o1.compareTo(o2));
}
});
Arrays.sort(ints,(o1, o2) -> o1.compareTo(o2));
2、函数式接口
其实是仅有一个抽象方法的普通接口,如果声明多个抽象方法则会报错,但是默认的方法和静态方法在此接口中可以定义多个。
3、Stream流
流操作是java8提供一个重要新特性,它允许开发人员以声明性方式处理集合,其核心类库主要改进了对集合类的API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引1入到ava中,能让代码更加简洁,极大地简化了集合的处理操作,提高了开发的效率和生产力。
同时,Stream不是一种数据结构,它只是某种数据源的一个视图,数据源可以是一个数组,Java容器或i/o channel等。在Stream中的操作每一次都会产生新的流,内部不会像普通集合操作一样立刻获取值,而是情性取值,只有等到用户真正需要结果的时候才会执行。
-
中间操作:会返回一个流,通过这种方式可以将多个中间操作连接起来,形成一个调用链,从而转化为另外一个流。除非调用链最后存在一个终端操作,否者中间操作对流不会进行任何结果处理。
-
终端操作:会返回一个具体的结果,比如Boolean、List、Integer等。
public class demo1 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student(1,"张三","F",18));
list.add(new Student(2,"李四","M",19));
list.add(new Student( 3,"王五","F",20));
list.add(new Student( 4,"赵六","M",21));
List<String> collect = list.stream()
.filter(student -> student.getAge() > 19)// 过滤出年龄大于19岁的学生
.sorted(Comparator.comparing(Student::getAge))// 按照年龄排序
.map(Student::getName)// 只获取学生的名字
.collect(Collectors.toList());// 将结果收集到list中
// System.out.println(collect);
List<String> collect1 = Stream.of("one", "two", "three", "four")
.filter(e -> e.length() > 3)
.peek(e -> System.out.println("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e))
.collect(Collectors.toList());
System.out.println(collect1);
}
}
3.1、筛选
对于集合的操作,经常性的会涉及到对于集中符合的数据筛选,Stream中对于数据筛选两个常见的API:filter(过滤),distinct(去重)。
List<Student> collect = list.stream().distinct().collect(Collectors.toList());
输出集合发现没有去重,为什么原来是要实现hashcode和equals方法!!!
3.2、切片
limit
public class limitdemo {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
List<Integer> collect = list.stream().limit(4).collect(Collectors.toList());
System.out.println(collect);
}
}
limit是对数据进行从前往后的方式进行截取,但是对于我想获取其中的一部分数据怎么办,skip
public class limitdemo {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
List<Integer> collect = list.stream()
.limit(4)
.skip(2)
.collect(Collectors.toList());
System.out.println(collect);
}
}
两个执行的前后顺序不一样的话,获取到的结果也是不一样的。
3.3、映射
在对集合进行操作的时候,我们经常会从对象选择性的提取某些数据的值,就像编写sql一样,指定获取表中的特定数据列。
select name from Student
public class demo1 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student(1,"张三","F",18));
list.add(new Student(2,"李四","M",19));
list.add(new Student( 3,"王五","F",20));
list.add(new Student( 4,"赵六","M",21));
list.add(new Student( 4,"赵六","M",21));
List<String> collect = list.stream().map(Student::getName).collect(Collectors.toList());
List<String> stringList = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9");
List<Integer> integerList = stringList.stream().map(Integer::parseInt).collect(Collectors.toList());
int sum = stringList.stream().mapToInt(Integer::parseInt).sum();
System.out.println(collect);
}
}
3.4、匹配
在日常的开发中,有时还需要判断集合中的某些元素是否匹配对应的条件,如果有可以进行后续操作,在Stream中提供了相关方法供我们使用,比如anyMatch、allMatch等。
anyMatch:判断条件至少匹配一个元素,主要用于判断六中的元素是否至少存在一个符合条件的元素, 他返回的是一个Boolean值,并且对于它的操作一般叫做短路求值。
短路求值:对于集合的一些操作,我们无需处理整个集合就可以获得结果,比方说通过&&或者||连接一个判断调条件,这个就是短路。对于流来说,某些操作不用操作整个流就可以得到结果。
AllMatch()判断条件是否匹配所有元素,AllMatch的工作原理与anyMatch类似,但是执行anyMatch时,只要流中有一个元素符合条件就会返回true,而allMatch会判断流中所有的条件都符合条件,全部符合才会返回true。
public class demo1 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student(1,"张三","F",18));
list.add(new Student(2,"李四","M",19));
list.add(new Student( 3,"王五","F",20));
list.add(new Student( 4,"赵六","M",21));
list.add(new Student( 5,"孙琪","M",22));
boolean b = list.stream().anyMatch(student -> student.getAge() > 21);
System.out.println(b);
boolean b1 = list.stream().allMatch(student -> student.getAge() > 20);
System.out.println(b1);
}
}
3.5、查找
对于集合操作,有时需要从集合中查找中符合条件的元素,Stream中也提供了相关的API,findAny(和findFirst0,他俩可以与其他流操作组合使用。findAny用于获取流中随机的某一个元素,findFirst用于获取流中的第一个元素。至于一些特别的定制化需求,则需要自行实现。
public class demo1 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student(1,"张三","F",18));
list.add(new Student(2,"李四","M",19));
list.add(new Student( 3,"王五","F",20));
list.add(new Student( 4,"赵六","M",21));
list.add(new Student( 5,"孙琪","M",22));
Optional<Student> any = list.stream().filter(student -> student.getAge() > 18).findAny();
if (any.isPresent()){
Student student = any.get();
System.out.println(student);
}
}
}
3.6、规约
到现在截止,对于流的终端操作,我们返回的有boolean、Optional和List。 但是在集合操作中,我们经常会涉及对元素进行统计计算之类的操作,如求和、求最大值、最小值等,从而返回不同的数据结果。
public class dis {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 4, 3, 2, 1);
Integer reduce = list.stream().reduce(0, (x, y) -> x + y);
System.out.println(reduce);
Integer reduce1 = list.stream().reduce(0, Integer::sum);
System.out.println(reduce1);
Integer integer = list.stream().reduce(Integer::sum).get();
System.out.println(integer);
}
}
3.7、数值处理
Integer max = list.stream().reduce(Integer::max).get();
System.out.println(max);
list.stream().reduce(Integer::min).ifPresent(System.out::println);
list.stream().reduce(Integer::sum).ifPresent(System.out::println);
3.8、构建流
基于值:
Stream<String> stream = Stream.of("one", "two", "three", "four");
stream.forEach(System.out::println);
Integer[] integers = {1, 2, 3, 4, 5, 6, 7, 8, 9};
Stream<Integer> stream1 = Stream.of(integers);
stream1.forEach(System.out::println);
基于文件:
public class filedemo {
public static void main(String[] args) throws IOException {
Files.list(Paths.get("")).forEach(path -> {
System.out.println(path);
try {
Files.lines(path).forEach(c->{
System.out.println(c);
});
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
}
3.9、收集器
通过使用收集器,可以让代码更加方便的进行简化与重用。其内部主要核心是通过Collectois完成更加复杂的计算转换,从而获取到最终结果。并且Collectors内部提供了非常多的常用静态方法,直接拿来就可以了。比方说:toList。
public class demo1 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student(1,"张三","F",18));
list.add(new Student(2,"李四","M",19));
list.add(new Student( 3,"王五","F",20));
list.add(new Student( 4,"赵六","M",21));
list.add(new Student( 5,"孙琪","M",22));
Map<String, List<Student>> collect = list.stream().collect(Collectors.groupingBy(Student::getSex));
System.out.println(collect);
}
}
收集集合总数、最大值、最小值
public class demo1 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student(1,"张三","F",18));
list.add(new Student(2,"李四","M",19));
list.add(new Student( 3,"王五","F",20));
list.add(new Student( 4,"赵六","M",21));
list.add(new Student( 5,"孙琪","M",22));
Long collect = list.stream().collect(Collectors.counting());
Optional<Student> collect1 = list.stream().collect(Collectors.maxBy(Comparator.comparing(Student::getAge)));
Student student = collect1.get();
System.out.println(student);
Optional<Student> collect2 = list.stream().collect(Collectors.minBy(Comparator.comparing(Student::getAge)));
System.out.println(collect2.get());
}
}
平均值,求和
public class demo1 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student(1,"张三","F",18));
list.add(new Student(2,"李四","M",19));
list.add(new Student( 3,"王五","F",20));
list.add(new Student( 4,"赵六","M",21));
list.add(new Student( 5,"孙琪","M",22));
Integer collect = list.stream().collect(Collectors.summingInt(Student::getAge));
int sum = list.stream().mapToInt(Student::getAge).sum();
Double collect1 = list.stream().collect(Collectors.averagingDouble(Student::getAge));
list.stream().mapToDouble(Student::getAge).average();
}
}