Como programador seguramente has trabajado con una infinidad de colecciones, seguramente te ha tocado recorrerlas, ordenarlas, dividirlas, filtrarlas, eliminar o agregar nuevos elementos en la colección. Y cada vez que hacías esto estabas casi forzado a realizar un foreach sobre la colección, incluso, tenías que hacer un foreach anidado para poder realizar operaciones más complejas; prueba de ello es que el nombre ConcurrentModificationException  te recuerda a algo (¿o no?).

Pues bien, los Streams no permite crear atajos a la hora de procesar colecciones, creando flujos de datos que permite el procesamiento de una forma declarativa, es decir, que nos centramos en lo que queremos resolver, y no en cómo debemos hacerlo, como pasa en la programación imperativa.

Sígueme en mi canal de Youtube

Pero dejémonos de palabrerías (que me sobran) y vallamos a un escenario concreto donde se puede aplicar para entender mejor. Veamos el caso más simple al utilizar una colección, imprimamos todos los valores de una lista ¿Simple no?

public static void printForeach(){
  List<String> names = getStringArray();
  for (String name : names) {
     System.out.println(name);
  }
}

Este código que está viendo, es un escenario normal que utilizarías para imprimir todos los elementos de una lista (apuesto que sí), ¿verdad que no tiene nada de extraño? La verdad es que no, porque ya estamos acostumbrados a hacerlo así, pero te apuesto que tu punto de vista acerca de este código cambiaría si ti dijera que puedo hacer el foreach en una solo línea de código. ¿no me crees? Pues tómala!!

public static void printStream(){
    List<String> names = getStringArray();
    names.stream().forEach(System.out::println);
}

Probablemente te estés preguntado ¿qué clase de brujería es eso?, pero la realidad es que no hay tal brujería, simplemente estamos utilizando los Streams. Notemos que estamos utilizando el método stream() para obtener el Stream, seguido, solo utilizamos el método forEach() en el cual definimos mediante lo que vamos a hacer para cada elemento de la colección. En este caso estamos imprimiendo cada empleado utilizando Referencia a métodos.

Para comprender mejor que es un stream (espero no herir los sentimientos de algunos) lo voy a explicar de una forma simple fácil de digerir y que pueda que no cuadre con la definición perfecta, pero seguro me entenderás. Imagina que los streams son una forma de iterar todos los elementos de la colección de una forma simple, y que además mientras los iteras puedes realizar operaciones sobre la colección de forma declarativa. Es decir, vamos a realizar operaciones pero centrándonos en el objetivo que buscamos, no en cómo implementar el algoritmo para que funcione. Veamos otro ejemplo más complejo.

Imaginemos que tenemos una lista de Empleados, cada empleado tiene un ID que lo identifica como único, tiene un nombre y el departamento el que pertenece. La lista de empleados es la siguiente:

Ahora bien, sobre esta lista queremos filtrar todos los Empleados que pertenecen al departamento de sistemas, luego vamos a ordenas todos los empleados de forma ascendente por su nombre, luego vamos a filtrar los elementos repetidos mediante su ID, finalmente, imprimiremos el nombre de todos los empleados que cumplieron con todas las reglas. Pfff!! ¿Imaginas hacer esto con una colección? A mí ya me empezó a doler la cabeza 🙁 . Por suerte, el enfoque declarativo de los Streams nos permite enfocarnos solamente en el que y no en el cómo. Veamos cómo quedaría la solución usando Streams.

public static void printOrderedSystemEmployees(){
    List<Employee> employess = getEmployeeArray();
    employess.stream()
            .filter(x -> x.getDepartment().equals("Systems"))
            .sorted((x,y) -> x.getName().compareToIgnoreCase(y.getName()))
            .distinct()
            .forEach(System.out::println);
}

Ves lo fácil que es hacer todo esto con los Streams, solo nos preocupamos por lo que queremos hacer pero no por el cómo. Veamos los métodos del Stream utilizados, filter, nos permite filtrar elementos de la lista, para lo cual solo deberemos crear una expresión que regrese un boolean, si regresa true, entonces es agregado al Stream de resultados. Luego tenemos el método sorted() en el cual definimos cual es mayor mediante la comparación de los nombres. Seguido, utilizamos el método distinct() para filtrar los Empleados repetidos, para esto hemos sobreescrito el método equals para comprar por el ID en lugar del Hashcode. Finalmente un foreach para imprimir los resultados:

• Fernanda Martinez
• Liliana Castro
• Oscar Blancarte
• Rebeca Perez

¡Realmente sorprendente verdad!!, al menos para mí si… Pues bien, así como vimos algunos métodos interesantes de los Streams, debes de saber que la interface Stream proporciona varios métodos interesantes que te pueden ayudar muchísimo, sin embargo la intención de este artículo es introducirte en el concepto de los Stream y que logres entender que son y cómo se utilizan, por lo que si quieres aprender todavía más, poder ver este link, donde explican a profundidad la interface Stream y todos los métodos que expone. Me gustaría explicarte a detalle cada uno de los métodos disponibles, pero en realidad creo que sería reinventar la rueda, pues en el link se explica mucho mejor de lo que yo mismo podría hacerlo.

El resultado se puede apreciar mejor con la siguiente imagen:

En fin, creo que si lograste entender que son los Streams yo me doy por bien servidor, pero si por algún motivo tienes alguna duda, puedes escribirme en la sección de comentarios y con gusto te contestaré.

The post Java 8 – Streams appeared first on Oscar Blancarte - Software Architecture.

La siguiente imagen muestra más claro cómo funciona la referencia a métodos:

En la imagen podemos ver una interface funcional, la cual define un método abstracto, por otro lado, tenemos una clase Custom, la cual define un método implementado, este método tiene un cuerpo y una funcionalidad previamente implementada. Sabemos que el método abstracto de la interface funcional no tiene implementada una funcionalidad, pues es una interface, y queremos que el método abstracto haga referencia al método de la clase Custom, por lo cual “asignamos” o referenciamos el método de la clase custom por medio del método de la interface funcional. Para que un método pueda ser referenciado debe de coincidir los parámetros y el retorno de la interface funcional con el del método que queremos referenciar, por lo tanto, el nombre del método no importaría.
¿Pero cómo funciona esto?
Cuando referenciamos un método, lo que pasa es que la funcionalidad del método original es implementada con una referencia al método referenciado, esto quieres decir que cuando ejecutemos el método de la interface funcional, en realidad lo que pasara es que se ejecutara el método de la otra clase.

Tipos de métodos referenciados:

• Referencia a un método estático
• Referencia a un método de un objeto
• Referencia a un método de un objeto arbitrario
• Referencia a un constructor

Antes de explicarlos, me gustaría que vieras el código, trates de familiarizarte con las clases para después entrar en la explicación. El código completo lo puedes encontrar GitHub: https://github.com/oscarjb1/MethodReferences.git

La siguiente clase es un Interface Funcional debidamente anotada con @FunctionalInterface , Esta interface la cual utilizaremos como base para referenciar los métodos.

package com.osb.referencedmethod;

/**
* @author Oscar Blancarte <oscarblancarte3@gmail.com>
*/
@FunctionalInterface
public interface IHello {
public void sayHello();
}

La siguiente clase será utilizada para referencias a su constructor.

package com.osb.referencedmethod;

/**
* @author Oscar Blancarte <oscarblancarte3@gmail.com>
*/
public class Hello implements IHello {

private String helloMessage;

public Hello() {
System.out.println("Hey!!! i'am a constructor");
}

public void createHello(String helloMessage) {
this.helloMessage = helloMessage;
}

@Override
public void sayHello() {
System.out.println(this.helloMessage);
}
}

La siguiente clase tiene el contenido más importante de este artículo, en ella veremos los 4 tipos de referencias a métodos.

package com.osb.referencedmethod;

import com.osb.referencedmethod.IHello;
import java.util.Arrays;

/**
* @author Oscar Blancarte <oscarblancarte3@gmail.com>
*/
public class Methods {
public static void sayStaticHello() {
System.out.println("Hey!!! i'am a static hello!");
}

public void sayInstanceHello() {
System.out.println("Hey!!! i'am a instance hello");
}

public static void main(String[] args) {
//Referencia a un método estatico
IHello staticRef = Methods::sayStaticHello;
staticRef.sayHello();

//Referencia a un método de un objeto
Methods methods = new Methods();
IHello instanceRef = methods::sayInstanceHello;
instanceRef.sayHello();

//Referencia a un método de un objeto arbitrario
String[] names = new String[]{"Oscar", "Alex", "Maria", "Samuel", "Perla", "Fausto"};
Arrays.sort(names, String::compareToIgnoreCase);
System.out.println("Hey!!! i'am a ordered array " + Arrays.toString(names));

//Referencia a un constructor
IHello hello = Hello::new;
hello.sayHello();
}
}

Una vez, analizadas las clases pasaremos explicar, pero antes, me gustaría que vieras el resultado de la ejecución del proyecto:

Hey!!! i'am a static hello!
Hey!!! i'am a instance hello
Hey!!! i'am a ordered array [Alex, Fausto, Maria, Oscar, Perla, Samuel]
Hey!!! i'am a constructor

¡Impresionante no!!!, ¿esperabas este resultado? Si es así, entonces quieres decir que ya estas más familiarizado con Java 8 y las expresiones lambda, pero si no es así, no importa, porque a continuación explicaremos lo que está pasando. Para hacer esta explicación más simple, asumiremos que ya conocemos que son las interfaces funcionales, si no es así, aquí explico cómo. Pues bien, iniciaremos con las referencias a los métodos estáticos, para lo cual regresaremos a las líneas 20-21, observemos que estamos creando la variable staticRef, la cual es de tipo IHello (Recordemos que IHello es una interface funcional), pero al asignarle valor a la variable, no lo hacemos con un new, si no que indicamos que la interface funcional se debe implementar con el método sayStaticHello el cual está definido en la clase Methods, para hacer la referencia al método sayStaticHello de la clase Methods. Para hacer la referencia se utiliza :: (Cuadro puntos o dos dobles punto). Al ejecutar el método en la línea 21, vemos que se imprime “Hey!!! i’am a static hello!”.
La otra forma de implementar las referencias es por medio de los métodos a un objeto en particular como en las líneas 24-26, en la cual vemos que primero instanciamos la clase Methods, luego volvemos a utilizar :: para hacer referencia al método sayInstanceHello, observa que esta vez utilizamos el objeto en lugar de la clase, ya que este método no es static. Al ejecutar el método se imprimirá “Hey!!! i’am a instance hello”.
Otra de las formas de implementar la referencia a métodos es por medio de un objeto arbitrario. Se dice arbitrario, porque en realidad no sabes sobre que objeto vamos hacer la referencia, pero si sabes el tipo de datos, por lo tanto, podemos asumir los métodos que tiene para referenciarlos. Un ejemplo de esto está en las líneas 29-31. Veamos lo que vamos a hacer, tenemos un Array de Strings el cual tiene una serie de nombre que queremos ordenar, para lo cual vamos a utilizar la clase Arrays, esta clase nos permite ordenar Objetos que implementen la interface Comparator, esta interface es una interface funcional debido a que solo tiene el método public int compareTo(T o), por lo que podríamos mandar una referencia a un método que pueda implementarla, en este caso veamos que al método sort le mandamos el array de nombre y una referencia al método compareToIgnoreCase el cual tiene la siguiente definición public int compareToIgnoreCase(String str), veamos que tanto compareTo y compareToIgnoreCase reciben el String a comprar y los dos regresan un int, por lo tanto la referencia a métodos es compatible. Lo que pasa entonces en la línea 30, es que la lista será iterada, y por cada String, llamará a su método compareToIgnoreCase, notemos algo muy importante…. La instrucción String::compareToIgnoreCase, no es una referencia a un método estático como podríamos creer, en su lugar, como sabemos que es una lista de String, le estamos diciendo que de cada String que está en la lista, use su método compareToIgnoreCase para comprar el siguiente elemento de la lista. Es por eso que se llama referencia a métodos de objetos arbitrario, porque conocemos el tipo de datos, pero no el objeto concreto. Al imprimir la lista, veremos una lista correctamente ordenada: “Hey!!! i’am a ordered array [Alex, Fausto, Maria, Oscar, Perla, Samuel]”

Finalmente, tenemos la referencia a constructores, la cual nos permitirá asignar la referencia de un constructor a el método de la interface funcional, de tal forma que cuando ejecutemos el método, este en realidad llamará al constructor de la clase referenciada. Como vemos en las líneas 34-35, estamos haciendo referencia al constructor mediante los :: (cuatro puntos) seguido del operador new, así de fácil. Finalmente cuando ejecutemos el método sayHello, este en realidad llamará al constructor de la clase Hello y se imprimirá en pantalla: “Hey!!! i’am a constructor”. Recordemos que las clases pueden tener más de un constructor, ¿entonces como sabe Java a que constructor llamar?, pues es fácil, llamará al que tenga compatibilidad con los parámetros de la interface funcional. Como en este caso, el método sayHello, no recibe parámetros, entonces se llama al constructor sin parámetros de la clase Hello. Por otra parte, si el método recibiera un String, entonces llamaría al constructor que recibe un solo parámetro. ¡Así de fácil!

Conclusiones:

Desde mi punto de vista, los métodos y constructores referenciados fueron de las cosas más extrañas que me parecieron del Java 8, pues al inicio no lograba entender cómo funcionaba a la perfección, sobre todo la referencia a métodos de un objeto arbitrario, pero la verdad es que es solo práctica, tenemos que descargar el código y probar, modificar las clases y probar de nuevo. Si no experimentamos se nos hará muy difícil entenderlas, pero más a un recordarlas cuando las necesitemos.
Como verás esta fue una guía rápida de los métodos referenciados, pero si tienes dudas, déjamelas en los comentarios y con gusto las resolveré. Recuerda que puedes descargar el código y a practicar.

Si estas interesado en seguir aprendiendo más de las mejoras de Java 8 te dejo este Enlace donde están todos los artículos que he escrito sobre Java 8

The post Java 8 – Métodos referenciados appeared first on Oscar Blancarte - Software Architecture.

Las interfaces funcionales es un nuevo concepto que fue agregado a partir de la versión 8 de Java y cobran su importancia al utilizar expresiones lambda (λ).

Ejemplo de interfaces funcionales:

A continuación, veremos ejemplos de dos interfaces funcionales válidas:

package com.osb.functionalinterface;

/**
 * @author Oscar Blancarte 
 */
public interface IStrategy {
    public String sayHelloTo(String name);
}

En esta interface, definimos un método que manda un saludo a la persona que le pasamos como parámetro, pero todavía no está definido el cuerpo del método.

package com.osb.functionalinterface;

/**
 * @author Oscar Blancarte 
 */
public interface IStrategy {
    
    public String sayHelloTo(String name);
    
    public default String sayHelloWord(){
        return "Hello word";
    }
}

Esta segunda interface, también es una interface funcional, ya que solo tiene un método abstracto.

Otra forma de asegurarnos de que estamos definiendo correctamente una interface funcional, es anotarla con @FunctionalInterface , ya que al anotarla el IDE automáticamente nos arrojara un error si no cumplimos con las reglas de una interface funcional. Sin embargo, es importante resaltar que en tiempo de ejecución no nos dará un comportamiento diferente, puesto que es utilizada para prevenir errores al momento de definir las interfaces. Veamos cómo quedaría la clase anterior con esta anotación:

package com.osb.functionalinterface;

/**
 * @author Oscar Blancarte 
 */
@FunctionalInterface
public interface IStrategy {
    
    public String sayHelloTo(String name);
    
    public default String sayHelloWord(){
        return "Hello word";
    }
}

Interfaces funcionales con expresiones lambda:

Ya con la teoría, veamos cómo podría utilizar la clase IStrategy  mediante expresiones lambda:

package com.osb.functionalinterface;

/**
 * @author Oscar Blancarte
 */
public class Main {
    public static void main(String[] args) {
        IStrategy strategy = (name) -> "Hello " + name;
        
        System.out.println(strategy.sayHelloTo("Oscar Blancarte"));
        System.out.println(strategy.sayHelloWord());
    }
}

Veamos como en la línea 8 definimos una expresión lamba en donde concatena Hello con el nombre de la persona que es pasada como parámetro, luego esta expresión es asignada a la variable a la variable strategy , la cual es de tipo IStrategy . Luego de esto mandamos llamar al método sayHelloTo  el cual nos regresa el saludo para Oscar Blancarte, seguido en la línea 11 llamamos al método sayHelloWord , el cual manda un Hello Word.

Como vemos la expresión lambda siempre se asigna al método abstracto, por este motivo el método sayHelloTo  es implementado con el cuerpo de la expresión lamba, mientras que el método sayHelloWord  continua con la misma implementación que viene desde la interface.

Observemos la imagen anterior, cuando una expresión lambda es asignada a una interface, está siempre implementará el método abstracto, es por esta razón por la que solo puede existir un método abstracto y muchos defaults.

Finalmente, el resultado de la ejecución es el siguiente:

Hello Oscar Blancarte

Hello word

The post Java 8 – Interfaces funcionales appeared first on Oscar Blancarte - Software Architecture.

Para agregar un método default solo será necesario marcar un método con el operador default , veamos un ejemplo de cómo se implementan:

public default double getTotal(){
  return getQuantity() * getPrice();
}

Los métodos default se utilizan cuando es necesario implementar un cuerpo sin la necesidad de tener que implementar por separado una clase abstracta, además los métodos por default se pueden sobrescribir en caso de que la implementación por default no cumpla con lo que requerimos. Tenemos que resaltar que los métodos default no remplazan a las clases abstractas, pues estas últimas son mucho más potentes, debido a que nos permiten definir propiedades a nivel de clase, constructores y métodos privados. Veamos una limitante de los métodos default:

public default double getTotal(){
  return quantity * price;
}

Esta interface nos va a marcar error en tiempo de compilación, debido a que no es posible declarar propiedades de clase y mucho menos interactuar con ellas, por lo que estamos limitados a trabajar con los parámetros o con los métodos definidos en la misma interface o que extiende de otra.

Un ejemplo práctico:

Imaginemos que estamos programando un sistema que procesa ordenes de varios tipos, cómo el caso de un ERP, este sistema, podría crear varios tipos de órdenes, como una orden de compra, venta, embarque, etc. todas estas órdenes podrían tener algo en común, cómo, por ejemplo, un total, una lista de ítems asociados a la orden y los ítems pueden tener una cantidad de productos y un precio, así mismo los detalles tendrían un total.

El código completo de este articulo lo puedes encontrar en GitHub: https://github.com/oscarjb1/DefaultMethod.git

Lo interesante aquí es que si todas las ordenes tiene un total, ¿no sería bueno tener una definición del método por default que nos calcule el total y a la vez los ítems también implementen su método para obtener el total? De la misma forma, si una orden tiene ítems, no sería bueno definir un método que permite agregar los ítems.

Veamos cómo quedaría si implementáramos los métodos por default, implementaremos dos interfaces, una que representa una order (IOrder ) y otra que representa los ítems (IOrderItem ):

package com.osb.defaultmethod;

import java.util.List;

/**
 * @author Oscar Blancarte
 */
public interface IOrder {
    
    public List<IOrderItem> getOrderItem();
    
    public default double getTotal(){
        double total = 0;
        for (IOrderItem item : getOrderItem()) {
            total += item.getTotal();
        }
        return total;
    }
    
    public default void addOrderItem(IOrderItem orderItem){
        getOrderItem().add(orderItem);
    }
}

Analicemos los métodos de la clase IOrder:

• getOrderItem: método que nos regresará los ítems que tiene la orden, no lo podemos implementar porque no es posible definir propiedades a nivel de clase, salvo constantes. Por lo que la clase que la implemente deberá de regresar una lista de ítems.
• getTotal: este método nos regresará el total de la orden, es decir la sumatoria de todos los ítems de la orden. Cuanta con el operador default lo que nos permite implementarlo recorriendo todos los ítems de la orden y sumando su total.
• addOrderItem: método default que nos permite agregar fácilmente nuevos ítems a la orden.

package com.osb.defaultmethod;

/**
 * @author Oscar Blancarte
 */
public interface IOrderItem {
    
    public double getQuantity();
    public double getPrice();
    
    public default double getTotal(){
        return getQuantity() * getPrice();
    }
}

Esta segunda interface representa los ítems de la orden, cuanta con los métodos:

• getQuantity: deberá retornar la cantidad de productos que tiene la línea.
• getPrice: deberá de retornar el precio por producto.
• getTotal: método default que calcula el total de la línea, multiplicando la cantidad por el precio.

Hasta este punto ya hemos implementado todos los métodos default y continuaremos creando un par de clases concretas que implementen estas dos interfaces para ver cómo funcionaría en tiempo de ejecución. Para esto crearemos las siguientes clases:

package com.osb.defaultmethod;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Oscar Blancarte
 */
public class SalesOrder implements IOrder{
    
    private List<IOrderItem> orderItems;

    @Override
    public List<IOrderItem> getOrderItem() {
        if(orderItems==null){
            orderItems = new ArrayList<>();
        }
        return orderItems;
    }
}

En esta clase representará una orden de venta, por lo cual deberá de implementar la interface IOrder , pero como podemos ver, solo nos pedirá que implementemos el método getOrderItem  el cual es el único que no es default, los métodos getTotal  y addOrderItem  ya estarán implementados por default y se podrán utilizar sin necesidad de declararlos en la clase.

El método getOrderItem  solo regresa la lista de ítems, en caso de que la lista sea nula la crea y la retorna.

La siguiente clase representa los ítems de la orden de venta:

package com.osb.defaultmethod;

/**
 * @author Oscar Blancarte
 */
public class SalesOrderItem implements IOrderItem {
    
    private double quantity;
    private double price;

    public SalesOrderItem(double quantity, double price) {
        this.quantity = quantity;
        this.price = price;
    }
    
    @Override
    public double getQuantity() {
        return quantity;
    }

    @Override
    public double getPrice() {
        return price;
    }
    
}

Podemos observar que implementan la interface IOrderItem  la cual nos pedirá que implementemos los métodos getQuantity  y getPrice  los cuales ya hemos explicado. El método getTotal  ya está implementado por default desde la interface, por lo que ya no será necesario implementarlo en la clase.

Finalmente, la clase Main , en donde pondremos a prueba lo que hemos aprendido para ver cómo se comportan los métodos por default en tiempo de ejecución:

package com.osb.defaultmethod;

/**
 * @author Oscar Blancarte
 */
public class Main {
    public static void main(String[] args) {
        SalesOrder salesOrder = new SalesOrder();
        salesOrder.addOrderItem(new SalesOrderItem(10, 100));
        salesOrder.addOrderItem(new SalesOrderItem(1, 20));
        System.out.println("total ==> " +salesOrder.getTotal() );
    }
}

Lo primero que hacemos es crear una instancia de la Orden de venta (línea 8), luego en las líneas 9 y 10 agregamos dos nuevos ítems. Notemos que el método addOrderItem  esta implementado como default en la clase IOrde . Cada ítem define un precio y la cantidad.

Finalmente, en la línea 11 imprimimos el total de la orden, el total de la orden es calculado desde el método default de la clase IOrder  sumando el total de los ítems y el total de cada ítem también es calculado mediante el método default implementado desde la interface IOrderItem .

Como resultado de la ejecución tendremos:

total ==> 1020.0

Conclusiones:

Los métodos default son sin duda una gran utilidad, sobre todo porque nos evita tener que tener que implementar clases abstractas, pero como ya lo mencionamos no las sustituyen.

The post Java 8 – Default Method appeared first on Oscar Blancarte - Software Architecture.