【java基础】Java8新特性

🍇Lambda表达式

对于FunctionalInterface,用注解@FunctionalInterface标记，即只定义了单方法的接口才可以使用Lambda来简写匿名实现类.

例如：

• Comparator
• Runable
• Callable

这些都是单方法的接口。

@FunctionalInterface
public interface Comparator<T> {

    int compare(T o1, T o2);

    boolean equals(Object obj);

    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    default Comparator<T> thenComparing(Comparator<? super T> other) {
        ...
    }
    ...
}

对于Comparator的运用我们可以看到

public static void Main(){
    String[] array=new String[] {"apple","Orange","benean"};
    //在不使用Lambda表达式时，需要创建一个匿名类来实现比较器
    Arrays.sort(array,new Comparator<String>(){
        public int compara(String s1,String s2){
            return s1.comparaTo(s2)
        }
    })
    
}

使用lambda表达式，可以改成这样

public static void Main(){
    String[] array=new String[] {"apple","Orange","benean"};
    //在不使用Lambda表达式时，需要创建一个匿名类来实现比较器
    Arrays.sort(array,(s1,s2)->{
        return s1.comparaTo(s2);
    }
    )
    
}

对于只有一条语句的lambda表达式还可以写成这样

(s1,s2)->s1.comparaTo(s2)

🍈方法引用

所谓方法引用就是某个方法的返回类型和参数列表与某个FunctionalInterface的单方法一致，就可以使用这个方法来代替FunctionalInterface.

例如：

public class Main {
    public static void main(String[] args) {
        String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
        Arrays.sort(array, Main::cmp);
        System.out.println(String.join(", ", array));
    }

    static int cmp(String s1, String s2) {
        return s1.compareTo(s2);
    }
}

由于 Arrays.sort所需要的Comparator<String>的方法是int compare(String, String)，这和静态方法int cmp(String, String)一致，所以就可以使用Main::cmp代替。

🐵构造方法引用

如果要把一个List<String>转换为List<Person>，应该怎么办？

传统方法：

List<String> names = List.of("Bob", "Alice", "Tim");
List<Person> persons = new ArrayList<>();
for (String name : names) {
    persons.add(new Person(name));
}

使用方法引用

List<String> names = List.of("Bob", "Alice", "Tim");
List<Person> persons=names.stream.map(Person::new).collect(Collectors.toList());

🍉Stream api

StreamApi特点：

• 分为两个操作：转换操作和聚合操作，其中转换操作对元素不进行计算只存储转换操作的算法，只有当聚合操作才会执行转发操作的计算。

	List	Stream
元素	已分配并存储在内存	可能未分配，实时计算
用途	操作一组已存在的Java对象	惰性计算

🐵Map()操作

Stream.map()是Stream最常用的一个转换方法，它把一个Stream转换为另一个Stream

public static void main(){
    List.of(1,2,3,4,5,6,7,8)
        .stream()
        .map(x->x*x)
        .foreach(System.out::println)
}

🐒Filter()操作

Stream.filter()是一种对元素的过滤操作

 public static void main(String[] args) {
        IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
                .filter(n -> n % 2 != 0)
                .forEach(System.out::println);
    }

🐶Reduce()操作

Stream.reduce()则是Stream的一个聚合方法，它可以把一个Stream的所有元素按照聚合函数聚合成一个结果，类似与求和。

public static void main(){
    List<Integer> nums=List.of(1,2,3,4,5,6,7,7,8);
    int ans=nums.stream().reduce((sum,x)->sum+x);
}