Java 9 HackDay: Introducción a Java 9

HackDay Java 9
Java 9 en nuestro idioma
Noviembre 25 - 2017

Nos acompañan
Perú JUG
Barcelona JUG

Nuestros invitados
Heather VanCura
Java Community Process
@heathervc
Mani Sarkar
Adopt Open JDK
@theNeomatrix369

Speakers
Hillmer Chona
Colombia
@hchona
David Gomez
España
@dgomezg
Mercedes Wyzz
Guatemala
@itrjwyss
Alberto Salazar
Ecuador
@betoSalazar

Agenda
- Adopta Open JDK
- Sesión 1: Introducción a Java 9
- Sesión 2: Java 9: Más allá de la modularización
- Java Community Process
- Receso (Media Mañana, Tiempo para un algo, media tarde, etc)
- Sesión 3: JShell
- Sesión 4: JLink
- Comentarios y retroalimentación (FeedBack)

Adopta Open JDK
15 Minutos
Mani Sarkar
Adopt Open JDK
@theNeomatrix369

Estamos listos para iniciar?
Java 9
http://jdk.java.net/9/
https://adoptopenjdk.net/releases.html
Repositorio GIT
https://github.com/AdoptOpenJDK/jdk9-jigsaw/tree/master/es

Sesión 1: Introducción a Java 9
15 Minutos
Hillmer Chona
Colombia
MedellinJUG
@hchona

Que significa modularización en Java 9
Es la división del JDK en un conjunto de módulos que pueden ser combinados en
tiempos de ejecución, compilación, o construcción. Esto permite entender y definir
las dependencias entre módulos.
La modularidad permite a los desarrolladores de manera más fácil ensamblar y
mantener las aplicaciones. También permite a Java reducirse para poder ser
utilizadas en pequeños dispositivos mientras la seguridad y el rendimiento es
mejorado.

Java, el lenguaje: Dividido en módulos Sesión 1: Introducción a Java 9

Java, el lenguaje: Gráfico de dependencias

Porque modularización en Java 9
Viene funcionando por cerca de una década
Configuración confiable
- Define dependencias entre módulos
- Resuelve problemas de ClassPath
Fuerte encapsulación
- Define o oculta lo que no es necesario que tenga acceso público
- JDK APIs internas (sun.misc.unsafe, security, etc…)
- APIs internas de nuestras aplicaciones

Porque modularización en Java 9
Otros efectos y beneficios
- Permite remover lo que no necesitamos (bajo acoplamiento y alta cohesión)
- Runtime customizables
- Mejora la distribución y mejora el rendimiento de ejecución
- Altamente requerido para IoT, arduino/dispositivos embebidos, ect.

Antes Vs Despues de Java 9 Sesión 1: Introducción a Java 9

Estructura de paquetes en disco Sesión 1: Introducción a Java 9

Estructura de paquetes en disco Sesión 1: Introducción a Java 9
Modulo org.medellinjug.hobbies Paquete org.medellinjug.hobbies

Definición de dependencias Sesión 1: Introducción a Java 9
module-info.java

Manos a la obra: Workshop sesión 1
60 Minutos

Manos a la obra: Es tiempo de practicar
Que necesitamos
- JDK 9 instalado y configurado
- Consola de comando: DOS, Terminal, Git Bash
- Opcional: Editor de texto, explorador de archivos

https://github.com/AdoptOpenJDK/jdk9-jigsaw/tree/master/es
Ejercicios a trabajar:
01, 02, 03, 04, 05 y 09

es: directorio con archivo README con la
explicación en Español del ejercicio
src: directorio con los códigos fuentes de cada
taller
README.md: Archivo con la explicacioón en Inglés
Archivos .sh: Archivos que contienen los scripts
para compilar, empaquetar o ejecutar los talleres,
ejecutarlos en el orden que cada taller indica.
Revisarlos con un editor de texto para ver los
comandos que ejecuta cada uno

Recuerde
No se trata de terminar todos los ejercicios o terminar de primero, la meta
es divertirnos, compartir (no sólo con los asistentes a nivel local, anímese a
compartir con los asistentes de las otras ciudades), colaborar, ayudar a
otros y pasar un buen rato

Sesión 2: Java 9: Más allá de la modularización
20 Minutos

Sesión 2: Java 9: Más allá de la modularización
20 Minutos
David Gomez
MadridJUG
España
@dgomezg
https://goo.gl/8W18mf
https://goo.gl/AroY8i

¿Qué nos ha traído Java 9?
¿Modularidad?

• Collections factory methods
• Interface changes
• Improvements in Optional<T>
• Stream enhancements
• Multi-release JAR files
• Reactive programming (Flow API)
• Stack Walking API
• New Deprecation
• try with resources improved
• REPL shell
• @safeVarArgs on private instance methods
• emoji in source code
• UTF-8 in property files
• G1 as default collector
• String changes (Compact strings, sharing
interned strings between JVMs)
• Unified JVM logging
• Spin-Wait hints
• VarHandles & Method Handles
Java 9 trae un montón de cosas

$java
WARNING: --permit-illegal-access will
be removed in the next major release
--illegal-access=--permit-illegal-accessdenypermitwarndebug
Jigsaw. Deshabilitar el control de acceso

Java 9: Más allá de la modularización
Colecciones

List<String> numbers = Arrays.asList("UNO", "DOS", "TRES");
List<Contact> contacts = new ArrayList<>();
contacts.add(new Contact("David", "Madrid", "555-55 55 55", LocalDate.of(1975, Month.MARCH, 26)));
contacts.add(new Contact("Nando", "Malaga", "555-55 55 56", LocalDate.of(1980, Month.APRIL, 30)));
contacts.add(new Contact("Hilmer", "Medellin", "555-75 44 63", LocalDate.of(1983, Month.JUNE, 29)));
contacts.add(new Contact("Antón", "Vigo", "555-66 66 73", LocalDate.of(1979, Month.SEPTEMBER, 7)));
contacts.add(new Contact("Olivier", "Paris", "555-66 66 61", LocalDate.of(1977, Month.DECEMBER, 22)));
*Crear e inicializar una lista en Java < 9

public final List<String> divisibleBy4 =
List.of("CUATRO", "OCHO", "DOCE", "DIECISEIS");
public final Map<String, Integer> numbers = Map.of(
"UNO", 1,
"DOS", 2,
"TRES", 3);
public final Set<Integer> negative = Set.of(-1,-2,-3);
9Java 9 Factory Methods. Colecciones

Collection Factory Methods. Características
static <E> Set<E> of() {}
static <E> Set<E> of(E e1) {}
static <E> Set<E> of(E e1, E e2) {}
static <E> Set<E> of(E e1, E e2, E e3) {}
[…]
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5,
E e6, E e7, E e8, E e9, E e10) { }
static <E> Set<E> of(E... elements) {}
Métodos sobre cargados de 0 a 10 elementos
9

static <E> Set<E> of(E e1, E e2, E e3) {
return new ImmutableCollections.SetN<>(e1, e2, e3);
}
Collection Factory Methods. Características 9
Colecciones inmutables

static <E> Set<E> of() {
return ImmutableCollections.Set0.instance();
}
Reutiliza colecciones vacías
9

static <E> Set<E> of() {
return ImmutableCollections.Set0.instance();
}
static <E> Set<E> of(E e1) {
return new ImmutableCollections.Set1<>(e1);
}
static <E> Set<E> of(E e1, E e2) {
return new ImmutableCollections.Set2<>(e1, e2);
}
static <E> Set<E> of(E e1, E e2, E e3) {
return new ImmutableCollections.SetN<>(e1, e2, e3);
}
Implementaciones específicas para 0, 1, 2 & N elementos
9

static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2) {
return new ImmutableCollections.MapN<>(k1, v1, k2, v2);
}
Map<String, Integer> numbers = Map.of("UNO", 1,"DOS", 2);
static <K, V> Map<K, V> ofEntries(Entry<K,V>... entries) { }
Oculta la estructura del Entry para Mapas
9
(Sólo para mapas de menos de 10 elementos)

Interfaces
(Milling coin project)

public interface Iterable<T> {
Iterator<T> iterator();
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
}
Interfaces. Métodos por defecto (Java 8)
Extensión de contratos (sin romper implementaciones)
Conversión de interfaces complejos en @FunctionaInterfaces
8

public interface Locatable {
GeoPoint getLocation();
default boolean isInside(GeoPoint... points) {
//compose a polygon from points[]
return;
}
default boolean isInBorder(int borderSize, GeoPoint... points) {
//compose a poligon from points[]
//check if distance from getLocation to any edge is less than borderSize
return;
}
}
Java 9 Interfaces. Métodos privados.
8

return;
}
return;
}
private Poligon getPoligonFrom(GeoPoint... points) {
return new Poligon();
}
}
8

getPoligonFrom(points);
return;
}
getPoligonFrom(points);
return;
}
private Poligon getPoligonFrom(GeoPoint... points) {
return new Poligon();
}
}
9

Java 9 Interfaces. Métodos privados. Ventajas
Reutilización de código en métodos de extensión
Mantiene el código limpio
Expone sólo el API público del interfaz

Mejoras en Optional

Optional. Más popular de lo que se esperaba
Pensado inicialmente como tipo de retorno para métodos.
The JSR-335 EG felt fairly strongly that Optional should not be
on any more than needed to support the optional-return idiom
only.
Someone suggested maybe even renaming it to OptionalReturn

Optional. Más popular de lo que se esperaba
Adecuado en ciertos casos, pero:
No pensado como contenedor de atributos
No como argumento de un método
No para evitar el NullPointerException

Optional. The mother of all bikesheeds
https://goo.gl/i13Cu4

Optional. Casos de uso
public class Contact implements Comparable<Contact> {
private String name;
private String city;
private String phoneNumber;
private boolean emergency = false;
} public class ContactBook extends ArrayList<Contact> {
public Optional<Contact> getEmergency() {
return this.getFirstThat(Contact::isEmergency);
}
public Optional<Contact> getFirstContactFromCity(String city) {
return getFirstThat(c -> c.getCity().equalsIgnoreCase(city));
}
private Optional<Contact> getFirstThat(Predicate<Contact> predicate) {
return this.stream().filter(predicate).findFirst();
}
}

Optional<Contact> emergencyCall = contactBook.getEmergency();
if (emergencyCall.isPresent()) {
emergencyCall.get().getPhoneNumber();
}
Contact emergencyCall = contactBook.getEmergency();
if (emergencyCall != null) {
emergencyCall.getPhoneNumber();
}
Optional. Uso NO preferido
get() para el valor (¡Cuidado! ¡puede lanzar NoSuchElementException)
Usar isPresent() para comprobar el valor
¿No se parece eso a la comprobación de nulos?

Optional. Uso recomendado
Mejor utilizar ifPresent(Consumer<T>)
contactBook.getEmergency()
.ifPresent(contact -> new PhoneDialer().dial(contact));

Optional. Mejoras en Java 9. ifPresentOrElse
Recibe
Un Consumer<T> (invocado cuando hay valor)
Y un Runnable (invocado cuando no hay valor)
emergencyCall.ifPresentOrElse(
contact -> phoneDialer.dial(contact),
() -> phoneDialer.dial("112"));

Optional. orElseGet (Java 8)
Recibe un Supplier<T> (invocado cuando no hay valor)
La legilibilidad puede mejorarse
8
Contact emergencies = new Contact("Emergencies", "Spain", "112");
String emergencyNumber =
emergencyCall.orElseGet(() -> emergencies)
.getPhoneNumber();
phoneDialer.dial(emergencyNumber);
Permite retornar un valor por defecto

Optional. Más legible en Java 9 con or()
Recibe un Supplier<Optional<T>>
9
or() crea un Optional<T> que contiene el valor por defecto
Contact emergencies = new Contact("Emergencies", "Spain", "112");
Optional<String> emergencyNumber =
contactBook.getEmergency()
.or(()->Optional.of(emergencies)
phoneDialer.dial(emergencyNumber.get());

Optional. Stream<Optional<T>>
Hay que gestionar específicamente el isPresent() y el get()
8
Llamar a un contacto de cada ciudad cercana
ciudadesCercanas.stream()
.map(contactBook::getFirstContactFromCity)
//now we have Stream<Optional<Contact>>
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(phoneDialer::dial);

Optional. Java 9 Optional.stream()
Optional.stream() retorna un stream de 0 o 1 elementos
Usaremos flatMap() para aplanarlo
9
Llamar a un contacto de cada ciudad cercana
ciudadesCercanas.stream()
.map(contactBook::getFirstContactFromCity)
.flatMap(Optional::stream)
.forEach(phoneDialer::dial);

Mejoras en Streams

Stream. takeWhile()
Nos permite parar streams infinitos
9
Útil para cortar el procesamiento ante una condición externa
Files.lines(Paths.get("urls.txt"))
.takeWhile(__ -> running)
.forEach(url -> URLChecker::check);

Stream. dropWhile()
9
Útil para cortar el procesamiento ante una condición externa
Files.lines(Paths.get("urls.txt"))
.dropWhile(__ -> !running)
.forEach(url -> URLChecker::check);

Stream. Método iterate() enriquecido
¡Cuidado con operaciones como: sort(), max()...!
9
iterate() devuelve Streams infinitos
IntStream infiniteEvenNumbers = IntStream.iterate(0, i -> i+2);
IntStream evenNumbers = IntStream.iterate(0, i -> i < 500, i -> i+2);
IntStream evenNumbers = IntStream.iterate(0, __ -> running, i -> i+2);
Alternativa con el formato iterate(seed, hasNext, getNext)

Stream. Método de factoría ofNullable()
9
Crea un stream vacío cuando el valor es null
/**
* Returns a sequential {@code Stream} containing a single element, if
* non-null, otherwise returns an empty {@code Stream}.
*
* @param t the single element
* @param <T> the type of stream elements
* @return a stream with a single element if the specified element
* is non-null, otherwise an empty stream
* @since 9
*/
public static<T> Stream<T> ofNullable(T t) {
return t == null ? Stream.empty()
: StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
}

Otros cambios más alla
de la modularización

• MultiRelease Jar files
• Flow API (estándar para sistemas reactivos)
• StackWalking
• Nuevo parametro en @Deprecated
• VarHandles
• Cambios internos en String
Y la lista sigue...

• @SafeVarArgs on private instance methods
• emoji in source code
• UTF-8 in property files
• _ not allowed as identifier
• Unified JVM logging
• Spin-Wait hints
… Y sigue ...
// This comment is 💩

El JCP nos Saluda
Heather VanCura, Mercedes Wyss

Receso (Media Mañana, Tiempo para el algo, media tarde)
25 Minutos
Sesión1: Introducción a Java 9

Sesión 3: JShell
15 Minutos
Mercedes Wyzz
Guatemala
@itrjwyss

Java Shell Tool
● REPL (Read-Evaluate-Print Loop)
● Aprender Java
● Prototipar Código Java
https://docs.oracle.com/javase/9/jshell/toc.htm
Sesión 3: JShell

Inicializando JShell
Sesión 3: JShell
Verbose mode Normal mode
$ jshell -v $ jshell
| Welcome to JShell -- Version 9-internal
| For an introduction type: /help intro
jshell>

Diferencia del Modo
Sesión 3: JShell
Verbose mode Normal mode
int x = 6;
x ==> 6
| created variable x : int
jshell> int x = 6;
x ==> 6

Snippets
● Sentencias
● Variables
● Métodos
Sesión 3: JShell
● Clases
● Imports
● Expresiones

Sentencias
Sesión 3: JShell
jshell> 5 + 16 * 3
$1 ==> 53
| created scratch variable $1 : int

Variables
Sesión 3: JShell
jshell> int x = 24
x ==> 24
| created variable x : int
jshell> String str = "Ejemplo"
str ==> "Ejemplo"
| created variable str : String

Métodos
Sesión 3: JShell
jshell> void asteriscos(int n){
...> for(int i = 1; i <= n; i++){
...> for(int j = 0; j < i; j++){
...> System.out.print("*");
...> }
...> System.out.println();
...> }
...> }
| created method asteriscos(int)

Métodos
Sesión 3: JShell
jshell> asteriscos(4)
*
**
***
****

Clases
Sesión 3: JShell
jshell> class Ejemplo {
...> public void sayHi(){
...> System.out.println("Hola!!!");
...> }
...> }
| created class Ejemplo

Clases
Sesión 3: JShell
jshell> Ejemplo ejemplo = new Ejemplo()
ejemplo ==> Ejemplo@4dfa3a9d
jshell> ejemplo.sayHi()
Hola!!!

Cambio de Definiciones
Sesión 3: JShell
jshell> int elevar(int n){ return n * n;}
| created method elevar(int)
jshell> elevar(4);
$9 ==> 16

Cambio de Definiciones
Sesión 3: JShell
jshell> int elevar(int n){ return n * n * n;}
| modified method elevar(int)
jshell> elevar(4)
$11 ==> 64

Comandos
● /vars
● /methods
● /open
Sesión 3: JShell
● /help
● /exit
● /save
● /list
○ -all
○ -history
○ -start
○ -<tab>

/save
Sesión 3: JShell
jshell> /save [-all|-history|-start] <file>
jshell> /save -all HackatonOpenJDK.java

/open
Sesión 3: JShell
jshell> /open <file>
jshell> /open HackatonOpenJDK.java

https://github.com/AdoptOpenJDK/jdk9-jigsaw/tree/master/session-3-jshell
Sesión 2: JShell

Manos a la obra: Como nos fué (feedback)
10 Minutos
Sesión 2: JShell

Sesión 4: Introducción a JLink
5 Minutos
Alberto Salazar
Ecuador
@betoSalazar

Pre-Java 9
Sesión 3: JLink
Applicacion:
Paquetes &
Clases
JDK (javac)
Paquete
(Distribuible)
Compila
r Creamo
s
Crear y empaquetar nuestro
artefacto, que corre donde
quiera, pero necesita una
plataforma específica JDK
Depende
o necesita
Para correr JVM (the
Platform)
Java, el
lenguaje
(Packages &
Clases)

Java 9
Sesión 3: JLink
Creamo
s
Crear un aplicación
standalone distribuible
(smaller footprint), que corre
en una plataforma específica
JVM, the Platform
Java, el lenguaje (JDK
modules)
JDK
Nuestra
Applicacion:
Módulos
Compila
JDK:
Módulos
JLink
Aplicacion (App modules)

https://github.com/AdoptOpenJDK/jdk9-jigsaw/tree/master/session-2-jlink
Sesión 3: JLink
30 Minutos

Manos a la obra: Como nos fué (feedback)
10 Minutos
Sesión 3: JLink

Java 9 HackDay: Introducción a Java 9

Recommended

Recommended

More Related Content

Similar to Java 9 HackDay: Introducción a Java 9

Similar to Java 9 HackDay: Introducción a Java 9 (20)

Recently uploaded

Recently uploaded (20)

Java 9 HackDay: Introducción a Java 9