Tipos de Colecciones

Un ArrayList es la implementación más conocida de una Collection, aunque también existen LinkedList y otras implementacions no detalladas en este post. En este enlace se puede profundizar en su conocimiento de forma más exahustiva.

Además de List existe otra interfície que deriva de Collection llamada Set cuyas implementaciones más conocidas son Hashset y TreeSet (implementación ésta de la interfaz SortedSet).

Existe una tercera interfaz que también deriva de Collection llamada Queue. En este enlace puede encontrarse información más detallada.

Para un mayor detalle y nivel de profundidad respecto a la clase Collections de Oracle, puede consultarse su documentación oficial online en este enlace para el JDK 7.

Autoboxing & Unboxing

Streams

El término define una corriente de datos de una fuente a un destino.

Todos los datos fluyen a través de un ordenador desde una entrada (fuente) hacia una salida (destino).

Los fuentes y destinos de datos son nodos de los flujos en la comunicación del ordenador. Todos los flujos presentan el mismo modelo a todos los programas Java que los utilizan:

Flujos de Datos (Bytes y carácteres)

Fig. 1 Tipos de Datos admitidos en Java

• Métodos básicos de lectura de Streams
  • Clase InputStream (Bytes)
    • int read()
    • int read(byte[] buffer)
    • int read(byte[] buffer, int offset, int length)
  • Clase Reader (Caracteres)
    • int read()
    • int read(char[] buffer)
    • int read(char[] buffer, int offset, int length)

• Métodos básicos de escritura de Streams 
  • Clase OutputStream (Bytes)
    • void write(int c)
    • void write(byte[] buffer)
    • void write(byte[] buffer, int offset, int length)
  • Clase Writer (Caracteres)
    • void write(int c)
    • void write(char[] buffer)
    • void write(char[] buffer, int offset, int length)
    • void write(String string)
    • void write(String string, int offset, int length)

Flujos en Memoria Intermedia

Para la lectura de archivos cortos de texto es mejor utilizar FileInputStream en conjunción con FileReader. A continuación se añaden algunos ejemplos con código fuente para la memoria intermedia.

1.-Ejemplo TestBufferedStreams

package bufferedstreams;

import java.io.*;

public class TestBufferedStreams {

    public static void main(String[] args) {
        try (
           BufferedReader bufInput = 
       new BufferedReader(new FileReader("src\bufferedstreams\file1.txt"));
           BufferedWriter bufOutput = 
       new BufferedWriter(new FileWriter("src\bufferedstreams\file2.txt"))
        ){
            String line = bufInput.readLine();
            while (line != null) {
               
                bufOutput.write(line, 0, line.length());
                bufOutput.newLine();               
                line = bufInput.readLine();                
            }
        } catch (IOException e) {
            System.out.println("Exception: " + e);
        }
    }
}

2.-Ejemplo TestCharactersStreams

package bufferedstreams;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestCharactersStreams {

    public static void main(String[] args) {
        try (FileReader input = new FileReader("src\bufferedstreams\file1.txt");
             FileWriter output = new FileWriter("src\bufferedstreams\file2.txt")) {

            int charsRead;
            while ((charsRead = input.read()) != -1) {
                output.write(charsRead);
            }
        } catch (IOException e) {
            System.out.println("IOException: " + e);
        }
    }
}

Ejemplo de entrada y salida estándar

import java.io.*;

public class KeyboardInput {

    public static void main(String[] args) {

        try (BufferedReader in = new BufferedReader(new InputStreamReader(System.in))) {
            String s = "";
            while (s != null) {
                System.out.print("Type xyz to exit: ");
                s = in.readLine().trim();                
                System.out.println("Read: " + s);
                System.out.println("");

                if (s.equals("xyz")) {
                    System.exit(0);
                }
            }
        } catch (IOException e) {
            System.out.println("Exception: " + e);
        }
    }
}

Persistencia

1.- Ejemplo DeserializeMyClass

package persistence;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeserializeMyClass {

    public static void main(String[] args) {
        
        MyClass myclass = null;
        
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("file1.ser"))) {
            myclass = (MyClass) in.readObject();
            
        } catch (ClassNotFoundException | IOException e) {
            System.out.println("Exception deserializing file1.ser: " + e);
        }
        System.out.println("a = " + myclass.a);
        System.out.println("b = " + myclass.b);
        System.out.println("cad1 = " + myclass.getCad1());
        System.out.println("cad2 = " + myclass.getCad2());
    }
}

2.- Ejemplo MyClass

package persistence;

import java.io.Serializable;

public class MyClass implements Serializable {

    public int a = 0;
    private String cad1 = "";
    static int b = 0;    
    private transient String cad2 = "";
    Student student = new Student();

    public String getCad1() {
        return cad1;
    }

    public void setCad1(String cad1) {
        this.cad1 = cad1;
    }

    public String getCad2() {
        return cad2;
    }

    public void setCad2(String cad2) {
        this.cad2 = cad2;
    }
}

3.- Ejemplo SerializeMyClass

package persistence;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializeMyClass {

    public static void main(String[] args) {
        
        MyClass myclass = new MyClass();
        myclass.a = 100;
        myclass.b = 200;
        myclass.setCad1("Hello World");
        myclass.setCad2("Hello student");

        try (ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("file1.ser"))) {
            o.writeObject(myclass);
            
        } catch (IOException e) {
            System.out.println("Exception serializing file1.ser: " + e);
        }
    }
}

4.- Ejemplo Student

package persistence;

public class Student {

    String name = "Darío";
    int age = 3;
}

Recordatorio 

Las clases BufferedReader y BufferedWriter aumentan la eficacia de las operaciones de entrada y salida. Estas clases permiten gestionar el búfer y escribir o leer línea por línea. A continuación se añade un ejemplo sencillo utilizando un BufferedReader para leer la cadena «xyz» y finalizar la ejecución.1.-Ejemplo utilizando BufferedReader

try (BufferedReader in = new BufferedReader(
  new InputStreamReader(system.in)))) {
   String s = "";
   System.out.print("Type xyz to exit");
   s = in.readline().trim();
   System.out.print("Read "+s);

   // ...
}

Tipos de Excepciones

Excepciones comprobadas (checked).

Representan errores producidos durante la ejecución de un programa por condiciones inválidas en el flujo esperado. Estos errores pueden ser previsibles o esperables y por eso se puede definir un flujo alternativo para tratarlos. Es el caso, por ejemplo, de errores de conexión de red, errores en la localización de ficheros, conexión a base de datos, etc. En estos casos, se puede aplicar una política de re-intentos o bien informar al usuario del error de forma controlada si se trata de un entorno interactivo.

Los métodos están obligados a tratar de alguna manera las excepciones de este tipo producidas en su implementación, ya sea relanzándolas, apilándolas o tratándolas mediante un bloque try/catch.

Exception y subclases, excepto RuntimeException y subclases.

Excepciones no comprobadas (unchecked).

Representan errores producidos durante la ejecución de un programa de los que no se espera una posible recuperación o no se pueden tratar. Se incluyen entre estos casos errores aritméticos, cómo divisiones entre cero, excepciones en el tratamiento de punteros, cómo el acceso a referencias nulas (NullPointerException) u errores en el tratamiento de índices, cómo por ejemplo el acceso a un índice incorrecto de un array.

Este tipo de errores pueden ocurrir en cualquier lugar de la aplicación y no se requiere su especificación en la firma de los métodos correspondientes o su tratamiento a través de bloques try/catch (aunque es posible hacerlo) lo que facilita a la legibilidad del código.

RuntimeException, Error y subclases de éstas.

En concreto la excepción no comprobada Error representa errores producidos por condiciones anormales en la ejecución de una aplicación que nunca deberían darse. En su mayoría se trata de errores no recuperables y por esta razón, este tipo de excepciones no extienden de Exception y si de Throwable con el propósito que no sean capturadas accidentalmente por ningún bloque try/catch que pueda impedir la finalización de la ejecución. A nivel de compilación, estos se tratan de igual forma que las excepciones no comprobadas, por lo que no hay la obligación de declarar su lanzamiento en las firmas de los métodos.

Ejemplos:

Jerarquía de Excepciones

La jerarquía de las excepciones en Java 7 puede visualizarse en el siguiente esquema:

Fig. 1. Jerarquía de excepciones

La superclase de todas las excepciones es Throwable.

La clase Exception sirve como superclase para crear excepciones de propósito específico, es decir, adaptado a nuestras necesidades.

La clase Error está relacionada con errores de compilación, del sistema o de la JVM. Normalmente estos errores son irrecuperables.

RuntimeException (Excepciones Implícitas): Excepciones muy frecuentes relacionadas con errores de programación. Existen pocas posibilidades también de recuperar situaciones anómalas de este tipo.

Lanzamiento de Excepciones

//  Crear una excepcion
MyException me = new MyException("Myexception message");

//  Lanzamiento de la excepción
throw me;

import java.util.*;

public class ExTryCatch {
 public static void main(String[] args){
  
  int i=-3;
  
  try{
   String[] array = new String[i];
   System.out.println("Message1");
  }
  
  catch(NegativeArraySizeException e){
   System.out.println("Exception1");
  }
  
  catch(IllegalArgumentException  e){
   System.out.println("Exception2");
  }
  
  System.out.println("Message2");
  
 }
}

import java.util.*;

public class ExFinally {
 public static void main(String[] args){
  
  int i=5;
  
  try{
   String[] array = new String[i];
  }
  
  catch(NegativeArraySizeException e){
   System.out.println("Exception1");
  }
  
  catch(IllegalArgumentException  e){
   System.out.println("Exception2");
  }
  
  finally{
   System.out.println("This always executes");
  }
  
  
 }
}

public enum Day {

    SUNDAY("Sunday"),
    MONDAY("Monday"),
    TUESDAY("Tuesday"),
    WEDNESDAY("Wednesday"),
    THURSDAY("Thursday"),
    FRIDAY("Friday"),
    SATURDAY("Saturday");

    private final String name;

    private Day(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }   
}

Cuándo hay campos, métodos o constructores, la lista de constantes de la enumeración debe terminar con un punto y coma.

Las enumeraciones pueden implementar interfaces pero no pueden extender otras enumeraciones. Una posible utilidad de esto es «esconder» la enumeración referenciando a la interfaz:

public enum Day implements IDayOfWeek
{
             SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
             SATURDAY;
}

...

IDayOfWeek dow = Day.SUNDAY;

Las variables miembro de una clase se declaran siempre dentro de una clase pero de forma externa al constructor de la clase. Java es un lenguaje fuertemente tipado y esto obliga a que las variables deban inicializarse antes de ser utilizadas. En Java todos los parámetros son pasados por valor.

Constructores

Sentencias de control de flujo

Pueden encontrarse las sentencias for, if…else, do…while, while.

La sentencia switch

Fig. 3 Implementación de Switch en Java 7

evalúa el valor de una variable de tipo int, char o String.  Permite una acción u otra según el resultado de una comparación o un valor lógico. Permite también agrupar un mismo resultado para varios case.

Paso por valor

Encapsulación

En general se llaman métodos asignadores y recuperadores a los métodos que disponen de los valores encapsulados dentro de una clase.

Herencia

Consiste en un mecanismo de relación entre clases. Aunque cada clase sólo tiene una SUPERCLASE,  existe una clase que se encuentra en la parte superior de la estructura de herencia.

Es la clase Object, clase de la que derivan TODAS las clases Java y a la que TODOS sus hijos pueden acceder a sus variables miembro y métodos miembro.

La herencia se implementa mediante la palabra clave:

Polimorfismo

Sobrecarga de métodos (overloading)

Dentro de una misma clase es posible agrupar varias sobrecargas en Java para disponer de un sólo método pero que puede recibir distintas cargas o parámetros.

El mecanismo que permite la sobrecarga se llama varargs (o argumentos variables) y permite escribir un método más génerico del tipo siguiente

A nivel de JVM, el compilador siempre prefiere utilizar un método que contenga tipos de parámetros a los cuáles podamos convertir los tipos de argumentos utilizados en la llamada que utilizar un método que acepte argumentos variables.