1.出现的背景
java是面向对象语言,除了部分简单数据类型,Java中的一切都是对象,即使数组也是一种对象,每个类创建的实例也是对象.在java中的定义的函数或方法不可能完全独立,也不能将方法作为参数或返回一个方法给实例.
在java 8以前,若我们想要把某些功能传递给某个方法,总要去写匿名类.代码示例
list.sort(new Comparator<User>(){
@Override
public int compare(User o1,User o2){
return o1.getId()-o2.getId();
}
}在上面的例子里,为了对集合集合进行排序,我们为Comparator接口创建了一个它的匿名内部类对象,重写接口中的方法,来实现排序功能.
简而言之,在java里将普通的方法或函数像参数一样传值并不简单,为此,java 8 增加了一个语言级的新特性,名为Lambda表达式
2.Lambda表达式简介
lambda 表达式是一个匿名函数,我们可以把lambda 表达式理解为一段可以传递的代码(将代码段像数据一样传递),使用它可以写出更简洁,更灵活的代码.作为一种更紧凑的代码风格,使java语言的表达式能力得到的提升
Lambda表达式的本质只是一个"语法糖",由编译期推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能
3.Lambda表达式的结构
Lambda 表达式可以具有零个,一个或多个参数.
可以显式声明参数的类型,也可以由编译器自动从上下文推断参数的类型,例如(int a,int b)与(a,b)相同
参数用小括号括起来,用逗号分隔.例如:(a,b)或(int a,int b)或(String a,int b,float c).
空括号用于表示一组空的参数.例如()->42.
当有且仅有一个参数时,如果不显式指明类型,则不必使用小括号.
例如 a-> return a*a.
Lambda 表达式的正文可以包含零条,一条或多条语句.
如果Lambda表达式的正文只有一条语句,则大括号可不用写,且表达式的返回值类型要与匿名函数的返回类型相同.
如果Lambda 表达式的正文有一条以上的语句必须包含在大括号(代码块)中,且表达式的返回值类型要与匿名函数的返回类型相同.
Java中的Lambda 表达式通常使用(argument)->(body)语法书写,例如:
左侧:lambda表达式的参数列表
右侧:lambda表达式中需要执行的功能,即lambda体
(arg1,arg2...)->{body}
(type1 arg1,type2 arg2...)->{body}以下是一些Lambda表达式的例子
无参数,无返回值,lambda体中只有一行代码时,{}可以忽略
()->System.out.println("Hello World");
五参数,有返回值
()->{return 3.1415};有参数,无返回值
(String s)->{System.out.println(s);}
有一个参数,无返回值
s->{System.out.println(s);}
有多个参数,有返回值
(int a,int b)->{return a+b;}
有多个参数,表达式参数类型可以不写,jvm可以根据上下文进行类型推断
(a,b)->{return a-b;}eg1:
package com.ffyc.lambdaStream;
public class Car {
private int num;
private String name;
private String color;
public Car(int num, String name) {
this.num = num;
this.name = name;
}
public Car(int num, String name, String color) {
this.num = num;
this.name = name;
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Car{" +
"num=" + num +
", name='" + name + '\'' +
'}';
}
}
package com.ffyc.lambdaStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class TestCar {
public static void main(String[] args) {
Car car1 = new Car(101, "car1");
Car car2 = new Car(102, "car2");
Car car3 = new Car(103, "car3");
Car car4 = new Car(104, "car4");
Car[] cars = {car2,car1,car4,car3};
/*
java是面向对象的语言,向方法传递参数不能是单个函数.
sort需要一个比较的函数,只能创建一个对象,将方法包装在对象中传递
可以通过创建匿名内部类对象,将比较函数包装起来.
java8之后为了再次简化语法,推出lambda语言
lambda就是一个匿名函数,简化匿名内部类语法,
以后可以将匿名函数当做参数传递, 由java根据语言进行推断,补全常规代码
*/
/*Arrays.sort(cars, new Comparator<Car>() {
@Override
public int compare(Car o1, Car o2) {
return 0;
}
});*/
Arrays.sort(cars,(Car c1,Car c2)->{
return c1.getNum()-c2.getNum();
});
//(a) -> {
// asdsadsa
// }eg2:
package com.ffyc.lambdaStream;
@FunctionalInterface//表示是一个功能函数接口,接口中只能定义一个抽象方法
public interface Oper {
//使用lambda表达式接口中,只能有一个抽象方法,因为需要自动类型推断
//void show();
int add(int a,int b);
//void show1();
}
package com.ffyc.lambdaStream;
public class TestOper {
public void test(Oper oper){
//oper.show();
oper.add(2,5);
}
public static void main(String[] args) {
TestOper testOper = new TestOper();
/* testOper.test(()->{
System.out.println("aaaaaaaaaaaaa");
System.out.println("aaaaaaaaaaaaa");
});*/
/*
testOper.test((a,b)->{
int c = a+b;
return c;
});
*/
testOper.test((a,b)->{ return a+b;});
new Thread(()->{
for (int i = 0; i <1000 ; i++) {
}
}).start();
/* 创建一个匿名内部类对象,重写接口中的show方法,将匿名对象传递到test方法中
testOper.test(new Oper() {
@Override
public void show() {
System.out.println("显示信息");
}
});*/4.什么是功能接口(Functional interface)
Lambda表达式只支持函数式接口,也就是说只有一个抽象方法的接口,功能接口是java 8中的新增功能,他们只允许一个抽象方法.这些接口也称为但抽象接口.java8也引入了一个注释,即@FunctionalInterface,当你注释的接口违反了Functional Interface的契约时,它可以用于编译器级错误
以下是自定义功能接口的示例:
@FunctionalInterface
public interface WorkerInterface{
public void doSomeWork();
}正如其定义所述,功能接口只能有一个抽象方法.如果我们尝试在其中添加一个抽象方法,则会抛出编译时错误.例如:
@FunctionalInterface
public interface WorkerInterface{
public void dowork();
public void doMoreWork();
}案例:
@FunctionalInterface
public interface Shape{
void area(int a,int b);
}
Shape d=(a,b)->(System.out.println(a+b);};
d.area(1,2);Java8&Stream
什么是Stream?
Stream是Java8的新特性,它允许你以声明式的方式处理数据集合,可以把他看做是遍历数据集的高级迭代器.此外与Stream与lambda表达式结合后编码效率与大大提高,并且可读性更强
要澄清的是java8中的stream与InputStream和OutoutStream是完全不同的概念
简单案例:
public static void main(String[] args){
List<Apple> applestore=new ArrayList();
applestore.add(new Apple(1,"red',500,"河南"));
applestore.add(new Apple(2,"red",400,"陕西"));
applestore.add(new Apple(3,"green",300,"上海"));
applestore.add(new Apple(4,"green",200,"湖北"));
applestore.add(new Apple(5,"green",100,"湖南"));
}我们的需求是在applestore集合中找出红色苹果手机.
使用Stream流快速实现操作
List<Apple> apples=applestore
.stream()
.filter(a->a.getColor().equals("red"))
.collect(Collectors.toList());这里使用的就是Java8中的stream流,使用的是声明性方式写的:说明想要完成什么(筛选,排序,取值),而不说明如何实现一个操作(for 循环).同时可以将这些操作链接起来,达到一种流水线式的效果
集合->流-->filter->流->sorted->流->map->rersult
Java8中的集合支持一个新的Stream方法,它会返回一个流
什么是流呢?
简单的定义,就是从"从支持数据处理操作的源,生成的元素序列'.
元素列表:和集合一样,;流也提供了一个接口,访问特定元素类型的一组有序值.
数据源:获取数据的源,比如集合.
数据处理操作:流更偏向于数据处理和计算,比如filter,map,find,sort等.
简单来说,我们通过一个集合的stream方法获取一个流,然后对流进行一系列流操作,最后再构建我们需要的数据集合.
语法:
stream of elements +------->|filter+->|map+->|collect|+
List<Integer> list=
widgets.stream()
.filter(b->b.getColor()==RED)
.sorted((x,y)->x.getWeight()-y.getWeight())
.sum();获取流
使用Collection接口下的stream
List<String> list=new ArrayList<>();
List<String> list=new ArrayList<>();
Stream<String> stream=list.stream();
使用Arrays中的stream()方法,将数组转成流
Integer[] nums=new Integer[10];
Stream<Integer> stream=Arrays.stream(nums);使用Stream中的静态方法:of()
Stream<Integer> stream=Stream.of(1,2,3,4,5,6);
eg:
package com.ffyc.lambdaStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;
public class StreamDemo {
/*
Stream 流 是java8推出的新功能, 与IO流完全不同的.
提供了对象数据集合进行操作的各种方法,我们只需要声明式的告诉其应该做什么.
java中的集合,数组主要是存储数据,而Stream主要作用是对集合进行操作.
获取流 流的中间操作 终端操作
数据集合-->Stream-->filter-->Stream-->sorted-->流-->tolist/sum/max--->result
就是一个对集合进行遍历操作的高级迭代器.
*/
//获取流 中间操作 终端操作
public static void main(String[] args) {
Integer[] array = {4,2,1,3,5};
Arrays.stream(array);
Stream.of(4,2,1,3,5);
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(5);
list.add(2);
list.add(4);
list.stream();
}
}使用BufferedReader.lines()方法,将每行内容转成流
BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));
Stream<String> lineStream=reader.lines();流操作
流操作可以分为两类:中间操作和终端操作.回看之前的代码:
List<Apple> apples=applestore
.stream() 获得流
.filter(a->a.getColor.equals("red")) 中间操作
.collect(Collectors.toList()); 终端操作简化一下就是:
数据源=>中间操作=>终端操作=>结果
诸如filter或者sort等中间操作会返回另一个流,进而进行下一步操作,而终端操作则是将流关闭,构建新的数据集合对象(也可以不构建).
中间操作
filter:过滤流中的某些元素
sorted():自然排序,流中的元素需实现Comparable接口
distinct:去除重复元素
limit(n):获取n个元素
skip(n):跳过n元素,配合limit(n)可实现分页
map();将其映射成一个新的元素
终端操作
forEach:遍历流中的元素
toArray:将流中的元素倒入一个数组
Min:返回流中元素最小值
Max:返回流中元素最大值
count:返回流中元素的总个数
Reduce:所有元素求和
anyMatch:接收一个Predicate函数,只要流中有一个元素满足条件则返回true,否则返回false
allMatch:接收一个Predicate函数,当流中每个元素都符合条件时才返回true否则返回false
findFirst:返回流中第一个元素
collect:将流中的元素倒入一个集合,Collection或Map
eg1:
package com.ffyc.lambdaStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;
public class StreamDemo1 {
/*
Stream 流 是java8推出的新功能, 与IO流完全不同的.
提供了对象数据集合进行操作的各种方法,我们只需要声明式的告诉其应该做什么.
java中的集合,数组主要是存储数据,而Stream主要作用是对集合进行操作.
获取流 流的中间操作 终端操作
数据集合-->Stream-->filter-->Stream-->sorted-->流-->tolist/sum/max--->result
就是一个对集合进行遍历操作的高级迭代器.
*/
//获取流 中间操作 终端操作
public static void main(String[] args) {
Integer[] array = {4,2,1,3,1,5,6,8,7};
Arrays.stream(array) //返回一个Stream对象
.distinct()
.filter((e)->{ return e<6;}) //对流进行一个过滤操作,又返回一个流对象
.sorted((a,b)->{ return a-b;}) //对流进行一个排序操作,又返回一个流对象
.skip(0) //跳过指定数量的元素
.limit(2) //限制取出的个数
.forEach((e)->{
System.out.println(e);
});
eg2;
package com.ffyc.lambdaStream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamDemo2 {
/*
Stream 流 是java8推出的新功能, 与IO流完全不同的.
提供了对象数据集合进行操作的各种方法,我们只需要声明式的告诉其应该做什么.
java中的集合,数组主要是存储数据,而Stream主要作用是对集合进行操作.
获取流 流的中间操作 终端操作
数据集合-->Stream-->filter-->Stream-->sorted-->流-->tolist/sum/max--->result
就是一个对集合进行遍历操作的高级迭代器.
*/
//获取流 中间操作 终端操作
public static void main(String[] args) {
Integer[] array = {4,2,1,3,1};
long count = Arrays.stream(array) //返回一个Stream对象
.distinct()
.sorted((a,b)->{return a-b;})
.limit(5)
.count();//终端操作,返回最终处理的结果
System.out.println(count);
Integer max = Arrays.stream(array) //返回一个Stream对象
.distinct()
.max((a,b)->{return a-b;})
.get();
System.out.println(max);
Integer sum = Arrays.stream(array) //返回一个Stream对象
.distinct()
.reduce((a,b)->{ return a+b;})
.get();
System.out.println(sum);
Object [] objs = Arrays.stream(array)
.distinct()
.toArray();
System.out.println(Arrays.toString(objs));
boolean b = Arrays.stream(array)
.distinct()
//.anyMatch((e)->{return e<5;});//只要有一个元素满足返回true
.allMatch((e)->{return e<5;}); //所有的元素都必须满足条件 返回true
System.out.println(b);
List<Integer> list= Arrays.stream(array)
.distinct()
.collect(Collectors.toList());
System.out.println(list);eg3:
package com.ffyc.lambdaStream;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
public class StreamDemo3 {
/*
Stream 流 是java8推出的新功能, 与IO流完全不同的.
提供了对象数据集合进行操作的各种方法,我们只需要声明式的告诉其应该做什么.
java中的集合,数组主要是存储数据,而Stream主要作用是对集合进行操作.
获取流 流的中间操作 终端操作
数据集合-->Stream-->filter-->Stream-->sorted-->流-->tolist/sum/max--->result
就是一个对集合进行遍历操作的高级迭代器.
*/
//获取流 中间操作 终端操作
public static void main(String[] args) {
Car car1=new Car(101,"宝马1","红色");
Car car2=new Car(102,"宝马2","黑色");
Car car3=new Car(103,"宝马3","蓝色");
Car car4=new Car(104,"宝马4","白色");
Car car5=new Car(105,"宝马5","绿色");
Car[] cars = {car1,car2,car3,car4,car5};
List<Car> listcar = Arrays.stream(cars)
.sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
.filter((c)->{ return c.getColor().equals("红色");})
.collect(Collectors.toList());
System.out.println(listcar);
/* Set<Car> setcar = Arrays.stream(cars)
.sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
.collect(Collectors.toSet());
System.out.println(setcar);*/
Map<Integer,String> carmap = Arrays.stream(cars)
.sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
.collect(Collectors.toMap(Car::getNum, Car::getColor));
System.out.println(carmap);
List<Integer> listnum = Arrays.stream(cars)
.map(Car::getNum)
.collect(Collectors.toList());
System.out.println(listnum);
扫一扫
342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
