Las nuevas características Java8 4 tenedor / clase unirse y opcional

Después de java8 paralelo () y secuencial () se conecta en paralelo con la corriente de flujo paralelo

empaquetar corriente; 

importación java.time.Duration;
importación java.time.Instant;
importación java.util.concurrent.ForkJoinPool;
importación java.util.concurrent.ForkJoinTask;
importación java.util.concurrent.RecursiveTask;
importación java.util.stream.LongStream; 

/ ** 
 * @autour ZDC 
 * @create 2020-03-24-23: 53 
 * / 
público  de clase ForkJoinCaculate extiende RecursiveTask <Larga> { 

    privada  estática  última  larga serialVersionUID = 1222222L ;
    privada comienzan mucho;
    privado largo final;
    privada  estática  largo THESHOLD = 10000L ; 

    pública ForkJoinCaculate (empezar largo, largo final) {
         este .start = comenzar;
        este .end = final; 
    } 

    @ Override 
    protegida largo de cómputo () {
         larga duración = End- arranque;
        si (longitud < THESHOLD) {
             larga suma = 0 ;
            para ( largo i = inicio; i <= final; i ++ ) { 
                suma + = i;
            } 
            Devolver suma; 
        } 
        Demás { 
            largo mediados = (start + final) / 2 ; 
            ForkJoinCaculate dejó = nueva ForkJoinCaculate (inicio, mitad); 
            left.fork (); 
            ForkJoinCaculate derecha = nuevo ForkJoinCaculate (mediados + 1 , final); 
            right.fork (); 
            volver left.join () + right.join (); 
        } 
    } 

    Pública  estáticas  void main (String [] args) { 
        Comienzo inmediato = Instant.now (); 

        piscina ForkJoinPool= Nuevo ForkJoinPool (); 
        ForkJoinTask <Larga> task = nueva ForkJoinCaculate (0l, 1000000000l ); 
        Larga suma = pool.invoke (tarea); 
        System.out.println (suma); 

        Final instantánea = Instant.now (); 

        System.out.println (Duration.between (inicio, final) .toMillis ()); 

        Start1 instantánea = Instant.now (); 
        resumir = 0L ;
        para (Long i = 0L; i <= 1000000000l; i ++ ) { 
            suma + = i; 
        } 
        System.out.println (suma);

        END1 la instantánea = Instant.now (); 
        System.out.println (Duration.between (Start1, END1) .toMillis ()); 

        // paralelo () y secuencial () se conecta en paralelo con la corriente de flujo paralelo después de java8 
        largo sum1 = LongStream .rangeClosed (0, 1000000000) .reduce (0 , Long :: SUM);
         larga . LongStream.rangeClosed SUM2 = (0, 1000000000) .parallel () el reducir (0 , Long :: SUM);
         larga sum3 = LongStream.rangeClosed . (0, 1000000000) .sequential () al reducir (0 , Long :: SUM); 
        System.out.println (SUM2); 

    } 

}

Opcional

@Test
     pública  vacío Test3 () { 

        // Opcional El buque es capaz de bloquear rápidamente NullPointerException NullPointerException evitar la molestia 


        Opcional El <la Persona> OP = Optional.of ( nueva nuevo la persona ( "ZZZ", 33 es , 445D));
         // Opcional la <la persona> Optional.of OP1 = (null); // informaron anormal 

        Opcional la <la persona> Optional.empty OP3 = (); // crear una instancia vacía
         // System.out.println (op3.get () ); // informó anormal 

        // nulo pasar sobre NULL construir una instancia de objeto se pasa sobre la construcción del complejo y el vacío 
        opcional el <la persona> OP4 = Optional.ofNullable ( nulo ); 
        opcional el <la persona> OP5 = Optional.ofNullable ( nuevo nuevoLa persona ( "ZZ", 22,11.3 )); 


        SI (op3.isPresent ()) { 
            System.out.println ( "op3w no vaciar" ); 
        } else { 
            System.out.println ( "nulll" ); 
        } 

        // OP3 para volver valor nulo dado orElse (T T) 
        la Persona ZZZ = op3.orElse ( nuevo nuevo la Persona ( "ZZZ", 22 es decir, 22,2 )); 

        // orElseGet (Proveedor s) para el valor de retorno de s 
        OP3. orElseGet (la persona :: nueva nueva ); // devolver un argumento nulo porque el constructor de interfaces de proveedor 


        // proceso de la hoja si su valor 
        opcional la <String> op5.map S = (P -> p.getName ()); 

        / / flatMap retorno opcional
        Opcional <String> s1 = op5.flatMap (p -> Optional.of (p.getName ())); 
    }

Resolver excepción de puntero nulo:

empaquetar corriente; 

/ ** 
 * @autour ZDC 
 * @create 2020-03-25-01: 00 
 * / 
público  de clase Perro {
     privado Bola de la cadena; 

    pública Perro () { 
    } 

    pública perro (Bola de la cadena) {
         este .ball = pelota; 
    } 

    Pública getBall String () {
         retorno de pelota; 
    } 

    Pública  estáticas  void main (String [] args) { 
        perro perro = nuevo perro (); 
        dog.getBall (); 
        // 发生空指针异常
        System.out.println (dog.getBall () longitud ().);
        // 解决方法
        si (= perro! Nula ) { 
            secuencia de la bola = dog.getBall ();
            si (= bola! nula ) 
                System.out.println (ball.length ()); 
        } 
    } 
}

opcional reemplazado

empaquetar corriente; 

importación javax.swing.text.html.Option;
importación java.util.Optional; 

/ ** 
 * @autour ZDC 
 * @create 2020-03-25-01: 00 
 * / 
público  de clase Perro {
     // 注意!!! 
    privado opcional <String> = bola Optional.empty (); 

    pública Perro () { 
    } 

    pública perro (Opcional <String> bola) {
         este .ball = pelota; 
    } 

    Pública opcional <String> getBall () {
         retorno de pelota; 
    } 

    Pública  estática  vacíoprincipal (String [] args) { 
        Opcional <Dog> perro = Optional.ofNullable ( nulo ); 
        Cadena s = dog.orElse ( nueva . Perro ()) getBall () OrElse ( "默认的球". ); 
        System.out.println (s); 


    } 
}