자바 에서 사용 가능:

프로필
 
방법 인용 은 세 가지 로 나 뉘 는데 방법 인용 은 한 쌍 의 짝 퉁 을 통 해: 방법 인용 은 함수 식 인터페이스의 또 다른 쓰기 방식 임 을 나타 낸다.
 

정적 방법 참조, 클래스 이름: 정적 방법 이름, 예 를 들 어 Integer:: parseInt

인 스 턴 스 방법 참조, 인 스 턴 스 대상: 인 스 턴 스 방법, 예 를 들 어 str: substring

구조 방법 인용, 유형 명: new, 예 를 들 어 User: new

 
방법 참조
 

 

 

 

 

 

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

 
방법 인용 을 통 해 방법의 인용 대 가 를 변수 에 줄 수 있 습 니 다. 대 가 를 통 해 Function 에 줄 수 있 습 니 다. 설명 방법 인용 도 함수 식 인터페이스의 쓰기 방식 입 니 다. Lambda 표현 식 도 함수 식 인터페이스 입 니 다. Lambda 표현 식 은 보통 자신 이 방법 체 를 제공 하 는 데 사용 되 고 방법 은 기 존의 방법 을 직접 참조 합 니 다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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) {
        //      ::             Function fun = Integer::parseInt;    Integer value = fun.apply("123");    System.out.println(value);
    //      ::              String content = "Hello JDK8";    Function func = content::substring;    String result = func.apply(1);    System.out.println(result);
    //           BiFunction biFunction = User::new;    User user = biFunction.apply("mengday", 28);    System.out.println(user.toString());
    //              ，                     sayHello(String::toUpperCase, "hello");}
//        ，   private static void sayHello(Function func, String parameter){
        String result = func.apply(parameter);    System.out.println(result);}

 
3: 옵션 선택 가능 값
 
Google Guava 에는 Optional 이 있 으 며 Swift 언어 에 도 이와 유사 한 문법 이 있 습 니 다. Swift 에 서 는 선택 가능 한 값 을 데이터 형식 으로 사용 하여 위치 와 기본 유형 을 동일 하 게 만 들 고 위치 가 매우 높 습 니 다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

package java.util;
import java.util.function.Consumer;import java.util.function.Function;import java.util.function.Predicate;import java.util.function.Supplier;
/** * @since 1.8 */public final class Optional {
        private static final Optional> EMPTY = new Optional<>();
    private final T value;
    private Optional() {
            this.value = null;    }
    //        Optional      public static Optional empty() {
            @SuppressWarnings("unchecked")        Optional t = (Optional) EMPTY;        return t;    }
    private Optional(T value) {
            this.value = Objects.requireNonNull(value);    }
    //      Optional       Optional    public static  Optional of(T value) {
            return new Optional<>(value);    }
    //      Optional    Optional，    ，        Optional    public static  Optional ofNullable(T value) {
            return value == null ? empty() : of(value);    }
    //   Optional     ，   ，     NoSuchElementException 。    public T get() {
            if (value == null) {
                throw new NoSuchElementException("No value present");        }        return value;    }
    //   true     ，    false     public boolean isPresent() {
            return value != null;    }
    //      ，             ，         。    public void ifPresent(Consumer super T> consumer) {
            if (value != null)            consumer.accept(value);    }
    //        ，             ，     Optional    ，         Optional    public Optional filter(Predicate super T> predicate) {
            Objects.requireNonNull(predicate);        if (!isPresent())            return this;        else            return predicate.test(value) ? this : empty();    }
    //        ，          ，       ，      Optional    Optional 。    public Optional map(Function super T, ? extends U> mapper) {
            Objects.requireNonNull(mapper);        if (!isPresent())            return empty();        else {
                return Optional.ofNullable(mapper.apply(value));        }    }
    //        ，      Optional      ，     ，         Optional 。    public Optional flatMap(Function super T, Optional> mapper) {
            Objects.requireNonNull(mapper);        if (!isPresent())            return empty();        else {
                return Objects.requireNonNull(mapper.apply(value));        }    }
    //      ，    ，                public T orElse(T other) {
            return value != null ? value : other;    }

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

 
of 방법 에 대해 서 는 현재 유행 하 는 것 같 습 니 다. static 방법 을 제공 하 는 것 입 니 다. 방법 이름 은 of 이 고 방법의 반환 값 은 현재 클래스 로 돌아 가 며 구조 함 수 를 개인 private 로 설정 하고 정적 of 방법 으로 구조 함 수 를 대체 합 니 다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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);    }}

 
Main
 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

public static void main(String[] args) {
        // Optional     Java 8      ， Guava     ，  Oracle            // Optional         ，       ，       NullPointerException           String msg = "hello";    Optional optional = Optional.of(msg);    //       ，       boolean present = optional.isPresent();    //     ，    ，             String value = optional.get();    //     ，  else        String hi = optional.orElse("hi");    //       ，   Lambda       optional.ifPresent(opt -> System.out.println(opt));}

저자: 거품 코드 의 작은 이 흑 
원본:https://urlify.cn/Qjaaue