目录
一、Lambda表达式
1.Lambda 表达式的由来
为了编写这类处理批量数据的并行类库,需要在语言层面上修改现有的 Java:增加 Lambda 表达式。
2.什么是函数式编程
在思考问题时,使用不可变值和函数,函数对一个值进行处理,映射成另一个值。
3.Lambda 表达式的不同形式
#无参无返回的lambda表达式
Runnable noArguments = () -> System.out.println("Hello World");
#有参无返回的lambda表达式
ActionListener oneArgument = event -> System.out.println("button clicked");
#将行为写在大括号里的lambda表达式
Runnable multiStatement = () -> {
System.out.print("Hello");
System.out.println(" World");
};
#有参又返回省略参数类型的lambda表达式
BinaryOperator<Long> add = (x, y) -> x + y;
#有参又返回的lambda表达式
BinaryOperator<Long> addExplicit = (Long x, Long y) -> x + y;
4.自定一个Lambda表达式及简单使用
1.定义一个函数接口
public interface Operate {
boolean getResult(int t);
}
2.lambda表达式的使用(传入行为)
Operate operate = (c) -> c > 5;
3.lambda表达式的调用(实现)
boolean b=operate.getResult(3);
这里的operate 就是一个行为,在使用lambda表达式的时候我们可以通过传入不同的行为如( c ) -> c <5,那么我们就会得到我们想要的另一种结果,这就是函数式编程。
5.java为我们提供的函数接口
接口 | 参数 | 返回类型 | 示例 |
---|---|---|---|
Predicate | T | boolean | 这张唱片已经发行了吗 |
Consumer | T | void | 输出一个值 |
Function<T,R> | T | R | 获得 Artist 对象的名字 |
Supplier | None | T | 工厂方法 |
UnaryOperator | T | T | 逻辑非(!) |
BinaryOperator | (T, T) | T 求两个数的乘积(*) |
二、流式编程
java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种,最终操作返回一特定类型的计算结果,而中间操作返回Stream本身,这样你就可以将多个操作依次串起来。当最终操作发生时则次操作序列结束。Stream 的创建需要指定一个数据源,比如 java.util.Collection的子类,List或者Set。Stream的操作可以串行执行或者并行执行。
下面我们直接上代码展示Stream的用法
1.准备工作给定一个实体类StreamUseEntity
import lombok.Data;
import java.util.List;
public class StreamUseEntity {
@Data
public class Test{
private String s;
}
@Data
public static class Artist {
private String name;
private List<String> members;
private String origin;
}
@Data
public static class Track {
private String name;
}
@Data
public static class Album {
private String name;
private List<Track> tracks;
private List<Artist> artists;
}
}
2.Stream测试类
import org.junit.Before;
import org.junit.Test;
import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static com.zzx.insert.lambda.StreamUseEntity.*;
public class SimpleLambda {
private List<Album> albums;
private List<Artist> artists;
private List<Track> tracks;
@Before
public void before() {
Track track = new Track();
track.setName("hello lambda");
Track track1 = new Track();
track1.setName("It's my life");
tracks = Arrays.asList(track, track1);
Artist artist = new Artist();
artist.setName("theband");
artist.setMembers(Arrays.asList("zhangsan", "lisi"));
artist.setOrigin("china");
Artist artist1 = new Artist();
artist1.setName("theband2");
artist1.setMembers(Arrays.asList("holi", "mota"));
artist1.setOrigin("america");
Artist artist2 = new Artist();
artist2.setName("person");
artist2.setMembers(Arrays.asList("zhangsan", "lisi", "wang"));
artist2.setOrigin("china");
artists = Arrays.asList(artist, artist1, artist2);
Album album = new Album();
album.setArtists(artists);
album.setTracks(tracks);
album.setName("album");
Track trackx = new Track();
trackx.setName("hello lambda 2");
Track trackx1 = new Track();
trackx1.setName("It's my life 2");
List<Track> tracksx = Arrays.asList(trackx, trackx1);
Artist artistx = new Artist();
artistx.setName("theband 2");
artistx.setMembers(Arrays.asList("zhangsan 2", "lisi 2"));
artistx.setOrigin("china");
Artist artistx1 = new Artist();
artistx1.setName("theband2 2");
artistx1.setMembers(Arrays.asList("holi 2", "mota 2"));
artistx1.setOrigin("america");
Artist artistx2 = new Artist();
artistx2.setName("person 2");
artistx2.setMembers(Arrays.asList("zhangsan 2", "lisi 2"));
artistx2.setOrigin("china");
List<Artist> artistsx = Arrays.asList(artistx, artistx1, artistx2);
Album album1 = new Album();
album1.setArtists(artistsx);
album1.setTracks(tracksx);
album1.setName("album1");
albums = Arrays.asList(album, album1);
}
public void test(BinaryOperator<Integer> plus, int a, int b) {
plus.apply(a, b);
}
public interface MyFunction<R, T> {
R apply(T t);
}
public void streamTest() {
List<String> collected = Stream.of("a", "b", "c")
.collect(Collectors.toList());
System.out.println(collected.get(0));
}
public void listStream() {
List<Integer> integerList = Arrays.asList(1, 2, 3);
Set<String> stringList = integerList.stream().map(String::valueOf).collect(Collectors.toCollection(HashSet::new));
}
/**
* 收集器
*/
@Test
public void biggestGroup() {
Function<Artist, Integer> getCount = artist -> artist.getMembers().size();
Optional result = artists.stream().collect(Collectors.maxBy(Comparator.comparing(getCount)));
result.ifPresent(count -> System.out.println(count));
}
/**
* 收集器,求平均
*/
@Test
public void avrageMusicNum() {
double result = albums.stream().collect(Collectors.averagingDouble(target -> target.getTracks().size()));
System.out.println(result);
}
/**
* 收集器,布尔分组
*/
@Test
public void partitionTest() {
Map<Boolean, List<Artist>> result = albums.stream()
.flatMap(art -> art.getArtists().stream())
.collect(Collectors.partitioningBy(arts -> arts.getName().startsWith("the")));
System.out.println(result);
}
/**
* 收集器,分组
*/
@Test
public void groupingByTest() {
Map<String, List<Artist>> result = albums.stream()
.flatMap(art -> art.getArtists().stream())
.collect(Collectors.groupingBy(Artist::getName));
System.out.println(result);
}
/**
* 收集器,字符串处理
*/
@Test
public void toStringTest() {
String result = albums.stream()
.flatMap(art -> art.getArtists().stream())
.map(Artist::getName)
.collect(Collectors.joining(",", "[", "]"));
System.out.println(result);
}
/**
* 收集器,分组,并且分组后计数
*/
@Test
public void groupingCountTest() {
Map<String, Long> result = albums.stream()
.flatMap(art -> art.getArtists().stream())
.collect(Collectors.groupingBy(Artist::getName, Collectors.counting()));
System.out.println(result);
}
/**
* 收集器嵌套,分组,并且分组后把一种结果转换成另一种结果
*/
@Test
public void groupingCountTest2() {
Map<String, List<Character>> result = albums.stream()
.flatMap(art -> art.getArtists().stream())
.collect(Collectors.groupingBy(Artist::getName, Collectors.mapping(Artist::getName, Collectors.mapping(str -> str.charAt(0), Collectors.toList()))));
System.out.println(result);
}
@Test
public void diyCollector() {
}
/**
* 练习
*/
@Test
public void practice(){
Map<String, Long> result = Stream.of("sadf", "sdf", "sdf").collect(Collectors.groupingBy(a-> a, Collectors.counting()));
System.out.println(result);
}
}
三、推荐资源
《JAVA8 函数式编程》
大家要想了解得更深入推荐大家看看《JAVA8 函数式编程》这本书。