java8-04 - 기타 기능

[TOC]
1 기본 Base64 API
Base64에 대응하는 조작은 굳이 제3자 라이브러리를 사용할 필요가 없다.java8에 내장된 Base64 API 위치: java.util.Base64

//    -->     
byte[] bs = Base64.getEncoder().encode("java 8".getBytes(Charset.forName("UTF-8")));
// amF2YSA4
System.out.println(new String(bs));

//    -->     String
String string = Base64.getEncoder().encodeToString("java 8".getBytes(Charset.forName("UTF-8")));
// amF2YSA4
System.out.println(string);

//   
byte[] bs2 = Base64.getDecoder().decode(bs);
// java 8
System.out.println(new String(bs2));

2 NPE용 Optional 컨테이너
빈 포인터를 위해 태어난 옵티올은 N이 이전google Guava에 등장한 것으로 보인다.

public final class Optional {
    private final T value;
    
    private Optional(T value) {
      // value null ,          ,       NPE     
        this.value = Objects.requireNonNull(value);
    }
  
    private Optional() {
        this.value = null;
    }
  
    //       Optional  
    public static Optional empty() {
        @SuppressWarnings("unchecked")
        Optional t = (Optional) EMPTY;
        return t;
    }
    
    public static  Optional of(T value) {
        return new Optional<>(value);
    }
   
    public static  Optional ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
    // ...
}

사실은 용기류로 빈 대상을 용기에 포장할 수 있다.
Optional 인스턴스 가져오기
구조기는 개인적이며 다음과 같은 방법으로 그 실례를 얻을 수 있다.

// 1.       Optional  
Optional

상용 방법

isPresent(): 값이 반환true가 존재하지 않으면false

로 반환

get(): 용기 내부에 값이 있으면 되돌려주고, 그렇지 않으면 NoSuchElementException

을 던집니다.

orElse(T other): 용기 내부에 값이 있으면 되돌려주고, 그렇지 않으면other

로 되돌려줍니다.

orElseGet(Supplier extends T>other): 용기 내부에 값이 있으면 되돌려주고, 그렇지 않으면 공급형 인터페이스인other의 되돌려준다

orElseThrow(Supplier extends X> exception Supplier): 용기 내부에 값이 있으면 되돌려주고, 그렇지 않으면 공급형 인터페이스인other가 되돌려주는 이상

을 던집니다.

Filter(Predicate super T>predicate): 용기의 값을predicate 필터로 필터한 후 조건이 충족되면 이 값을 포함하는 Optional을 되돌려줍니다. 그렇지 않으면 빈 Optional

을 되돌려줍니다.

맵(Function super T,? extends U> mapper): 이 방법의 원본 코드는 다음과 같다

public Optional map(Function super T, ? extends U> mapper) {
    // mapper   null
    Objects.requireNonNull(mapper);
    //       ,   Optional
    if (!isPresent())
        return empty();
    else {
        //      ,        apply        Optional
         return Optional.ofNullable(mapper.apply(value));
    }
}

Optional 사용
먼저 어색한 작법 을 보아라

Optional user = ......;
if (user.isPresent()) {//              
    return user.get().getName();
} else {//        
    return "default Value";
}

사실 이렇게 쓰는 것은 아래의 쓰는 방법과 아무런 차이가 없다.

User user = ......;
if (user != null) {
    return user.getName();
} else {
    return "default Value";
}

호출 방법isPresent()은 사실obj!=null과 똑같다.
Optional 이 있으면 다음과 같이 우아합니다.

Optional user = ......;
return user.map(User::getName).orElse("default Value");

다시 한 번 예를 보겠습니다.

public static class Person {
    private String name;
    private Addr addr;

    public static class Addr {
        private String city;
        private String street;
    }
}

//         ,    ,  "NotFound"
public String getPersonStreet(Person person) {
    return Optional.ofNullable(person)//
      .map(p -> p.getAddr())//
      .map(a -> a.getStreet())//
      .orElse("NotFound");
}


//   Optional   ,             
public String getPersonStreet2(Person person) {
    if (person != null) {
        if (person.getAddr() != null) {
            if (person.getAddr().getStreet() == null) {
                return "NotFound";
            }
            return person.getAddr().getStreet();
        }
    }
    return "NotFound";
}

총결산

Optional의 출현은 NPE를 피할 수 있는 것이 아니라 NPE의 발생을 줄일 수 있을 뿐이다-

NPE가 발생할 때 Optional은 NPE의 근원을 신속하게 포착할 수 있다

또한 Optional을 사용할 때 우아하지 않은 문법을 최대한 피해야 한다. 그렇지 않으면 Optional의 출현과 거의 아무런 의미가 없다.이를 고려하여 다음과 같은 몇 가지 건의가 있다.

가능한 한 직접 호출하지 마라isPresent()/get() 방법

Optional을 구성원 변수/방법으로 가입하는 것을 권장하지 않음

가능한 한 사용해야 한다map()/filter()/orElse() 등 방법

3 업그레이드 인터페이스

public interface Foo {

    //          
    Integer max = 10000;
    
    //        
    String get();

    //     (   )
    static String bar() {
        return "haha";
    }
  
    // default       (   )
    default String hello() {
        return "hello";
    }
}

이렇게 되면 다승계와 비슷하지만 충돌이 있을 수 있다.

류 우선원칙

실현된 여러 인터페이스 중의 방법이 충돌하면 하나만 실현할 수 있고 나머지는 버려야 한다

public class InterfaceTest {

    static interface Walkable {
        default void walk() {
            System.out.println("walk() from Walkable");
        }
    }

    static interface Speekable {
        default void speek() {
            System.out.println("walk() from Walkable");
        }

        default void walk() {
            System.out.println("walk() from Walkable");
        }
    }

    static class Dog implements Walkable, Speekable {

        @Override
        public void walk() {
            // 1.         default         ,       
            Speekable.super.walk();
        }
    }

    static class Animal {
        public void walk() {
            System.out.println("walk() from Animal");
        }
    }

    static class Cat extends Animal implements Walkable {
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        // 2.      ,   walk()     Animal,     Walkable
        cat.walk(); // walk() from Animal
    }
}

4 반복 가능한 메모
jdk1.8 이전에 자바의 주석은 같은 수식된 방법이나 속성에 직접 중복될 수 없다.수조나 다른 방식을 통해서만 이 수요를 실현할 수 있다.
jdk1.8에서 주석을 같은 수식된 방법이나 속성에 중복적으로 나타낼 수 있다.

public class AnnotationTest {

    @Target({ ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    @Repeatable(Roles.class)
    public static @interface Role {
        String value();
    }

    @Target({ ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    public static @interface Roles {
        Role[] value();
    }

    public static class RepeatableAnnotationTest {

        @Role("admin")
        @Role("user")
        public void doProcess() {
        }
    }

    public static void main(String[] args) throws Exception {
        RepeatableAnnotationTest obj = new RepeatableAnnotationTest();

        Method method = obj.getClass().getDeclaredMethod("doProcess");

        Role[] annotations = method.getAnnotationsByType(Role.class);

        // @cn.xxx$Role(value=admin)
        // @cn.xxx$Role(value=user)
        Arrays.stream(annotations).forEach(System.out::println);
    }
}

5 JavaScript 엔진

public static void main(String[] args) throws ScriptException {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("JavaScript");
    Object ret = engine.eval("function add(i,j){return i+j;} add(1,1);");
    
    //out: 2.0
    System.out.println("out: " + ret);
}

6 JVM 메모리 모델 변경
영구 벨트가 제거되어 Metaspace가 도입되었습니다.
자세한 내용은 다음을 참조하십시오.http://blog.csdn.net/hylexus/article/details/53771460