What grammar is it? ]

5 Line code , Can let wechat small program on the shelf to their own APP in | Register and send it to Dajiang 、 Huawei 、 Cherry keyboard ！>>>

One ： concise

There are three types of method references , Method references are made through a pair of double colons :: To express , Method reference is another way to write a functional interface

• Static method reference , By class name :: Static method name , Such as Integer::parseInt

• Instance method reference , By instance object :: Example method , Such as str::substring

• Construction method reference , By class name ::new, Such as User::new
  Two ： Method reference

public final class Integer {
    public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }
}

Quote... By method , You can assign a reference to a method to a variable , By assigning a value to Function, Explain that method reference is also a way of writing functional interface ,Lambda Expressions are also functional interfaces ,Lambda Expression is usually used to provide its own method body , The method reference usually refers to the ready-made method directly .

public class User {
    private String username;
    private Integer age;

    public User() {
    }

    public User(String username, Integer age) {
        this.username = username;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }

    // Getter&Setter
}
public static void main(String[] args) {
    //  Use double colons :: To construct static function references 
    Function<String, Integer> fun = Integer::parseInt;
    Integer value = fun.apply("123");
    System.out.println(value);

    //  Use double colons :: To construct non static function references 
    String content = "Hello JDK8";
    Function<Integer, String> func = content::substring;
    String result = func.apply(1);
    System.out.println(result);

    //  Constructor reference 
    BiFunction<String, Integer, User> biFunction = User::new;
    User user = biFunction.apply("mengday", 28);
    System.out.println(user.toString());

    //  Function reference is also a functional interface , So you can also take a function reference as a parameter of a method 
    sayHello(String::toUpperCase, "hello");
}

//  Method has two parameters , One is 
private static void sayHello(Function<String, String> func, String parameter){
    String result = func.apply(parameter);
    System.out.println(result);
}

3、 ... and ：Optional Optional value
stay Google Guava in Optional, stay Swift There are similar grammars in languages , stay Swift Take an optional value as a data type , The status is equal to the basic type , The status is very high .

/** * @since 1.8 */
public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();

    private final T value;

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

    //  Returns an empty  Optional example 
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    //  Returns a  Optional The current non null value of Optional
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    //  Return to one  Optional Specified value Optional, If it is not empty , Then return an empty  Optional
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    //  If Optional There is a value in , Return value , Otherwise throw  NoSuchElementException .
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    //  return true If there is value , Otherwise  false
    public boolean isPresent() {
        return value != null;
    }

    //  If there is value , Then use this value to call the specified consumer , Otherwise, nothing will be done .
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

    //  If a value exists , And the predicate given by the value matches , Return to one  Optional The value described , Otherwise, return an empty  Optional
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

    //  If there is a value , Then the mapping function provided by , If the result is not empty , Returns a  Optional The results of  Optional .
    public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

    //  If a value exists , The application provides  Optional The mapping function gives it , Return the result , Otherwise, return an empty  Optional .
    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }

    //  If the value exists , Just return the value , If it doesn't exist, it will return other specified values 
    public T orElse(T other) {
        return value != null ? value : other;
    }


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

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }
}

About of Method , It seems to be very popular now , Is to provide a static Method , The name of the method is of, Method returns the current class , And set the constructor to private private, Using static of Method instead of the constructor .

public class User {
    private String username;
    private Integer age;

    private User() {
    }

    public static User of() {
        return new User();
    }

    private User(String username, Integer age) {
        this.username = username;
        this.age = age;
    }

    public static User of(String username, Integer age) {
        return new User(username, age);
    }
}

public static void main(String[] args) {
    // Optional Class has become Java 8 Part of the class library , stay Guava There has been , Probably Oracle It's used directly 
    // Optional Used to solve null pointer exception , Make the code more rigorous , Prevent because of null pointer NullPointerException Impact on code 
    String msg = "hello";
    Optional<String> optional = Optional.of(msg);
    //  Judge whether there is value , Not empty 
    boolean present = optional.isPresent();
    //  If it's worth it , Return value , If it is equal to empty, then throw the exception 
    String value = optional.get();
    //  If it is empty , return else The specified value 
    String hi = optional.orElse("hi");
    //  If the value is not null , Is executed Lambda expression 
    optional.ifPresent(opt -> System.out.println(opt));
}