Java: interfaces y métodos default

cafe-151346_640

Los métodos por default fueron introducidos en Java 8. Éstos permiten tener métodos implementados en las interfaces.

Ejemplo. Definir dos interfaces (Imprimible y Documentable) con un método default imprimir().

Imprimible.java

package interfaces;

public interface Imprimible{
//Método implementado
		default void imprimir(){
			System.out.println("Esto es imprimible");
		}
	}

Documentable.java

package interfaces;

public interface Documentable{
//Método implementado
		default void imprimir(){
			System.out.println("Esto es imprimible");
		}
	}

Ahora crearemos una clase llamada Documento. Esta clase implementará ambas interfaces.
Documento.java

package clases;
public class Documento implements Imprimible, Documentable{
	@Override 
	public void imprimir(){
//Aquí accedemos a la implementación 
		Imprimible.super.imprimir();
		Documentable.super.imprimir();
	}
}

Clase principal:

Test.java

package test;
public class Test{
	public static void main(String[] args){
		Documento documento = new Documento();
          documento.imprimir();
	}
}

Java 8 ha introducido algunos aspectos que hacen de la programación Java algo más dinámico y bastante útil.

Advertisements

Java: List y stream()

web-1935737_960_720

En Java 8 tenemos nuevas formas para tratar datos de una lista. Veremos algunas de ellas.

Definiremos tres listas y un arreglo:


import java.util.List;
import java.util.Arrays;
import static java.lang.System.out;

//...

List numeros = Arrays.asList(11,15,21,24,27,33,39,45,46,52,66,68,73,75,80,83,90,94);
List nombres = Arrays.asList("Andrea","Luis","Juan","Ana","Pedro","Julia","Julio");
List caracteres = Arrays.asList('1','A','F','$','3','6','D','Q','@');
int[] enteros = {0,1,2,3,4,5,6,7,8,9};

forEach, para recorrer una lista o array:

//Recorrer con forEach

/*lista.forEach*/
numeros.forEach(out::print);out.println();
nombres.forEach(out::print);out.println();
caracteres.forEach(out::print);out.println();

/* Arrays.stream(array).forEach  */
Arrays.stream(enteros).forEach(out::print);out.println();

Donde:

lista.stream().forEach(Class::staticMethod)

boxed y collect

//Convertir array a lista (usando boxed() y collect())
//...
List listaEnteros = Arrays
    .stream(enteros)
    .boxed()
    .collect(Collectors.toList());
    listaEnteros.forEach(out::print);out.println();

sorted()

//Ordenar nombres (sorted())
    List nombresOrdenados = nombres.stream().sorted().collect(Collectors.toList());
    out.println("Nombres [no ordenados]:\n"+nombres);
    out.println("Nombres [ordenados]:\n"+nombresOrdenados);

filter

//...
//Filtrar numeros con filter()
List divisiblesEntre3 = numeros
    .stream()
    .filter(n -> n%3==0).collect(Collectors.toList());
    List divisiblesEntre5 = numeros
    .stream()
    .filter(n -> n%5==0).collect(Collectors.toList());
    List divisiblesEntre3Y5 = numeros
    .stream()
    .filter(n -> n%3==0 && n%5==0).collect(Collectors.toList());
    out.println("Numeros:\n"+numeros);
    out.println("Numeros divisibles entre 3:\n"+divisiblesEntre3);
    out.println("Numeros divisibles entre 5:\n"+divisiblesEntre5);
    out.println("Numeros divisibles entre 3 y 5:\n"+divisiblesEntre3Y5);

map()

//Mayusculas con map()
nombres.stream().map(nom -> nom.toUpperCase()).forEach(c -> System.out.print(c+","));
    out.println();
List mayusculas = nombres.stream().map(nom -> nom.toUpperCase()).collect(Collectors.toList());
    mayusculas.forEach(c -> System.out.println(c+","));

reduce()

//reduce()
Arrays.stream(enteros).reduce((n,m) -> n+m).ifPresent(c -> System.out.printf("numero: %d\n",c));
listaEnteros.stream().reduce((n,m) -> n+m).ifPresent(c -> System.out.printf("numero: %d\n",c));

findAny()

//findAny
Character arroba = caracteres.stream().filter(c -> c == '@').findAny().orElse(null);
    out.println(arroba); 

Código completo:
Main.java

package com.codemonkey;


import static java.lang.System.out;
import java.util.*;
import java.util.stream.*;
  


public class Main{


  public static void main(String[] args){
    List numeros = Arrays.asList(11,15,21,24,27,33,39,45,46,52,66,68,73,75,80,83,90,94);
    List nombres = Arrays.asList("Andrea","Luis","Juan","Ana","Pedro","Julia","Julio");
    List caracteres = Arrays.asList('1','A','F','$','3','6','D','Q','@');
    int[] enteros = {0,1,2,3,4,5,6,7,8,9};

    //Recorrer con forEach
    numeros.forEach(out::print);out.println();
    nombres.forEach(out::print);out.println();
    caracteres.forEach(out::print);out.println();
    Arrays.stream(enteros).forEach(out::print);out.println();

    //Convertir array a lista (usando boxed() y collect())
    List listaEnteros = Arrays
    .stream(enteros)
    .boxed()
    .collect(Collectors.toList());
    listaEnteros.forEach(out::print);out.println();

    //Ordenar nombres (sorted())
    List nombresOrdenados = nombres.stream().sorted().collect(Collectors.toList());
    out.println("Nombres [no ordenados]:\n"+nombres);
    out.println("Nombres [ordenados]:\n"+nombresOrdenados);

    //Filtrar numeros con filter()
    List divisiblesEntre3 = numeros
    .stream()
    .filter(n -> n%3==0).collect(Collectors.toList());
    List divisiblesEntre5 = numeros
    .stream()
    .filter(n -> n%5==0).collect(Collectors.toList());
    List divisiblesEntre3Y5 = numeros
    .stream()
    .filter(n -> n%3==0 && n%5==0).collect(Collectors.toList());
    out.println("Numeros:\n"+numeros);
    out.println("Numeros divisibles entre 3:\n"+divisiblesEntre3);
    out.println("Numeros divisibles entre 5:\n"+divisiblesEntre5);
    out.println("Numeros divisibles entre 3 y 5:\n"+divisiblesEntre3Y5);

    //Mayusculas con map()
    nombres.stream().map(nom -> nom.toUpperCase()).forEach(c -> System.out.print(c+","));
    out.println();
    List mayusculas = nombres.stream().map(nom -> nom.toUpperCase()).collect(Collectors.toList());
    mayusculas.forEach(c -> System.out.println(c+","));

    //reduce()
    Arrays.stream(enteros).reduce((n,m) -> n+m).ifPresent(c -> System.out.printf("numero: %d\n",c));
    listaEnteros.stream().reduce((n,m) -> n+m).ifPresent(c -> System.out.printf("numero: %d\n",c));

    //findAny
    Character arroba = caracteres.stream().filter(c -> c == '@').findAny().orElse(null);
    out.println(arroba);    


  }

}

Links:

https://docs.oracle.com/javase/8/docs/api/?java/util/stream/Stream.html

 

Java: Lambdas

ec564-shomecode4

El procesamiento de datos en colecciones gracias al Stream de Java 8 ha hecho que el programador Java ahorre cierto tiempo a la hora de escribir código. A pesar que ya están liberadas las versiones 9,10 y 11 de Java aún quedan cosas por saber del API JSE 8.

En este post veremos un ejemplo del uso de stream.

  • Creremos una clase denominada Economica.java
  • Creremos una clase denominada Main.java, esta será la clase principal
  • Dentro de Main.java definiremos una lista de tipo Economica
  • Haremos uso de stream

Economica.java


package com.codemonkey.model;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Economica{
	@Setter @Getter private double presente;
	@Setter @Getter private double tasa;
	@Setter @Getter private int periodo;

	public double getFuturo(){
		return Math.floor(this.presente*Math.pow(1+this.tasa/100,this.periodo));
	}

	public double getRedito(){
		return (this.getFuturo()-this.presente)/this.presente;
	}

}

Los métodos

public double getFuturo() y public double getFuturo()

nos servirán para obtener el valor futuro de una cantidad (presente) con una tasa y periodo determinado y el rédito de la misma.

Código completo:

Main.java

package com.codemonkey;

import java.util.List;//interface
import java.util.ArrayList;//class
import java.util.stream.Collectors;
import static java.lang.System.out;

import com.codemonkey.model.Economica;

public class Main{

  public static void main(String[] args) {
    List listaEconomica = new ArrayList();
		listaEconomica.add(0, new Economica(2550.0, new Double("0.45"), new Integer("12")));
		listaEconomica.add(1, new Economica(2700.0, new Double("0.5"), new Integer("12")));
		listaEconomica.add(2, new Economica(new Double("300.00"), new Double("0.4"), new Integer("24")));
		listaEconomica.add(3, new Economica(new Double("2400.60"), new Double("0.4"), new Integer("11")));
		listaEconomica.add(4, new Economica(new Double("1000.00"), new Double("0.67"), new Integer("12")));
		listaEconomica.set(0, new Economica(new Double("250.0"), new Double("0.99"), new Integer("12")));

		//Mostrar todo:
		listaEconomica.forEach(out::println);

		out.println("\nPeriodo mas largo:");
		listaEconomica
		.stream()
		.filter(eco -> eco.getPeriodo() >=24 )
		.forEach(out::println);

		out.println("\nPeriodo mas corto:");
		listaEconomica
		.stream()
		.filter(eco -> eco.getPeriodo() <=12 ) 		.forEach(out::println); 		out.println("Valor futuro:"); 		List listaFuturo = listaEconomica.stream().map(eco -> eco.getFuturo()).collect(Collectors.toList());
		listaFuturo.forEach(out::println);

		out.println("Redito:");
		List listaRedito = listaEconomica.stream().map(eco -> eco.getRedito()).collect(Collectors.toList());
		listaRedito.forEach(out::println);

		out.println("Economica:");
		listaEconomica.stream().map(eco -> {
			return eco.toString()+ ", Valor futuro: "+eco.getFuturo()+", Redito: "+eco.getRedito();
		}).forEach(out::println);
  }

}

 

Ejemplo: Mostrar el valor futuro de una cantidad:

//…
out.println("Valor futuro:");
List listaFuturo = listaEconomica.stream().map(eco -> eco.getFuturo()).collect(Collectors.toList());
listaFuturo.forEach(out::println);

List listaEconomica = new ArrayList();
listaEconomica.add(0, new Economica(2550.0, new Double(“0.45”), new Integer(“12”)));
listaEconomica.add(1, new Economica(2700.0, new Double(“0.5”), new Integer(“12”)));
listaEconomica.add(2, new Economica(new Double(“300.00”), new Double(“0.4”), new Integer(“24”)));
listaEconomica.add(3, new Economica(new Double(“2400.60”), new Double(“0.4”), new Integer(“11”)));
listaEconomica.add(4, new Economica(new Double(“1000.00”), new Double(“0.67”), new Integer(“12”)));
listaEconomica.set(0, new Economica(new Double(“250.0”), new Double(“0.99”), new Integer(“12”)));

//Mostrar todo:
listaEconomica.forEach(out::println);

Ejemplo: Mostrar sólo el periodo más largo y el más corto:

import static java.lang.System.out;
//...


out.println("\nPeriodo mas largo:");
		listaEconomica
		.stream()
		.filter(eco -> eco.getPeriodo() >=24 )
		.forEach(out::println);

		out.println("\nPeriodo mas corto:");
		listaEconomica
		.stream()
		.filter(eco -> eco.getPeriodo() <=12 )
		.forEach(out::println);

Java: excepciones más comunes

code-geek-2680204_960_720

El lenguaje Java posee mecanismos para el tratamiento de excepciones en tiempo decompilación y ejecución, pero no para errores. Hay que precisar que mientras una excepción es una anomalía en el flujo normal de un programa, un error es una falla fatal que termina bruscamente un programa. El programador sólo le queda mirar como falla la JVM. Uno de los clásicos errores es el StackOverflowError, que ocurre cuando hay un desborde de pila (usualmente por un ciclo infinito).

También es importante notar que existen dos tipos de excepciones:

Excepciones marcadas, todas excepto las RuntimeException que ocurren en tiempo de compilación y que son obligatorias. IOException, SQLException,ClassNotFoundException,etc. son algunas de éstas.

Excepciones no marcadas, las que ocurren en tiempo de ejecución.  ClassCastException, IllegalArgumentException, NumberFormatException, ArithmeticException, NullPointerException, etc. son algunas de éstas.

En está clase (TestExcepciones.java) se puede ver algunas de las Excepciones en tiempo de ejecución (las RuntimeException).

package com.codemonkey;

import static java.lang.System.out;
import static java.lang.System.err;

public class TestExcepciones{

    public static void main(String ... args){
        out.println("\t---- Excepciones en Java ----\n");
    //java.lang.Object
    //java.lang.Throwable
    //java.lang.Exception
    //java.lang.RuntimeException
    //java.lang.ArithmeticException

    //División x cero
    try{
      int division = 4/0;
    }catch(ArithmeticException | NumberFormatException ae){
      err.println("Division por cero: ArithmeticException");
    }catch(Exception ex){
      ex.printStackTrace();
    }//Salida: Division por cero: ArithmeticException

    //java.lang.Object
    //java.lang.Throwable
    //java.lang.Exception
    //java.lang.RuntimeException
    //java.lang.IllegalArgumentException
    //java.lang.NumberFormatException 

    //Numero con formato no valido
    try{
      Integer entero = Integer.parseInt("123G");
    }catch(NumberFormatException | ArithmeticException nfe){
      err.println("Numero con formato no valido: NumberFormatException");
    }catch(Exception ex){
      ex.printStackTrace();
    }//Salida: Numero con formato no valido: NumberFormatException

    //java.lang.Object
    //java.lang.Throwable
    //java.lang.Exception
    //java.lang.RuntimeException
    //java.lang.ClassCastException

    //Casteo no valido
    try{
      Animal animal = new Perro();
      Perro perro = (Perro) animal;
      Gato gato = (Gato) animal;
    }catch(ClassCastException | NullPointerException cce){
      err.println("Casteo no valido: ClassCastException");
    }catch(Exception ex){
      ex.printStackTrace();
    }//Salida:Casteo no valido: ClassCastException"

    //java.lang.Object
    //java.lang.Throwable
    //java.lang.Exception
    //java.lang.RuntimeException
    //java.lang.IndexOutOfBoundsException
    //java.lang.ArrayIndexOutOfBoundsException

    //Acceder a un indice que no existe
    CharSequence[] charSequence = {"Adelaida","Arenita"};
    try{
      charSequence[2] = "El guero";
    }catch(ArrayIndexOutOfBoundsException | NullPointerException aie){
      err.println("Tratas de acceder a un indice que no existe: ArrayIndexOutOfBoundsException");
    }catch(Exception ex){
      ex.printStackTrace();
    }//Salida: Tratas de acceder a un indice que no existe: ArrayIndexOutOfBoundsException

    //java.lang.Object
    //java.lang.Throwable
    //java.lang.Exception
    //java.lang.RuntimeException
    //java.lang.NullPointerException 

    //Tratar de hacer uso de un objeto null
    String cadena = null;
    try{
      cadena = cadena.toUpperCase();
    }catch(NullPointerException npe){
      err.println("Objeto null: NullPointerException");
    }catch(Exception ex){
      ex.printStackTrace();
    }
    //Salida: Objeto null: NullPointerException

    }

}

Java 8: java.util.function

cup-985957_960_720

En el anterior post vimos algo sobre lambdas y algunos ejemplos. Ahora veremos el paquete java.util.function el cual provee de interfaces útiles para propósitos en específico. La documentación oficial dice que:

Functional interfaces provide target types for lambda expressions and method references.

Recordemos que una expresión lambda es una función anónima que no necesita depender de una clase.

Síntaxis:

(parámetros) -> { cuerpo lambda }

 

Las principales interfaces a usar son cuatro:

//...
import java.util.function.Consumer;//interface
import java.util.function.Function;//interface
import java.util.function.Supplier;//interface
import java.util.function.Predicate;//interface

//...

¿Para qué me sirve cada una de éstas interfaces?

Consumer: Puede o no recibir algún valor y no devolver nada.

Function: Puede tomar dos valores de distinto tipo y devolver un valor en específico.

Predicate: Puede tomar valores y devolver un valor booleano.

Supplier: No recibe valores, pero devuelve un valor.

Comencemos con el consumidor (Consumer):

//...
import java.function.Consumer;

import static java.lang.System.out;

//...

Consumer consumer = (cad) -> out.println("Hola, "+cad);

consumer.accept(new String("Codemonkey"));

Seguimos con Function:

//...
import java.function.Function;

import static java.lang.System.out;

//...

Function<Integer, String> function = num -> {
    if(num%3==0  && num%5==0){
      return num+" divisible entre 3 y 5";
    }else{
      return num+" no es divisible entre 3 y 5";
    }
};

out.println(function.apply(new Integer("25")));
out.println(function.apply(new Integer("8")));

Ahora Predicate:

//...
import java.util.function.Predicate;
import static java.lang.System.out;
//...
Predicate predicate = (cad) -> String.valueOf(cad).endsWith(".xml");
out.println(predicate.test("doc.pdf")? "Cierto" : "Falso");
out.println(predicate.test("doc.xml")? "Cierto" : "Falso");

Finalmente, Supplier:

//...
import java.util.function.Supplier;
import java.util.Random;
import static java.lang.System.out;
//...
Random random = new Random();
String[] moneda = {"AGUILA","SOL"};
Supplier supplier = () -> moneda[random.nextInt(2)];
out.println("Moneda: "+supplier.get());

Feliz código

Python para todos … no. 1

web-1935737_960_720

Python ha demostrado ser un lenguaje muy poderoso.  Mientras que con lenguajes como C, C# o Java requerimos escribir líneas y líneas incontables de código para leer el contenido de un archivo *.xlsx, con Python sólo bastan unas tres para hacerlo.

Ejemplo. Leer el contenido de un archivos separado por comas.

file = open("datos.csv","r")
print("Contenido:",file.readlines())

Con Python se procesar datos de un PDF, de un documento Word, enviar correo electrónico, etc.

¿Pero Python puede trabajar, por ejemplo, con Big Data, Batch, gestión de tareas síncronas y asíncronas, etc.?

Sí, pero es necesario instalar los paquetes necesarios.

En esta serie de posts veremos como usar librerías como Numpy, Pandas, SciPy, Matplotlib, etc.

¿Cómo instalamos las librerías en Python?

La instalación de librerías es muy sencillo:

$ py -m pip install librería

O

$ pip install librería

Ejemplo: Instalar paquetes necesarios para usar SciPy.

python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose

Nota: No es necesario instalar todos los paquetes. En esta serie de posts usaremos JuPyter y sólo instalaremos Numpy (https://pypi.org/project/numpy/) y Pandas (https://pypi.org/project/pandas/) desde https://pypi.org.

Instalando JuPyter

JuPyter es un entorno de desarrollo de manera interactiva.

$ python3 -m pip install --upgrade pip
$ python3 -m pip install jupyter

Lanzamos Jupyter desde la terminal de comandos:

$ jupyter notebook

¡Feliz código!

Links:

Pandas: https://pandas.pydata.org/ | https://pypi.org/project/pandas/

Numpy: http://www.numpy.org/ | https://pypi.org/project/numpy/

Scipy: https://www.scipy.org/install.html | https://pypi.org/project/scipy/

PyZo: https://pyzo.org/

WinPython: https://winpython.github.io/

JuPyter: https://jupyter.org/index.html | https://www.adictosaltrabajo.com/2018/01/18/primeros-pasos-con-jupyter-notebook/

Spark Apache: https://spark.apache.org/docs/0.9.0/index.html

Spring + Maven: creando un proyecto

maven java logo

Continuando con esta serie de ejemplos usando Spring y Maven veremos cómo crear un proyecto desde la línea de comandos. En está ocasión mostraremos algunas variables del entorno y un mensaje.

Crear proyecto:

mvn archetype:generate -DgroupId=com.codemonkey -DartifactId=SimpleApp -
DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Ahora dentro del directorio (simpleapp) teclear:

mvn eclipse:eclipse

Para poder abrir el proyecto con Eclipse IDE.

Agregar esto en el pom.xml:

<!-- Spring framework -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
    <version>2.5.6</version>
  </dependency> 

  

Teclear de nuevo:

mvn eclipse:eclipse

Creamos una clase:

Saludar.java

package com.codemonkey.component;

import org.springframework.stereotype.Component;

import static java.lang.System.out;

@Component
public class Saludar{
	public void diHola(){
    	out.println("Programando con Spring Framework");
    	out.println("Usuario: "+System.getProperty("user.name"));
    	out.println("Home: "+System.getProperty("user.home"));
    	out.println("Directorio: "+System.getProperty("user.dir"));
    	out.println("Arch OS: "+System.getProperty("os.arch"));
    	out.println("Name OS: "+System.getProperty("os.name"));
    	out.println("OS version: "+System.getProperty("os.version"));
    	out.println("Java home: "+System.getProperty("java.home"));
    	out.println("Java vendor: "+System.getProperty("java.vendor.url"));
    	out.println("Java version: "+System.getProperty("java.version"));
    }

    public String decirAdios(){
        return "Arrivaderci!";
    }

}

Clase principal:
SimpleAppApplication.java

package com.codemonkey;

/**
* mvn compile
* mvn package
* cd target
* java -jar SimpleApp-0.0.1-SNAPSHOT.jar
*/

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.codemonkey.component.Saludar;

@SpringBootApplication
public class SimpleAppApplication {

	public static void main(String[] args) {
		mockDemoD();
	}

	public static void mockDemoA(String[] argum){
		ApplicationContext context = SpringApplication.run(SimpleAppApplication.class, argum);
		Saludar saludar = (Saludar)context.getBean("saludar");
		saludar.diHola();
	}
}

Compilar:

mvn compile

Ejecutar:

mvn exec:java -Dexec.mainClass="com.codemonkey.SimpleApp"

Crear JAR:

mvn package

Ejecutar:

java -jar SimpleApp-0.0.1-SNAPSHOT.jar

 Links:
https://codemonkeyjunior.wordpress.com/2018/11/07/spring-maven/