lombok+stream技术总结_lombok的stream流注解

lombok使用

lombok安装

idea自行下载插件，eclipse在安装路径下安装lombok.jar同时在eclipse.ini下配置

-javaagent:lombok.jar

-Xbootclasspath/a:lombok.jar

lombok使用

@Getter和@Setter

为属性提供getting和setting方法

@NoArgsConstructor

注解在类上；为类提供一个无参的构造方法

@AllArgsConstructor

注解在类上；为类提供一个全参的构造方法

@ToString

提供一个toString方法

@Cleanup

消除 try/catch/finally 块的冗余

@Data作用

注解在类上；提供类所有属性的 getting 和 setting 方法，此外还提供了hashCode、toString 方法

在注解@Setter、@Getter、@ToString后面添加exclude=”**“代表相应的方法不包括**字段

如

@ToString(exculde=”color”)

则在toString方法里面忽略color属性

lambda用法

(params) -> expression

(params) -> statement

(params) -> { statements }

例子

() -> System.out.println("Hello Lambda Expressions");

Stream用法

Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)

流的特点

• 单向 不可往复 数据只能遍历一次
• 可以并行化操作
• 数据源本身可以是无限的

流的构成

使用流的时候，通常包括三个步骤：

• 获取一个数据源
• 数据转换
• 执行操作获取想要的结果

常见的生成数据源的方式

从Collection和数组
1

• Collection.stream()
• Collection.parallelStream()
• Arrays.stream() or Stream.of()

对流的操作类型分为两种

• Intermediate（中间操作）：一个流后面可以跟随零个或多个Intermediate操作。其目的是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作是惰性化的。即仅仅调用到这类方法，并没有开始流的遍历
• Terminal（最终操作）：一个流只能有一个Terminal操作，当这个操作执行代表流的结束。Terminal操作的执行才是开始流的遍历

例子：

int sum = widgets.stream()
.filter(w -> w.getColor() == RED)
.mapToInt(w -> w.getWeight())
.sum();

流的构造

//1.具体的值
Stream stream0=Stream.of("a","b","c");
//2.Arrays
String[] strArray=new String[]{"a","b","c"};
Stream stream1=Stream.of(strArray);
Stream stream2=Arrays.Stream(strArray);
//3.Collections
List<String> list = Arrays.asList(strArray);
Stream stream3 = list.steam();
1
2
3
4
5
6
7
8
9

对于基本数据类型，对应三种包装类型Stream:

• IntStream
• LongStream
• DoubleStream

eg

IntStream.of(new int[]{1,2,3}).forEach.(System.out::println);

//结果为1 2
IntStream.range(1,3).forEach(System.out::println);

//结果为1 2 3
IntStream.rangeClosed(1, 3).forEach(System.out::println);
1
2
3
4
5
6
7

流的转换

//1.Array
String[] strArray1 = stream.toArray(String[]::new);
//2.Collection
List<String> list = stream.collect(Collections.toList());
Set set = stream.collect(Collections.toSet());
//3.String
String string = stream.collect(Collections.join()).toString();
1
2
3
4
5
6
7

流的操作

常见操作归类如下：

-Intermediate：

map(mapToInt,flatMap等),filter,sorted,distinct,peek,limit,skip,parallel,sequential,unordered
1

- Terminal:

forEach,forEachOrdered,toArray,reduce,collect,min,max,count,anyMatch,allMatch,noneMatch,findFirst,findAny,iterator
1

map/flatMap

作用是将input Stream的每一个元素转换成outpu Stream的另外一个元素
1

• 转换为大写

  List output = wordList.stream().map(String::toUpperCase).collect(Collections.toList());

  -平方数

  List nums = Arrays.asList(1,2,3,4);
  List squareNums = nums.stream().map(n -> n*n).collet(Collections.toList());

上面的map生成的是1:1 映射，对于1对多的映射关系需要使用flatMap

Stream<List<Integer>> inputStream = Stream.of(Arrays.asList(1),Arrays.asList(2,3),Arrays.asList(4,5,6));
Stream<Integer> outputStream = inputStream.flatMap(n ->n.stream());
1
2

filter

filter 是对原始的Stream进行某种测试，通过测试的元素被留下来生成一个新的Stream

• 留下偶数

  Integer[] nums = {1,2,3,4,5,6};

  Integer evens = Stream.of(nums).filter(n -> n%2==0).toArray(Integer[]::new);

peek

返回一个符合条件的stream
1

findFrist

返回 Stream 的第一个元素，或者空
它的返回值是Optional:作为一个容器，目的是避免空指针异常
Optional:A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value. 
Optional.get():值存在时返回值，不存在抛出NoSuchElementException;
Optional.ifPresent(Consumer<? super T> consumer):值存在时执行consumer操作，不存在值是不做任何;
Optional.isPresent():值存在时返回TRUE，不然doNothing;
Optional.orElse(T other):值存在时返回对应值，不存在是返回other
Optional.ofNullable(T value):值存在时返回一个描述value的Optional，不然返回一个空的Optional
1
2
3
4
5
6
7
8

Optional.ofNullable(text).ifPresent(System.out::println)
等价于if(text!=null){System.out.println(text)}

return Optional.ofNullable(text).map(String::length).orElse(-1);等价于return if (text!=null)?text.length():-1;

Stream中的findAny  max/min等方法也是返回Optional值
1

reduce

三个重载方法
1

- Optional reduce(BinaryOperator accumulator);
- T reduce(T identity, BinaryOperator accumulator);
- <U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner)

第一个方法返回一个Optional:
`Optional<Integer> sum = Arrays.asList(1,2).stream().reduce((a,b) -> a*b);`
第二个方法是提供一个起始值，然后根据运算规则和前面的Stream的第一、第二...第N个元素组合
`Integer sum = Arrays.asList(1,2).stream().reduce(2, (a, b) -> a*b);`
的结果sum等于4
第三种方法。。。。
1
2
3
4
5
6

limit skip

limit 是返回Stream的前n个元素，skip是扔掉前n个元素
1

Arrays.asList(1,2,3,4,5,6).stream().limit(5).skip(1).forEach(System.out::println);
的结果是2 3 4 5

sorted

对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间

distinct

去重
1

Match

Stream 有三个 match 方法
1

• allMatch: Stream中的元素全部符合,返回TRUE
• anyMatch: Stream 只要有一个满足 true
• noneMatch: 一个都不满足 true