JAVA 8 特性

刺骨的言语ヽ痛彻心扉 2022-07-15 09:48 138阅读 0赞

# JAVA 8 新特性(1) #

## 接口类的新写法 ##

在JAVA8中，我们可以用**default**关键词在interface中添加非抽象类，也叫作 Extension Methods（扩展方法），例如

interface Formula {
        double calculate(int a);
    
        default double sqrt(int a) {
            return Math.sqrt(a);
        }
    }

使用的时候，我们可以像下面这么写：

Formula formula = new Formula() {
        @Override
        public double calculate(int a) {
            return sqrt(a * 100);
        }
    };
    formula.calculate(100);     // 100.0
    formula.sqrt(16);           // 4.0

## Lambda表达式 ##

首先，我们从看看怎么给某个集合排序，

List<String> names = Arrays.asList("张三", "李四", "王五", "赵六");
    
    Collections.sort(names, new Comparator<String>() {
        @Override
        public int compare(String a, String b) {
            return b.compareTo(a);
        }
    });

排序的写法是不是很复杂？

让我们来改进一下，

Collections.sort(names, (String a, String b) -> { return b.compareTo(a); });

还可以更短

Collections.sort(names, (String a, String b) -> b.compareTo(a));

或者再短一点：

Collections.sort(names, (a, b) -> b.compareTo(a));

## 自己写函数式接口 ##

每个Lambda方法都对应了接口中的某个类型，以此来通过JAVA的类型检测系统。所以，每个函数式接口必须**只包含一个抽象方法**，例如：

@FunctionalInterface
    interface Converter<F, T> {
        T convert(F from);
    }

调用的时候，我们只要这么写

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
    Integer converted = converter.convert("123");
    System.out.println(converted);    // 123

注意，即使去掉**@FunctionalInterface**的注解，后面的程序也可以运行。

## 方法和构造器的引用 ##

通过静态方法引用，上面的程序还可以进一步简化，如

Converter<String, Integer> converter = Integer::valueOf;
    Integer converted = converter.convert("123");
    System.out.println(converted);   // 123

注意，这里用的是**::**。

还可以引用类中的方法，例如

class Something {
        String startsWith(String s) {
            return String.valueOf(s.charAt(0));
        }
    }

调用方法如下：

Something something = new Something();
    Converter<String, String> converter = something::startsWith;
    String converted = converter.convert("Java");
    System.out.println(converted);    // "J"

接下来，我们看看**::** 怎么捏合构造器，看下面的代码

class Person {
        String firstName;
        String lastName;
    
        Person() {}
    
        Person(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }

然后，我们写一个工厂类，

interface PersonFactory<P extends Person> { 
        P create(String firstName, String lastName);
    }

通过构造器引用，我们可以把这两个方法揉在一起：

PersonFactory<Person> personFactory = Person::new;
    Person person = personFactory.create("Peter", "Parker");