java8 新特性

lambda

• parameter -> expression body

可选的类型声明：你不用去声明参数的类型。编译器可以从参数的值来推断它是什么类型。
可选的参数周围的括号：你可以不用在括号内声明单个参数。但是对于很多参数的情况，括号是必需的。
可选的大括号：如果表达式体里面只有一个语句，那么你不必用大括号括起来。
可选的返回关键字：如果表达式体只有单个表达式用于值的返回，那么编译器会自动完成这一步。若要指示表达式来返回某个值，则需要使用大括号。

接口允许default方法提供默认的实现

• 接口中的default方法，可以有方法体，不算抽象方法，可以直接使用。

函数式接口

• 接口只有一个抽象方法，可以有多个非抽象方法，则可以用lambda表达式来表示该接口的抽象方法的一个实现。针对该接口类型的所有lambda表达式都会与这个抽象方法匹配。

  @FunctionalInterface
  interface Converter<F, T> {
  	T convert(F from);
  }
  // 即convert()方法体是Integer,valueOf(from)
  Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
  

• java8新增的Function，提供一个原料，并通过它提供的默认方法（compose. andThen），生产一个最终的产品。

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

Lambda

目标类型： 即可以把lambda表达式作为参数传入的目标类型：

预定义使用了 @Functional 注释的函数式接口，自带一个抽象函数的方法，或者SAM(Single Abstract Method 单个抽象方法)类型。这些称为lambda表达式的目标类型，可以用作返回类型，或lambda目标代码的参数。例如，若一个方法接收Runnable、Comparable或者 Callable 接口，都有单个抽象方法，可以传入lambda表达式。
类似的，如果一个方法接受声明于 java.util.function 包内的接口，例如 Predicate、Function、Consumer 或 Supplier，那么可以向其传lambda表达式。

方法引用： Lambda表达式内可以使用方法引用，当传入的参数跟表达式内的参数一致时，可以转化为方法引用，例如：

// 参数省略类型声明，编译器可以从list的类属性中推测出来
list.foreach(n -> System.out.println(n)); ——> list.foreach(System.out::println);

// 方法引用方式:
// 对象::实例方法, n -> System.out,println(n)
set.foreach(System.out::println);
// 类名::静态方法, () -> Math.random()
Stream<Double> stream = Stream.generate(Math::random); 
// 类名::实例方法, (s1, s2) -> s1.compareTo(s2)
TreeSet<String> set = new TreeSet<>(String::compareTo)

如果对参数有所修改则不能使用方法引用。

Stream

分为顺序流(stream)和并行流(parallelStream)，并行遍历时，数组被分成多个段，每个段在不同的线程中处理，将结果一起输出。parallelStream原理可用下面的流程描述：

List originalList = someData;
	split1 = originalList(0, mid);//将数据分段
	split2 = originalList(mid,end);
	new Runnable(split1.process());//部分执行操作
	new Runnable(split2.process());
	List revisedList = split1 + split2;//将结果合并
	在多核机器上，理论上并行流会比顺序流快。

Stream包含以下方法：其中collect()、foreach()、reduce()等是终止方法（不返回Stream对象），不执行它们则其他方法不生效。

filter()

Stream<T> filter(Predicate<? super T> var1);
传入一个Predicate，函数式接口，指定过滤方法，可以通过and()、or()、xor()来组合多个Predicate。

Predicate<String> startWithL = n -> n.startWith("L");
Predicate<String> lengthLong = n -> n.length > 4;
// 返回以L开头并且长度>4的name list
name.stream().filter(startWithL.and(lengthLong)).collect(Collectors.toList());

map()

<R> Stream<R> map(Function<? super T, ? extends R> var1);
执行Function，转换list中的元素。

area.getCities()
       .stream()      // 通过map，将city的model转成view
       .map(city -> BoutiqueZoneCardView.of(city, buildContext))
       .collect(toList()));

peek()

Stream<T> peek(Consumer<? super T> var1);
通常用于调试，类似打断点，传入一个Consumer方法体，调试后删掉，正式不建议使用，具体原因见下面peek和map的对比。
peek & map
● peek官方文档中是为了debug的，与map定位不同
● 两个函数的返回值都是一个新的Stream，但是两个函数的参数（peek是Consumer，map是Function）起作用的时机不同。map的Function在生成新的Stream之前被执行，新Stream中的元素是上游Stream中元素经Function作用后的值。peek函数的Consumer工作在生成Stream之后。
例如：

List<String> list = Stream.of("one", "two", "three", "four")
        .filter(e -> e.length() > 3)
        .peek(e -> System.out.println("Filtered value: " + e))
        .map(String::toUpperCase)
        .peek(e -> System.out.println("Mapped value: " + e))
        .collect(Collectors.toList());

1.第一个中间操作是filter，filter的谓词是只保留长度大于3的字符串，经过谓词过滤后filter返
回是一个仅包含两个字符串three和four的Stream1，谓词工作在Stream1生成之前。
2. 第二个中间操作是peek，peek的Consumer是打印Stream中的字符串，peek直接生成一个
和上游Stream1包含相同元素的Stream2，peek函数的Consumer工作在生成Stream2之后。
3. 第三个中间操作是map，map的Function将字符串转换为全大写，Function作用于上游Stream2的每一个元素，并生成新的Stream3。
4.第四个中间操作是peek，peek的Consumer依然只是打印Stream4中的字符串，Consumer依然工作在Stream4生成之后。
● map函数对Stream中元素执行的是映射操作，会以新的元素(map的结果)填充新的Stream，严格的讲map不是修改原来的元素。peek只能消费Stream中的元素，是否可以更该Stream中的元素，取决于Stream中的元素是否是不可变对象。如果是不可变对象，则不可修改Stream中的元素；如果是可变对象，则可以修改对象的值，但是无法修改对象的引用。
○ 不可变对象：如String，基本类型包装类，BigInteger等，一旦创建，属性值不能改变。其他为可变对象。

flatmap()

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> var1);
将多个stream连接成一个stream。用来将List<List<?>>合并成List<?>。

Collectors

收集器，将结果收集起来返回。

Collectors.joining(", ")     // 用逗号链接, 可以指定前后缀
Collectors.toList()           //返回List
Collectors.toSet() 						// 生成set集合
// 转成map,默认HashMap,可以自定义map,传mapFactory
// 去重,可以自定义比较器
Collectors.toMap(MemberModel::getUid, Function.identity(),(a, b) -> a);
// 另外还可以做统计、求和、最值、求平均等等, Collectors.minBy()、Collectors.maxBy()、reducing等 和Stream.min()、Stream.max() 作用是一样的, 适用于高级场景, 

max()、min()
Optional<T> min(Comparator<? super T> var1);
Optional<T> max(Comparator<? super T> var1);
以Comparator方法中返回值的正负零判断大小。

// 例如，比较整数数组，可以使用
Stream.of(2,1,4,5,3).max(Integer::compare).get();
// 不能使用, 因为数组元素都是正数, Integer.max()的执行结果都是正数,所以只能返回第一个值
Stream.if(2,1,4,5,3).max(Integer::max).get();

sorted

排序

Optional

用来解决null值问题，避免显式的null判断。Optional是一个可以为null的容器对象。

public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional();
    private final T value;

    private Optional() {
        this.value = null;
    }

    public static <T> Optional<T> empty() {
        Optional<T> t = EMPTY;
        return t;
    }

    private Optional(T value) {
      	// value为空会抛NPE
        this.value = Objects.requireNonNull(value);
    }
}

of()

创建一个非空的Optional对象，传入的参数不能为空。

public static <T> Optional<T> of(T value) {
    return new Optional(value);
}

ofNullable()

用指定值创建一个可空的Optional对象，如果传入参数为空，则返回value为null的Optianal。

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

isPresent()

返回Optional对象value是否为空。

public boolean isPresent() {
    return this.value != null;
}

ifPresent()

Optional对象有值则执行Consumer，否则不作处理。

public void ifPresent(Consumer<? super T> action) {
    if (this.value != null) {
        action.accept(this.value);
    }
}

get()

如果Optional有值则返回，否则抛NoSuchElementException。

public T get() {
    if (this.value == null) {
         throw new NoSuchElementException("No value present");
    } else {
         return this.value;
    }
}

orElse()

如果有值则返回value，否则返回指定的其他值other。

public T orElse(T other) {
    return this.value != null ? this.value : other;
}

orElseGet()

与orElse()类似，orElseGet()传入的是Supplier，用其实现来生成默认值。

public T orElseGet(Supplier<? extends T> supplier) {
    return this.value != null ? this.value : supplier.get();
}

map()

如果有值，则对其执行mapping函数得到返回值。如果返回值不为null，则创建包含mapping返回值的Optional作为map方法返回值，否则返回空Optional。

public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
    return !this.isPresent()? empty() : ofNullable(mapper.apply(this.value));
}

函数式接口

Function

R apply(T var1);
有参有返回值。

Supplier

T get();
无参有返回值。

Predicate

boolean test(T var1);
有参，但是返回值类型是固定的boolean。

Consumer

void accept(T var1);
有参数，无返回值。