Optional
Optional是一个没有子类的工具类，Optional是一个可以为null的容器对象。它的作用主要就是为了解决避免Null检查，防止NullPointerException。
//常用方法
Optional.of(T t) : 创建一个 Optional 实例
Optional.empty() : 创建一个空的 Optional 实例
Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
isPresent() : 判断是否包含值,包含值返回true，不包含值返回false
get() : 如果Optional有值则将其返回，否则抛出NoSuchElementException
orElse(T t) : 如果调用对象包含值，返回该值，否则返回参数t
orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
map(Function f): 如果有Optional值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
map中获取的返回值自动被Optional包装,即返回值 -> Optional<返回值>
flatMap中返回值保持不变,但必须是Optional类型,即Optional<返回值> -> Optional<返回值>
//进一步用法
//ifPresent() :
// 存在做的什么
userNameO.ifPresent(s -> System.out.println("用户名为" + s));
//ifPresentOrElse():
// 存在做的什么,不存在做点什么
userNameO.ifPresentOrElse(s -> System.out.println("用户名为" + s)
, () -> System.out.println("用户名不存在"));
}
Stream流
其他高级用法方法：
find
Optional<T> findFirst();
Optional<T> findAny();
@Test
public void testFind() {
Optional<Integer> first = Stream.of(5, 3, 6, 1).findFirst();
System.out.println("first = " + first.get());
Optional<Integer> any = Stream.of(5, 3, 6, 1).findAny();
System.out.println("any = " + any.get());
}
max/min
Optional<T> max(Comparator<? super T> comparator);
Optional<T> min(Comparator<? super T> comparator);
reduce
将数据做归纳
Optional<T> reduce(BinaryOperator<T> accumulator);
T reduce(T identity, BinaryOperator<T> accumulator);
<U> U reduce(U identity,
BiFunction<U, ? super T, U> accumulator,
BinaryOperator<U> combiner);
可以map和reduce组合使用
concat 合并流
如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：
static
备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。
并行流
@Test
public void testgetParallelStream() {
ArrayList<Integer> list = new ArrayList<>();
// 直接获取并行的流
// Stream<Integer> stream = list.parallelStream();
// 将串行流转成并行流
Stream<Integer> stream = list.stream().parallel();
}
线程安全问题
并行流存在线程安全问题，循环1000次打印结果却没有1000：
List<Integer> newList = new ArrayList<>();
// 使用并行的流往集合中添加数据
list.parallelStream()
.forEach(s -> {
newList.add(s);
});
System.out.println("newList = " + newList.size());
1、加锁
在添加数据时加锁
List<Integer> newList = new ArrayList<>();
// 使用并行的流往集合中添加数据
Object o = new Object();
list.parallelStream().forEach(s -> {
synchronized (o){
newList.add(s);
}
});
System.out.println("newList = " + newList.size());
2、Collections工具类
List<Integer> newList = Collections.synchronizedList(new ArrayList<>());
// 使用并行的流往集合中添加数据
list.parallelStream().forEach(s -> {
newList.add(s);
});
System.out.println("newList = " + newList.size());
3、同步容器
通过并行流将List中的数据转存到另一个线程安全的Vector集合中*
List<Integer> newList = new Vector<>();
// 使用并行的流往集合中添加数据
list.parallelStream().forEach(s -> {
newList.add(s);
});
System.out.println("newList = " + newList.size());
4、并发容器
使用并发容器CopyOnWriteArrayList+并行流
List<Integer> newList = new CopyOnWriteArrayList<>();
// 使用并行的流往集合中添加数据
list.parallelStream().forEach(s -> {
newList.add(s);
});
System.out.println("newList = " + newList.size());
函数式接口
-
Supplier接口
https://blog.csdn.net/qq_31635851/article/details/116497765
@FunctionalInterface
public interface Supplier<T> {
public abstract T get();
}
-
Consumer接口
https://moonce.blog.csdn.net/article/details/116207886
@FunctionalInterface
public interface Consumer<T> {
public abstract void accept(T t);
}
-
Function接口
https://moonce.blog.csdn.net/article/details/116593033
@FunctionalInterface
public interface Function<T, R> {
public abstract R apply(T t);
}
-
Predicate接口
https://moonce.blog.csdn.net/article/details/116484594
@FunctionalInterface
public interface Predicate<T> {
public abstract boolean test(T t);
}