JDK8新特性（二）--- Option\Stream\函数式接口

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 Stream concat(Stream<? extends T> a, Stream<? extends T> b)
备注：这是一个静态方法，与 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());

函数式接口

1. Supplier接口

https://blog.csdn.net/qq_31635851/article/details/116497765

@FunctionalInterface
public interface Supplier<T> {
	public abstract T get();
}

2. Consumer接口

https://moonce.blog.csdn.net/article/details/116207886

@FunctionalInterface
public interface Consumer<T> {
public abstract void accept(T t);
}

3. Function接口

https://moonce.blog.csdn.net/article/details/116593033

@FunctionalInterface
public interface Function<T, R> {
	public abstract R apply(T t);
}

4. Predicate接口

https://moonce.blog.csdn.net/article/details/116484594

@FunctionalInterface
public interface Predicate<T> {
	public abstract boolean test(T t);
}