Lambda表达式
如果不适用lambda表达式的话，可以使用匿名内部类，但是代码会显得有点多
lambda表达式其实就是匿名内部类
Lambda表达式简化了匿名内部类的使用，语法更加简单。
语法规则
(参数类型 参数名称) -> {
代码体;
}Lambda表达式使用的接口只能有一个抽象方法，可以使用@FunctionalInterface修饰
Lambda表达式本质
1. Lambda表达式在程序运行的时候会形成一个类
2. 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码
3. 还会形成一个匿名内部类，实现接口，重写抽象方法
4. 在重写的方法中，会调用新生成的方法
XJad：反编译工具，可以查看生成的代码
Lambda表达式省略写法
1. 小括号内的参数类型可以省略
2. 如果小括号内有且仅有一个参数，则小括号可以省略
3. 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。
Lambda表达式的使用前提
1. 方法的参数或局部变量类型必须为接口才能使用Lambda
2. 接口中有且仅有一个抽象方法(@FunctionalInterface)
Lambda表达式和匿名内部类的区别
-
所需类型不一样
-
匿名内部类的类型可以是 类，抽象类，接口
-
Lambda表达式需要的类型必须是接口
-
-
抽象方法的数量不一样
-
匿名内部类所需的接口中的抽象方法的数量是随意的
-
Lambda表达式所需的接口中只能有一个抽象方法
-
-
实现原理不一样
-
匿名内部类是在编译后形成一个class
-
Lambda表达式是在程序运行的时候动态生成class
-
Jdk8中接口改变
jdk8之前，接口中只能有静态常量和抽象方法；
jdk8之后，接口中可以有静态方法和默认方法；
默认方法
为什么要新增默认方法
如果没有默认方法，一个接口中新增一个抽象方法，所有实现类都必须重写该方法，不利于接口的扩展
默认方法使用default修饰
如果实现类没有重写默认方法，也可以直接调用接口中的默认方法
实现类也可以重写默认方法，这样调用的就是重写方法了
静态方法
静态方法也是为了接口扩展
静态方法不能被实现类重写，只能通过接口类型直接调用
函数式接口
使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。
为了更好的使用Lambda表达式，在JDK中提供了大量常用的函数式接口
Supplier
无参，有返回值
需要提供一个返回值类型T
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}Consumer
有参无返回值
需要提供一个泛型来定义参数类型
@FunctionalInterface
public interface Consumer<T> {
void accept(T var1);
default Consumer<T> andThen(Consumer<? super T> var1) {
Objects.requireNonNull(var1);
return (var2) -> {
this.accept(var2);
var1.accept(var2);
};
}
}consumer有一个默认方法andThen
如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法 andThen方法
Function
有参有返回值
T是参数，R是返回值
@FunctionalInterface
public interface Function<T, R> {
R apply(T var1);
default <V> Function<V, R> compose(Function<? super V, ? extends T> var1) {
Objects.requireNonNull(var1);
return (var2) -> {
return this.apply(var1.apply(var2));
};
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> var1) {
Objects.requireNonNull(var1);
return (var2) -> {
return var1.apply(this.apply(var2));
};
}
static <T> Function<T, T> identity() {
return (var0) -> {
return var0;
};
}
}andThen用于组合操作
compose方法的作用顺序和andThen方法刚好相反
静态方法identity，输入什么参数就返回什么参数
Predicate
有参，且返回值为boolean
@FunctionalInterface
public interface Predicate<T> {
boolean test(T var1);
default Predicate<T> and(Predicate<? super T> var1) {
Objects.requireNonNull(var1);
return (var2) -> {
return this.test(var2) && var1.test(var2);
};
}
default Predicate<T> negate() {
return (var1) -> {
return !this.test(var1);
};
}
default Predicate<T> or(Predicate<? super T> var1) {
Objects.requireNonNull(var1);
return (var2) -> {
return this.test(var2) || var1.test(var2);
};
}
static <T> Predicate<T> isEqual(Object var0) {
return null == var0 ? Objects::isNull : (var1) -> {
return var0.equals(var1);
};
}
}方法引用
在lambda表达式中进行其他方法调用
public class YinYong {
public static void main(String[] args) {
testTotal(arr -> total(arr) );
}
public static void total(int[] arr){
int sum = 0;
for(int i: arr){
sum += i;
}
System.out.println("sum:" + sum);
}
public static void testTotal(Consumer<int[]> consumer){
int arr[] = {1,2,3,4,5};
consumer.accept(arr);
}
}使用方法引用可以简写为：
public class YinYong2 {
public static void main(String[] args) {
testTotal(YinYong2::total);
}
public static void total(int[] arr){
int sum = 0;
for(int i: arr){
sum += i;
}
System.out.println("sum:" + sum);
}
public static void testTotal(Consumer<int[]> consumer){
int arr[] = {1,2,3,4,5};
consumer.accept(arr);
}
}方法引用应用场景
如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。
方法引用的使用方式
instanceName::methodName 对象::方法名
Date date2 = new Date(2021,10,9);
Supplier<Integer> dateSup = date2::getYear;
Integer year = dateSup.get();
System.out.println(year);ClassName::staticMethodName 类名::静态方法
ClassName::methodName 类名::普通方法
// Function<String, Integer>中，String是参数类型，Integer是返回值类型
Function<String, Integer> function = String::length;
Integer length = function.apply("abcd");
System.out.println(length);
// BiFunction<String, Integer, String>中第一个String是BiFunction的apply方法的第一个参数hello
// Integer是apply方法的第二个参数3
// String 是返回值str
BiFunction<String, Integer, String> substringFunction = String::substring;
String str = substringFunction.apply("hello", 3);
System.out.println(str);ClassName::new 类名::new 调用的构造器
Supplier<LocalDate> now = LocalDate::now;
LocalDate localDate = now.get();
System.out.println(localDate);由于构造器的名称和类名完全一致，所以构造器引用使用::new的格式使用
// Long是Date的构造函数的参数类型，Date是构造函数返回值
Function<Long, Date> dateFunction = Date::new;
Date date = dateFunction.apply(123456789110L);
System.out.println(date);TypeName[]::new String[]::new 调用数组的构造器
// Integer是数组长度
Function<Integer, String[]> stringArr = String[]::new;
String[] strArr = stringArr.apply(5);方法引用是对Lambda表达式符合特定情况下的一种缩写方式，它使得我们的Lambda表达式更加的精简
Stream
没有stream之前，要对集合元素进行处理，就需要一遍遍的循环处理，很麻烦，代码量也比较大
这里的stream流和IO流没有任何关系
Stream流不是一种数据结构，不保存数据，而是对数据进行加工处理
获取stream流
通过Collection获取
Collection接口下的所有的实现都可以通过steam方法来获取Stream流，因为java.util.Collection 接口中加入了default方法 stream
List<String> list = new ArrayList<>();
list.stream();
Set<String> set = new HashSet<>();
set.stream();Map没有实现Collection接口，不能直接获取stream流，只能获取key、value或者entry的stream流
通过Stream的of方法
获取数组的stream流（基本数据类型的数组是不可以的int[]）
String[] arr = {"a","b","c"};
Stream.of(arr);Stream流常用方法
| 方法名 | 方法作用 | 返回值类型 | 方法种类 |
|---|---|---|---|
| count | 统计个数 | long | 终结 |
| forEach | 逐一处理 | void | 终结 |
| filter | 过滤 | Stream | 函数拼接 |
| limit | 取用前几个 | Stream | 函数拼接 |
| skip | 跳过前几个 | Stream | 函数拼接 |
| map | 映射 | Stream | 函数拼接 |
| concat | 组合 | Stream | 函数拼接 |
终结方法：返回值类型不再是 Stream 类型的方法，不再支持链式调用。本小节中，终结方法包括 count 和forEach 方法。
非终结方法：返回值类型仍然是 Stream 类型的方法，支持链式调用。（除了终结方法外，其余方法均为非终结方法。）
Stream注意事项(重要)
-
Stream只能操作一次
-
Stream方法返回的是新的流
-
Stream不调用终结方法，中间的操作不会执行
forEach方法
/**
* Performs an action for each element of this stream.
*
* <p>This is a <a href="package-summary.html#StreamOps">terminal
* operation</a>.
*
* <p>The behavior of this operation is explicitly nondeterministic.
* For parallel stream pipelines, this operation does <em>not</em>
* guarantee to respect the encounter order of the stream, as doing so
* would sacrifice the benefit of parallelism. For any given element, the
* action may be performed at whatever time and in whatever thread the
* library chooses. If the action accesses shared state, it is
* responsible for providing the required synchronization.
*
* @param action a <a href="package-summary.html#NonInterference">
* non-interfering</a> action to perform on the elements
*/
void forEach(Consumer<? super T> action);对流中的元素进行遍历
// 打印list中的元素
list.stream().forEach(System.out::println);count
count方法用来统计其中的元素个数的
/**
* Returns the count of elements in this stream. This is a special case of
* a <a href="package-summary.html#Reduction">reduction</a> and is
* equivalent to:
* <pre>{@code
* return mapToLong(e -> 1L).sum();
* }</pre>
*
* <p>This is a <a href="package-summary.html#StreamOps">terminal operation</a>.
*
* @return the count of elements in this stream
*/
long count(); long count = list.stream().count();filter
filter方法的作用是用来过滤数据的，返回符合条件的数据
可以通过filter方法将一个流转换成另一个子集流
/**
* Returns a stream consisting of the elements of this stream that match
* the given predicate.
*
* <p>This is an <a href="package-summary.html#StreamOps">intermediate
* operation</a>.
*
* @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,
* <a href="package-summary.html#Statelessness">stateless</a>
* predicate to apply to each element to determine if it
* should be included
* @return the new stream
*/
Stream<T> filter(Predicate<? super T> predicate); // 返回list中包含a的元素并打印出来
list.stream().filter(s-> s.contains("a")).forEach(System.out::println);limit
limit方法可以对流进行截取处理，只取前n个数据
/**
* Returns a stream consisting of the elements of this stream, truncated
* to be no longer than {@code maxSize} in length.
*
* <p>This is a <a href="package-summary.html#StreamOps">short-circuiting
* stateful intermediate operation</a>.
*
* @apiNote
* While {@code limit()} is generally a cheap operation on sequential
* stream pipelines, it can be quite expensive on ordered parallel pipelines,
* especially for large values of {@code maxSize}, since {@code limit(n)}
* is constrained to return not just any <em>n</em> elements, but the
* <em>first n</em> elements in the encounter order. Using an unordered
* stream source (such as {@link #generate(Supplier)}) or removing the
* ordering constraint with {@link #unordered()} may result in significant
* speedups of {@code limit()} in parallel pipelines, if the semantics of
* your situation permit. If consistency with encounter order is required,
* and you are experiencing poor performance or memory utilization with
* {@code limit()} in parallel pipelines, switching to sequential execution
* with {@link #sequential()} may improve performance.
*
* @param maxSize the number of elements the stream should be limited to
* @return the new stream
* @throws IllegalArgumentException if {@code maxSize} is negative
*/
Stream<T> limit(long maxSize);如果集合当前长度大于参数就进行截取，否则不操作
// 返回list中前5个元素并打印出来
list.stream().limit(5).forEach(System.out::println);skip
skip方法用于跳过前n个元素
/**
* Returns a stream consisting of the remaining elements of this stream
* after discarding the first {@code n} elements of the stream.
* If this stream contains fewer than {@code n} elements then an
* empty stream will be returned.
*
* <p>This is a <a href="package-summary.html#StreamOps">stateful
* intermediate operation</a>.
*
* @apiNote
* While {@code skip()} is generally a cheap operation on sequential
* stream pipelines, it can be quite expensive on ordered parallel pipelines,
* especially for large values of {@code n}, since {@code skip(n)}
* is constrained to skip not just any <em>n</em> elements, but the
* <em>first n</em> elements in the encounter order. Using an unordered
* stream source (such as {@link #generate(Supplier)}) or removing the
* ordering constraint with {@link #unordered()} may result in significant
* speedups of {@code skip()} in parallel pipelines, if the semantics of
* your situation permit. If consistency with encounter order is required,
* and you are experiencing poor performance or memory utilization with
* {@code skip()} in parallel pipelines, switching to sequential execution
* with {@link #sequential()} may improve performance.
*
* @param n the number of leading elements to skip
* @return the new stream
* @throws IllegalArgumentException if {@code n} is negative
*/
Stream<T> skip(long n); // 跳过list中前5个元素，并打印后面的元素
list.stream().skip(5).forEach(System.out::println);map
map方法可以将流中的元素映射到另一个流中
/**
* Returns a stream consisting of the results of applying the given
* function to the elements of this stream.
*
* <p>This is an <a href="package-summary.html#StreamOps">intermediate
* operation</a>.
*
* @param <R> The element type of the new stream
* @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
* <a href="package-summary.html#Statelessness">stateless</a>
* function to apply to each element
* @return the new stream
*/
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
将T类型的数据转换为R类型的数据
// 将list中所有元素拼接上abc并打印
list.stream().map(s-> s+"abc").forEach(System.out::println);sorted
sorted方法用于排序
/**
* Returns a stream consisting of the elements of this stream, sorted
* according to natural order. If the elements of this stream are not
* {@code Comparable}, a {@code java.lang.ClassCastException} may be thrown
* when the terminal operation is executed.
*
* <p>For ordered streams, the sort is stable. For unordered streams, no
* stability guarantees are made.
*
* <p>This is a <a href="package-summary.html#StreamOps">stateful
* intermediate operation</a>.
*
* @return the new stream
*/
Stream<T> sorted();
/**
* Returns a stream consisting of the elements of this stream, sorted
* according to the provided {@code Comparator}.
*
* <p>For ordered streams, the sort is stable. For unordered streams, no
* stability guarantees are made.
*
* <p>This is a <a href="package-summary.html#StreamOps">stateful
* intermediate operation</a>.
*
* @param comparator a <a href="package-summary.html#NonInterference">non-interfering</a>,
* <a href="package-summary.html#Statelessness">stateless</a>
* {@code Comparator} to be used to compare stream elements
* @return the new stream
*/
Stream<T> sorted(Comparator<? super T> comparator); // 将list中的数据进行排序
list.stream().sorted().forEach(System.out::println);
// 根据Comparator进行排序（字符串长度倒序）
list.stream().sorted((o1,o2)-> o2.length() - o1.length()).forEach(System.out::println);distinct
distinct方法用于去除重复数据
/**
* Returns a stream consisting of the distinct elements (according to
* {@link Object#equals(Object)}) of this stream.
*
* <p>For ordered streams, the selection of distinct elements is stable
* (for duplicated elements, the element appearing first in the encounter
* order is preserved.) For unordered streams, no stability guarantees
* are made.
*
* <p>This is a <a href="package-summary.html#StreamOps">stateful
* intermediate operation</a>.
*
* @apiNote
* Preserving stability for {@code distinct()} in parallel pipelines is
* relatively expensive (requires that the operation act as a full barrier,
* with substantial buffering overhead), and stability is often not needed.
* Using an unordered stream source (such as {@link #generate(Supplier)})
* or removing the ordering constraint with {@link #unordered()} may result
* in significantly more efficient execution for {@code distinct()} in parallel
* pipelines, if the semantics of your situation permit. If consistency
* with encounter order is required, and you are experiencing poor performance
* or memory utilization with {@code distinct()} in parallel pipelines,
* switching to sequential execution with {@link #sequential()} may improve
* performance.
*
* @return the new stream
*/
Stream<T> distinct(); // 去除list中重复元素
list.stream().distinct().forEach(System.out::println);Stream流中的distinct方法对于基本数据类型是可以直接出重的，但是对于自定义类型，需要重写hashCode和equals方法来移除重复元素。
match
match方法用于判断数据是否匹配指定的条件
boolean anyMatch(Predicate<? super T> predicate);
boolean allMatch(Predicate<? super T> predicate);
boolean noneMatch(Predicate<? super T> predicate); // 判断list中是否所有元素都包含a
boolean a = list.stream().allMatch(s -> s.contains("a"));
// 判断list中是否有元素包含a
boolean a2 = list.stream().anyMatch(s -> s.contains("a"));
// 判断list中是否所有元素都不包含a
boolean a3 = list.stream().noneMatch(s -> s.contains("a"));find
find方法用于查找某些数据
Optional<T> findFirst();
Optional<T> findAny(); // 获取list中第一个元素
Optional<String> first = list.stream().findFirst();
System.out.println(first.get());
// 获取list中任意元素
Optional<String> any = list.stream().findAny();
System.out.println(any.get());max
获取最大值
/**
* Returns the maximum element of this stream according to the provided
* {@code Comparator}. This is a special case of a
* <a href="package-summary.html#Reduction">reduction</a>.
*
* <p>This is a <a href="package-summary.html#StreamOps">terminal
* operation</a>.
*
* @param comparator a <a href="package-summary.html#NonInterference">non-interfering</a>,
* <a href="package-summary.html#Statelessness">stateless</a>
* {@code Comparator} to compare elements of this stream
* @return an {@code Optional} describing the maximum element of this stream,
* or an empty {@code Optional} if the stream is empty
* @throws NullPointerException if the maximum element is null
*/
Optional<T> max(Comparator<? super T> comparator); // 获取list中最大值
Optional<String> max = list.stream().max((Comparator.comparingInt(Integer::parseInt)));
System.out.println(max.get());min
获取最小值
/**
* Returns the minimum element of this stream according to the provided
* {@code Comparator}. This is a special case of a
* <a href="package-summary.html#Reduction">reduction</a>.
*
* <p>This is a <a href="package-summary.html#StreamOps">terminal operation</a>.
*
* @param comparator a <a href="package-summary.html#NonInterference">non-interfering</a>,
* <a href="package-summary.html#Statelessness">stateless</a>
* {@code Comparator} to compare elements of this stream
* @return an {@code Optional} describing the minimum element of this stream,
* or an empty {@code Optional} if the stream is empty
* @throws NullPointerException if the minimum element is null
*/
Optional<T> min(Comparator<? super T> comparator); // 获取list中最小值
Optional<String> min = list.stream().min((Comparator.comparingInt(Integer::parseInt)));
System.out.println(min.get());reduce
reduce方法将所有数据归纳得到一个数据
T reduce(T identity, BinaryOperator<T> accumulator);
Optional<T> reduce(BinaryOperator<T> accumulator);
<U> U reduce(U identity,
BiFunction<U, ? super T, U> accumulator,
BinaryOperator<U> combiner); // 将list中所有元素拼接起来，x的初始值是identity的值，后面x的值是上一次的计算结果
// y的值是list中的每个元素
String pinjie = list.stream().reduce("", (x, y) -> x + y);
// 获取list中长度最长的元素
String maxLength = list.stream().reduce("", (x, y) -> x.length() > y.length() ? x : y);reduce方法经常和map方法一起使用
先使用map方法把数据转换成想要的格式，再使用reduce进行处理
// 获取list中最长元素的长度
list.stream().map(x -> x.length()).reduce(0, (x,y) -> x > y ? x : y);mapToInt
将集合中的包装类型转换为基本数据类型，提高程序代码的效率
IntStream mapToInt(ToIntFunction<? super T> mapper);
LongStream mapToLong(ToLongFunction<? super T> mapper);
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper); List<Integer> integerList = Arrays.asList(1,2,3,4,5);
// 将List<Integer>中的Integer转成int类型
integerList.stream().mapToInt(s -> s.intValue()).forEach(System.out::println);
integerList.stream().map(s -> s.intValue()).forEach(System.out::println);
OptionalInt min1 = integerList.stream().mapToInt(Integer::valueOf).min();
System.out.println(min1.getAsInt());
// 会报错
// OptionalInt min2 = integerList.stream().map(Integer::valueOf).min();concat
将2个流合并为1个流
/**
* Creates a lazily concatenated stream whose elements are all the
* elements of the first stream followed by all the elements of the
* second stream. The resulting stream is ordered if both
* of the input streams are ordered, and parallel if either of the input
* streams is parallel. When the resulting stream is closed, the close
* handlers for both input streams are invoked.
*
* @implNote
* Use caution when constructing streams from repeated concatenation.
* Accessing an element of a deeply concatenated stream can result in deep
* call chains, or even {@code StackOverflowException}.
*
* @param <T> The type of stream elements
* @param a the first stream
* @param b the second stream
* @return the concatenation of the two input streams
*/
public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
Objects.requireNonNull(a);
Objects.requireNonNull(b);
@SuppressWarnings("unchecked")
Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
(Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
return stream.onClose(Streams.composedClose(a, b));
} // 将两个list的流合并为一个新的流
Stream.concat(list.stream(), integerList.stream()).forEach(System.out::println);数据收集到集合中
// 将list中的数据流手机到Set<Integer>中
Set<Integer> setList = integerList.stream().collect(Collectors.toSet());
// 将list中的数据流手机到List<Integer>中
List<Integer> integers = integerList.stream().collect(Collectors.toList());
// 将list中的数据流手机到指定类型的集合中ArrayList中
ArrayList<String> strList = integerList.stream().map(s -> s + "a").collect(Collectors.toCollection(ArrayList::new));
数据收集到数组中
// 将数据收集到Object数组中
Object[] objArr = integerList.stream().toArray();
// 将数据收集到String数组中
String[] strArr = integerList.stream().toArray(String[]::new);聚合
// 求和
Integer sum = list.stream().collect(Collectors.summingInt(Integer::valueOf));
// 平均值
Double avg = list.stream().collect(Collectors.averagingInt(Integer::valueOf));
// 总量
Long count2 = list.stream().collect(Collectors.counting());分组操作
根据某个属性，对数据进行分组
List<Person> list = new ArrayList<>();
list.add(new Person(1, "tom", 12));
list.add(new Person(2, "tina", 18));
list.add(new Person(3, "tom", 19));
list.add(new Person(4, "bob", 21));
list.add(new Person(5, "tom", 21));
// 根据name进行分组
Map<String, List<Person>> nameMap = list.stream().collect(Collectors.groupingBy(Person::getName));
// 根据年龄分组 >=18一组，没满18一组
Map<String, List<Person>> ageMap = list.stream().collect(Collectors.groupingBy(p -> p.getAge() >= 18 ? "1" : "0"));
// 多级分组，先根据name分组，再根据成年未成年分组
Map<String, Map<String, List<Person>>> group = list.stream().collect(Collectors.groupingBy(Person::getName,
Collectors.groupingBy(p -> p.getAge() >= 18 ? "成年" : "未成年")));
group.forEach((k,v)->{
System.out.println(k+":");
v.forEach((k2,v2)->{
System.out.println(" " + k2 + " :"+v2);
});
});
class Person{
private int id;
private String name;
private int age;
public Person(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
分区操作
Collectors.partitioningBy会根据值是否为true,把集合中的数据分割为两个列表，一个true列表，一个false列表
// 根据是否成员分区
Map<Boolean, List<Person>> agePart = list.stream().collect(Collectors.partitioningBy(p -> p.getAge() >= 18));
agePart.forEach((k,v)->{
System.out.println(k+":"+ v);
});
拼接
Collectors.joining会根据指定的连接符，将所有的元素连接成一个字符串
// 将list中所有id拼接起来：12345
String ids = list.stream().map(p -> String.valueOf(p.getId())).collect(Collectors.joining());
// 将list中所有id通过-拼接起来:1-2-3-4-5
String ids2 = list.stream().map(p -> String.valueOf(p.getId())).collect(Collectors.joining("-"));
// 将list中所有id加前缀、后缀和拼接符拼接起来 @1-2-3-4-5#
String ids3 = list.stream().map(p -> String.valueOf(p.getId())).collect(Collectors.joining("-", "@","#"));
并行流
前面写的都是串行流，在一个线程执行
parallelStream其实就是一个并行执行的流，它通过默认的ForkJoinPool，可以提高多线程任务的速度。
获取并行流
List<String> list = Arrays.asList("a","b","c");
// 获取并行流的两种方式
Stream<String> stringStream = list.parallelStream();
Stream<String> parallel = list.stream().parallel();使用并行流可能会有数据安全问题
解决方案
-
加同步锁
-
使用线程安全的容器
-
通过Stream中的toArray/collect操作
Optional
Optional是一个没有子类的工具类，Optional是一个可以为null的容器对象，它的主要作用就是为了避免Null检查，防止NullpointerException
String str = "";
/* 获取optional对象 */
// of方法不能传入null值，会报NPE
Optional<String> op1 = Optional.of(str);
// ofNullable能传入null值
Optional<String> op2 = Optional.ofNullable(str);
// 通过empty方法直接创建一个空的Optional对象
Optional<Object> op3 = Optional.empty();
/* isPresent */
// 判断op1中是否有值
if(op1.isPresent()){
// 获取op1中的值，如果为空会报错，所以需要使用isPresent进行判断
String s1 = op1.get();
}
/* orElse */
// 如果op1中是空值，那么返回值是xxx；如果op1中本来有值，那么返回值是原值
String s2 = op1.orElse("xxx");
/* orElseGet */
// 如果op1中是空值，那么返回值是lambda表达式返回值
String s3 = op1.orElseGet(() -> "Hello");
/* ifPresent */
// 如果op1中有值，做lambda表达式中的操作
op1.ifPresent((s)->{
System.out.println(s);
});
// 获取Person中的name，并将name转为大写，person和name都有可能为空
Person1 person1 = new Person1();
Optional<Person1> op4 = Optional.of(person1);
if(op4.isPresent()){
String s4 = op4.map(Person1::getName)
.map(String::toUpperCase)
.orElse("");
System.out.println("s4:"+s4);
}
日期
老的日期存在的问题
java.util.Date是线程不安全的，
构造方法的year是从1990年开始的
没有时区支持
LocalDate、LocalTime、LocalDateTime常见用法
// 根据年月日生成LocalDate
LocalDate localDate = LocalDate.of(2023,12,31);
// 获取当前日期
LocalDate now = LocalDate.now();
// 生成指定的LocalTime
LocalTime localTime = LocalTime.of(13, 45, 56, 123456789);
// 获取当前时间
LocalTime now1 = LocalTime.now();
// 根据LocalDate和LocalTime生成时间
LocalDateTime localDateTime = LocalDateTime.of(now, now1);
// 生成指定的LocalDateTime
LocalDateTime localDateTime1 = LocalDateTime.of(2021, 11, 22, 9, 59, 23, 2345);
// 获取当前时间
LocalDateTime now2 = LocalDateTime.now();
int year = now2.getYear();
int month = now2.getMonthValue();
int day = now2.getDayOfMonth();
int week = now2.getDayOfWeek().getValue();
int hour = now2.getHour();
int minute = now2.getMinute();
int second = now2.getSecond();
int nano = now2.getNano();
System.out.println("year:" + year);
System.out.println("month:" + month);
System.out.println("day:" + day);
System.out.println("week:" + week);
System.out.println("hour:" + hour);
System.out.println("minute:" + minute);
System.out.println("second:" + second);
System.out.println("nano:" + nano);
/* 修改日期 */
// 修改localDateTime1的year为1998，生成一个新的对象，不会更改老对象的值
LocalDateTime localDateTime2 = localDateTime1.withYear(1998);
// 对日期时间进行加减
// 对localDateTime1加2天
LocalDateTime localDateTime3 = localDateTime1.plusDays(2);
// 对localDateTime1减3年
LocalDateTime localDateTime4 = localDateTime1.minusYears(3);
LocalDateTime localDateTime5 = localDateTime1.plusYears(-3);
Assert.assertEquals(localDateTime4,localDateTime5);
/* 比较日期 */
// 判断localDateTime2是否大于localDateTime3
boolean isAfter = localDateTime2.isAfter(localDateTime3);
// 判断localDateTime4是否小于localDateTime5
boolean isBefore = localDateTime4.isBefore(localDateTime5);
// 判断localDateTime4是否等于localDateTime5
boolean isEqual = localDateTime4.isEqual(localDateTime5);时间格式化、解析
LocalDateTime now = LocalDateTime.now();
// 将LocalDateTime转换为String
String format = now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
System.out.println(format);
String format1 = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
System.out.println(format1);
// 将String转换为LocalDateTime
LocalDateTime localDateTime = LocalDateTime.parse("2023-06-19 22:56:14", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
System.out.println(localDateTime);Instant
时间戳，内部保存了从1970年1月1日 00:00:00以来的秒和纳秒
// 获取当前时间
Instant now1 = Instant.now();
// do something
// ...
Instant now2 = Instant.now();
// 时间差
int time = now2.getNano() - now1.getNano();时间差
Duration：计算LocalTime的时间差
Period：计算LocalDate的时间差
LocalTime time1 = LocalTime.of(12, 23, 34, 45);
LocalTime time2 = LocalTime.of(23, 34, 45, 56);
// 计算time2和time1的时间差 用后面的减前面的
Duration duration = Duration.between(time2, time1);
// 将时间差转换为天数
long days = duration.toDays();
// 将时间差转换为小时
long hours = duration.toHours();
// 将时间差转换为分钟
long minutes = duration.toMinutes();
// 将时间差转换为秒
long millis = duration.toMillis();
// 将时间差转换为纳秒
long nanos = duration.toNanos();
LocalDate date1 = LocalDate.of(2023, 12, 31);
LocalDate date2 = LocalDate.of(2021, 10, 1);
// 计算date2和date1的时间差
Period period = Period.between(date1, date2);
// 相差的年数
int years = period.getYears();
// 相差的月数
int months = period.getMonths();
// 相差的天数
int days1 = period.getDays();TemporalAdjuster 时间校正器
LocalDateTime dateTime = LocalDateTime.of(2023,6,19,20,58,12);
// 获取dateTime下个月第一天的日期
LocalDateTime dateTime2 = dateTime.with(TemporalAdjusters.firstDayOfNextMonth());
System.out.println("dateTime2 = " + dateTime2);
// 也可以自己实现时间修改逻辑
LocalDateTime dateTime3 = dateTime.with((temporal -> {
LocalDateTime localDateTime = (LocalDateTime)temporal;
return localDateTime.plusMonths(1).withDayOfMonth(1);
}));
System.out.println("dateTime3 = " + dateTime3);时区
Java8 中加入了对时区的支持，LocalDate、LocalTime、LocalDateTime是不带时区的，带时区的日期时间类分别为：ZonedDate、ZonedTime、ZonedDateTime
// 获取所有时区
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
// 获取标准的时间（我国属于东八区，比标准时间快8个小时）
ZonedDateTime utc = ZonedDateTime.now(Clock.systemUTC());
System.out.println("utc = " + utc);
// 计算机默认的时区 Asia/Shanghai
ZonedDateTime defultTime = ZonedDateTime.now();
System.out.println("defultTime = " + defultTime);
ZonedDateTime americaTime = ZonedDateTime.now(ZoneId.of("America/Marigot"));
System.out.println("americaTime = " + americaTime);
JDK新的日期和时间API的优势
-
新版日期时间API中，日期和时间对象是不可变，操作日期不会影响原来的值，而是生成一个新的实例
-
提供不同的两种方式，有效的区分了人和机器的操作
-
TemporalAdjuster可以更精确的操作日期，还可以自定义日期调整期
-
线程安全
重复注解
JDK 8引入了重复注解的概念，允许在同一个地方多次使用同一个注解。在JDK 8中使用@Repeatable注解定义重复注解。
@MyAnnotation("zhangsan")
@MyAnnotation("lisi")
public class AnnotationTest {
@MyAnnotation("abc")
@MyAnnotation("def")
public void test(){
}
public static void main(String[] args) throws NoSuchMethodException {
Class<AnnotationTest> clazz = AnnotationTest.class;
// 获取类上的注解
MyAnnotation[] clazzAnnotations = clazz.getDeclaredAnnotationsByType(MyAnnotation.class);
// 获取clazzAnnotations中第一个注解的值
String value = clazzAnnotations[0].value();
// 获取方法上的注解
MyAnnotation[] methodAnnotations = clazz.getMethod("test").getAnnotationsByType(MyAnnotation.class);
}
}
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
String value();
}
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotations{
MyAnnotation[] value();
}类型注解
JDK 8为@Target元注解新增了两种类型： TYPE_PARAMETER ， TYPE_USE 。
-
TYPE_PARAMETER ：表示该注解能写在类型参数的声明语句中。 类型参数声明如： <T>
-
TYPE_USE ：表示注解可以再任何用到类型的地方使用。
public class AnnotationTest2 {
/**
* <T>
* <T>
* @param t
* @param <T> 表示是个泛型方法，就像有static修饰的方法是个静态方法一样;
* 表示传入参数有泛型,<T>存在的作用，是为了保证参数中能够出现T这种数据类型。
*/
public <T> void test(T t){
}
public <@A T> void test2(T t){
}
public void test3(@B String name, @B Integer age){
}
}
// 表示该注解能写在泛型中
@Target(ElementType.TYPE_PARAMETER)
@interface A{
}
// 在任何用到类型的地方使用
@Target(ElementType.TYPE_USE)
@interface B{
}
254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
