Algunos tips para manejo de Strings en Java!

El manejo de cadenas de caracteres en java es considerablemente más sencillo que con otros lenguajes, gracias al cielo que los desarrolladores de java se tomaron en serio la idea de hacer una clase String decente. Esta entrada en mi blog tiene la intención de dar algunos tips básicos de manejo de esta clase.

Primero lo primero

Un String es una cadena de caracteres, un tipo y una clase en java. Se utiliza para representar palabras, frases, etc. Un String puede ser vacío "", puede tener solo una letra "a", o "puede tener toda una frase". Sobra decirlo, pero la manera de declarar un String es:

    
    String s;
    s = "hola";
    String x = "otro String"; 

Operadores sobre Strings

Los Strings soportan algunas operaciones, la más utilizada es la concatenación, que permite "pegar" un String con otro (+), con un número o con una letra. La otra operación obvia es la asignación (=). Ahora un ejemplo de ello:

   
   int numero = 4; 
   String cadenaCompuesta = "Esta es"+" una "+"cadena "+'c'+'o'+"mpuesta"; //aquí pego cadenas con letras
   String otraCadena = "Leere este post al menos "+numero+" veces"; //aquí pego cadenas con números
   String cadena = "";
   cadena+="algo"; //aquí agrego una palabra a lo que ya había
   cadena+=" mas"; //aquí agrego otra palabra a lo que ya había

Métodos de uso común

Los Strings tienen algunos métodos que se pueden usar para facilitarle la vida a quien programa, estas son algunas funciones comunes:

- charAt: dado un número, retorna el caracter ubicado en la posición enviada como parámetro
- contains: dada una cadena, retorna true si esta contenida en otra
- length: retorna la longitud
- endsWith: retorna true si la cadena termina con un sufijo enviado como parámetro
- equals: retorna true si dos cadenas son iguales
- indexOf: retorna la posición de la primera ocurrencia de una cadena enviada como parámetro
- isEmpty: retorna true si el tamaño de la cadena es cero
- lastIndexOf: retorna la posición de la última ocurrencia de una cadena enviada como parámetro
- replace: reemplaza una cadena por otra
- startsWith: retorna true si la cadena inicia con un prefijo enviado como parámetro
- subString: retorna una subcadena dada posición de inicio y una longitud
- toLowerCase: convierte la cadena a minúsculas
- toUpperCase: convierte la cadena a mayúsculas

Ahora unos ejemplos de como funcionan los anteriores métodos...

                String s = "Sonido";
		char c = s.charAt(0);//S
		char c2 = s.charAt(1);//o
		boolean b = s.contains("oni");//true
		boolean b2 = s.contains("xx");//false
		int i = s.length();//6
		boolean b3 = s.endsWith("do");//true
		boolean b4 = s.equals("Sonido");//true
		boolean b5 = s.equals("sonido");//false
		int i2 = s.indexOf("on");//1
		boolean b6  = "".isEmpty();//true
		boolean b7 = s.isEmpty();//false
		int i3 = s.lastIndexOf("o");//5
		String s2 = s.replace("ido", "pa");//Sopa
		boolean b8 = s.startsWith("Son");//true
		String s3 = s.substring(1, 3);//on
		String s4 = "SoNiDo".toLowerCase();//sonido
		String s5 = "SoNido".toUpperCase();//SONIDO

Excepto por la Excepción....

¿Por qué excepciones?

Resulta que las excepciones son mecanismos que emplean los lenguajes de programación para manejar los posibles errores que puede tener una aplicación que estamos construyendo. Muchas veces, de manera intuitiva definimos ciertas convenciones para expresar que un procedimiento no cumplió su objetivo. Consideremos el siguiente algoritmo de búsqueda:

 

 public static int buscarPersona(int id, Persona[] conjuntoPersonas)
 {
  for (int i = 0; i < conjuntoPersonas.length; i++) 
  {
   if(id == conjuntoPersonas[i].getId())
   {
    return i;
   }
  }
  return -1;
 }

La anterior búsqueda retornaría la posición del arreglo donde se encuentra la persona que estamos buscando, sin embargo retornará -1 si esa persona no es encontrada en el arreglo. En este caso estamos utilizando el valor -1 como una convención que significa "No pude encontrar la persona en cuestión", lo cual es un comportamiento no esperado en la ejecución del método que estamos diseñando.

Así como el ejemplo anterior, los programadores nos valemos de un montón de convenciones para decir si una ejecución de un procedimiento fué exitosa o no; sin embargo manejar los casos de error de esta manera puede ser confuso cuando la complejidad de nuestros procedimientos es mayor. Además, las convenciones que utilizamos solo tienen significado para quien programó el procedimiento, razón por la cual quien llame nuestro método de búsqueda podría interpretar ese -1 como un resultado válido, lo cual puede desencadenar efectos inesperados (por ejemplo que el usuario de este método acceda a la posición -1 de ese arreglo).

La excepción salvando el día

Bueno, vamos a modificar el código de nuestra búsqueda para que avise que hubo un error de manera explícita, las excepciones son precisamente eso. 

 
public static int buscarPersona(int id, Persona[] conjuntoPersonas)throws Exception
{
 for (int i = 0; i < conjuntoPersonas.length; i++) 
 {
  if(id == conjuntoPersonas[i].getId())
  {
   return i;
  }
 }
 throw new Exception("Persona no encontrada");
}

Ahora nuestro método persona tiene dos cambios, en su encabezado (firma del método) aparece la palabra throws que indica que nuestro método podría lanzar una excepción, seguido de esta palabra se escribe el tipo de excepción que puede lanzar, en este caso la excepción más básica representada en la clase Exception. También se modifica el lugar donde retornamos -1 y en vez de ello creamos y lanzamos la excepción que anunciamos, en este caso una que lleva como mensaje : "Persona no encontrada". Para ello usamos la palabra reservada throw e instanciamos un objeto de tipo Exception. La palabra throw interrumpe el flujo del programa, razón por la cual cualquier línea después no será ejecutada.

El lado del cliente (versión sin excepción)

Ahora supongamos que usamos la primera versión de nuestro método de búsqueda (la que no usa excepciones). Nuestro código se vería más o menos así:

public static void modificarPersona ( int id , String nuevoNombre, Persona[] conjuntoPersonas )
{
 int posicion = buscarPersona(id, conjuntoPersonas);
 if(posicion != -1)
 {
  Persona p = conjuntoPersonas[posicion];
  p.setNombre(nuevoNombre);
 }
}

Este método le cambia el nombre a una persona, previamente la busca usando nuestro método del ejemplo anterior. Nótese el if horrible que hace que no se pueda modificar la persona en caso que la búsqueda devuelva -1. Quien lee este código está obligado a saber que ese -1 significa "no lo encontró", lo cual empeora si no es la misma persona quien escribe los dos métodos, no hay documentación o peor aún el método buscarPersona está en otra clase de la cual no se dispone del código fuente.

Sin embargo, podría ser peor...

public static void modificarPersona ( int id , String nuevoNombre, Persona[] conjuntoPersonas )
{
 int posicion = buscarPersona(id, conjuntoPersonas);

 Persona p = conjuntoPersonas[posicion];
 p.setNombre(nuevoNombre);
 
}

En este caso ni siquiera se toma en cuenta que el método podría fallar, por ende podríamos estar accediendo a la posición -1 del arreglo y generando un error grave en nuestra aplicación. ¿Quién tiene la culpa?

El lado del cliente (con excepción) y las cláusulas try, catch y finally

Bueno, ahora usemos la versión decente (con excepción) del método de búsqueda. Una de las ventajas de usar excepciones es que el compilador de java nos obliga a tratarlas, evitando que se pase por alto el caso de error. Revisemos una versión de nuestro método cliente usando excepciones.

public static void modificarPersona ( int id , String nuevoNombre, Persona[] conjuntoPersonas )
{
 int posicion;
 try 
 {
  posicion = buscarPersona(id, conjuntoPersonas);
  Persona p = conjuntoPersonas[posicion];
  p.setNombre(nuevoNombre);
  
 } 
 catch (Exception e) 
 {
  e.printStackTrace();
  //esta linea imprime en la consola la
  //traza de llamados que llevaron al error
 }
}

La cláusula try encierra las instrucciones que pueden lanzar excepciones, de hecho si un método es llamado sin la mediación de esta palabra reservada, no podrá ser ejecutado (el compilador nos dará un error a menos que el método cliente también lance excepción mediante la palabra throws ). La cláusula catch nos sirve para ejecutar algunas instrucciones que sucederán si alguna de las lineas dentro del try lanza una expcepción. La idea es escribir dentro del catch las instrucciones que manejarán el error, en el ejemplo anterior imprimiremos la traza de llamados en la consola, también podríamos escribir un archivo de registro de errores o lanzar una nueva excepción. Con un nuevo lanzamiento nuestro código podría quedar así...

public static void modificarPersona ( int id , String nuevoNombre, Persona[] conjuntoPersonas )throws Exception
{
 int posicion;
 try 
 {
  posicion = buscarPersona(id, conjuntoPersonas);
  Persona p = conjuntoPersonas[posicion];
  p.setNombre(nuevoNombre);
 } 
 catch (Exception e) 
 {
   throw new Exception("Hubo un error en la modificacion de la persona: "+e.getMessage());
 }
}

En esta versión, además de capturar la excepción lanzamos una nueva que dice un mensaje más explícito. Teniendo en cuenta que nuestro método de búsqueda podría ser usado por más de un cliente, el mensaje original podría no ser suficiente, en este caso le damos más contexto diciendo que no solamente la búsqueda falló, sino que además fué invocada con la intención de modificar una persona.

Existe la posibilidad de ejecutar algunas líneas de código independientes de la existencia de una excepción o no dentro de una cláusula try. La cláusula finally ejecuta su contenido siempre, inclusive si no se usa un try , lo cual podría ser una buena práctica para aquellas cosas que no se deben dejar de hacer en ningun caso (por ejemplo cerrar un archivo o una conexión a la red). Aquí un ejemplo de su uso leyendo un archivo:

public void openFile()
{
 FileReader reader = null;
 try 
 {
  reader = new FileReader("someFile");
  int i=0;
  while(i != -1){
   i = reader.read();
   System.out.println((char) i );
  }
 } 
 catch (IOException e) 
 {
  e.printStackTrace();
 } 
 finally 
 {
  if(reader != null)
  {
   try 
   {
    reader.close();
   } 
   catch (IOException e) 
   {
    e.printStackTrace();
   }
  }
  System.out.println("--- File End ---");
 }
}

Independientemente de si sucede la excepción (en este caso IOException), se intentará cerrar el archivo que se está trabajando. Nótese que en este caso la invocación al método close también podría generar una excepción que requiere ser capturada igualmente.

Las clases Exception, Error y Throwable.

Como vimos en los primeros ejemplos, es relativamente típico usar la clase Exception, sin embargo dicha clase es una clase genérica y deberíamos usar hijas de ella (por medio de herencia) para clasificar los posibles tipos de excepción que nuestra aplicación sabe lanzar. En general es una buena práctica definir varios tipos de excepciones que sean dicientes del error que está sucediendo o del componente que lanza la excepción. Por ejemplo, se podrían separar las excepciones de lógica de las excepciones de interfaz de usuario y eso ya sería un buen avance.

Si revisamos la jerarquia de herencia de la clase Exception nos encontraremos con que es una extensión (hereda de) la clase Throwable y que existe una clase Error que es hermana de Exception. Normalmente se trabajan excepciones cuando el flujo del programa principal puede ser restaurado y se puede continuar trabajando, la clase Error se utilizará entonces cuando el problema sea crítico y no se pueda continuar usando la aplicación (por ejemplo cuando no hay memoria disponible). Esa elección depende principalmente del desarrollador, sin embargo cási todos los casos prácticos se pueden resolver usando solo excepciones.

Por otro lado está la clase Throwable, la cual es la única clase que puede ser "lanzada" mediante la cláusula throw, razón por la cual Exception y Error son hijas suyas. Si queremos personalizar excepciones o errores, les recomendaría que extiendan directamente estas dos clases.

Algunas excepciones conocidas

Para terminar este post, quisiera contarles algunas excepciones que se suelen utilizar o que son comunes en el desarrollo. Aquí una lista:

ArrayIndexOutOfBoundsException	Se intenta acceder a una posición inválida en un arreglo o matriz
ClassCastException	Se intenta hacer cast de tipo con un objeto que no es de ese tipo
NegativeArraySizeException	Se intenta crear un arreglo de tamaño negativo (suena increible, pero si hicieron una excepción para eso es porque hay quien lo intenta)
NullPointerException	Se intenta acceder a una variable cuyo valor es nulo
StringIndexOutOfBoundsException	Lo mismo que un ArrayIndexOutOfBoundsException pero dentro de un String
ConcurrentModificationException	Se intenta hacer una modificación y lectura de un elemento al mismo tiempo, típicamente aparece cuando se eliminan elementos de una lista que se esta recorriendo en un mismo ciclo
FileNotFoundException	Se intenta abrir un archivo que no existe, típico error de ruta
IOException	Error en la lectura o escritura, normalmente cuando se trabaja con archivos.
ConnectException	Se intenta una conexión imposible, típico si se intenta conectar a un servidor caído o a una URL incorrecta

Clases y Objetos - ¿Cómo?, ¿Por qué?, ¿Para qué?

Este post tiene como idea mostrar un poco del funcionamiento de las clases y los objetos en JAVA desde una perspectiva nada formal y más bien práctica. Cuando yo aprendí a trabajar con JAVA era inmigrante de C++ por lo cual aprendí un poco "a las patadas" y aunque después de varios años de trabajar con JAVA ya  me considero un programador muy decente, quiero aprovechar este post para contarles algunas cosas que me ayudaron en ese proceso de aprender solo.

Clases y Objetos ¿Qué es eso?

Bueno, primero lo primero... Básicamente los lenguajes orientados por objetos tienen la idea de que los que escriben aplicaciones trabajen con conceptos más parecidos al mundo real. La forma más acertada que encontraron en su época fue el uso de variables de "tipos personalizados" para dejar de hablar de números , bytes, caracteres y cadenas; de hecho en lenguajes como C++ el concepto de cadena de caracteres estuvo relegado a librerías que ayudaban a usarlos, pero quienes tuvimos que sufrir con C (a secas) vimos como tocaba manejar las cadenas de caracteres como arreglos dinámicos desde una variable tipo char*. Bueno, en java al menos se tomaron la molestia de implementar una clase String muy decente...

Volviendo al asunto de los tipos, se quería que los programadores pensaran en conceptos más abstractos, como una Persona, un Directorio, un Automóvil  etc. La forma de implementarlos estos conceptos se pensó en términos de variables compuestas personalizables (muy al estilo de un struct en C). En principio una clase es una definición de un tipo de dato compuesto que además de las variables internas que lo definen (atributos), tiene unos métodos (procedimientos, funciones) que también lo caracterizan. En teoría un objeto tiene unas propiedades y comportamientos que lo hacen diferente de los demás (atributos y métodos).

Si volvemos al concepto de variable, una variable debería tener al menos un tipo y un nombre y además se le puede asignar un valor. La idea con un objeto realmente no cambia mucho....

        
 int i = 0;
 Persona p = new Persona("Daniel Santamaría", 4243430);

En la primera línea vemos la declaración de una variable entera que se llama i y que le estamos asignando el valor cero. En la segunda línea vemos una estructura similar en su sintaxis, una variable de tipo persona que se llama p (la variable) y le estamos asignando una persona. En este caso hablamos de un hipotético objeto persona que estamos usando y que posiblemente tiene "por dentro" una variable String para representar el nombre y un long que representará el número de teléfono. La palabra reservada "new" se utiliza en varios lenguajes de programación (C#, JAVA, C++, PHP, entre otros) para crear un nuevo objeto (separar memoria y ponerlo allí).

Definición de una clase

Para que esto sea posible, en algún lado de nuestro programa es necesario definir ¿Qué es una clase persona?. Para ello se usa un archivo aparte y la palabra reservada "class".

public class Persona
{
 private String nombre;
 private long telefono;
 
 public Persona(String n, long t)
 {
  this.nombre = n;
  this.telefono = t;
 }
}

La anterior porción de código (probablemente ubicada en un archivo Persona.java) define una clase Persona con dos atributos (nombre y teléfono). El uso de la palabra "private" para declarar dichas variable permite que esta variable solamente pueda ser accedida al interior de la clase persona (no accesible desde otras clases). El uso de esta palabra reservada y otras (public, protected, etc) no será tratado en este texto. Sin embargo es importante decir que : "Es muy importante que los atributos de una clase sean privados", ya que de no serlo, otras clases podrían interferir en la correcta operación del objeto. La idea de fondo es que cada clase "se encargue de lo suyo"...

También hay allí un método, específicamente un método constructor. El constructor se encarga normalmente de inicializar el estado de un objeto, sea dando valores por defecto o recibiéndolos como parámetro. Nótese también el uso de la palabra "this" con la que se hace explícito el hecho de que quiero trabajar con la variable que es atributo de este mismo objeto. Esto resuelve inconsistencias, por ejemplo si dentro del método se declara una variable con el mismo nombre.

El molde y la galleta - Diferencia entre clase y objeto

La definición de una clase permite decirle al lenguaje ¿Qué es una persona? (en el ejemplo anterior). Bueno, eso es una clase y se refiere al concepto literal de clase :

•  "Orden en que, con arreglo a determinadas condiciones o calidades, se consideran comprendidas diferentes personas o cosas." (Tomada del diccionario de la real academia de la lengua española)

El objeto vendría siendo una persona en particular, o sea una instancia particular de la clase persona. Esa instancia es básicamente una variable ya creada con valores específicos, única e irrepetible. En resumen la clase se comporta como el "molde" y el objeto como "la galleta" que se puede hacer con el molde. Uno mira con que la rellena, pero sigue siendo una galleta.

Métodos, especialmente los "getters" y "setters"

Como había dicho anteriormente es de suprema importancia que los atributos estén bajo el control de la clase que los contiene. La clase Persona del ejemplo es la única autorizada para cambiar el nombre de una persona de manera directa, sin embargo se puede hacer que un método permita modificar o consultar esos valores (de lo contrario la clase sería casi que inútil). Esto es lo que hace un método get(pedir valor) o set (cambiar valor). Lo interesante de estos métodos es que en ellos se puede controlar lo que sucede al hacer el cambio, notificar al objeto si es necesario, realizar validaciones, etc. Por ejemplo:

public class Persona
{
 private String nombre;
 private long telefono;
 
 public Persona(String n, long t)
 {
  this.nombre = n;
  this.telefono = t;
 }
 public String darNombre()
 {
  return this.nombre;
 }
 public long darTelefono()
 {
  return this.telefono;
 }
 public void cambiarNombre(String n)
 {
  if(!n.equals(""))
  {
   this.nombre = n;
  }
 }
 public void cambiarTelefono(long t)
 {
  if(t!=0)
  {
   this.telefono = t;
  }
 }
}

En este ejemplo he puesto 4 métodos más, los dos primeros retornan el valor del atributo, los dos siguientes permiten cambiar el valor del atributo, pero bajo algunas restricciones, por ejemplo el nombre no se puede cambiar si el valor enviado como parámetro es un String vacío, así mismo no se podrá cambiar el teléfono por un cero. Estas restricciones son tontas, pero podrían ser tan complejas como se requiera, por ello la importancia de mantener ese control dentro de la misma clase.

Desde afuera de la clase, estos métodos podrían ser llamados usando el operador punto (.):

 Persona p = new Persona("Daniel Santamaría", 4243430);
 p.cambiarNombre("Pepito Perez");
 p.cambiarTelefono ( 5554455 );
 System.out.printLn(p.darNombre());

Listo! con ello podrán crear clases simples.... Ahora faltan las relaciones entre clases...

Relaciones entre clases - ¿Quién tiene Qué?

Cuando uno modela clases, espera tener varias (obvio) y algunas de ellas tendrán que relacionarse para modelar contextos más complejos. La relación más común entre clases es la contenencia (agregación o composición), básicamente modela el hecho de que un concepto esta compuesto por otro. Consideremos el caso de una agenda de teléfonos, la cual contiene un conjunto de personas. En un diagrama de clases UML se representaría de la siguiente forma:

El diagrama representa una relación de agregación entre Agenda y Persona, la flecha en el diagrama significa que literalmente una Agenda puede tener de 0 a N Personas (significado del simbolo *). En ese caso, si miramos la implementación de la clase Agenda, necesitaremos tener una variable que pueda guardar N personas, por ejemplo un arreglo.

public class Agenda 
{
 private int numeroPersonas =0;
 public static final int MAX_PERSONAS = 100;
 private Persona[] personas = new Persona[MAX_PERSONAS];
 
 public void agregarPersona(Persona p)
 {
  this.personas[numeroPersonas]=p;
  this.numeroPersonas++;
 }
 public Persona[] listarPersonas()
 {
  return this.personas;
 }
 //.... otros métodos de la clase
}

Nótese que se incluyeron algunos atributos extra para la administración de la colección, los cuales no están en el diagrama. Si somos rígidos, deberían estar en él, pero desde el punto de vista conceptual, solamente requeríamos modelar el conjunto de personas. Por otro lado aparece un atributo "personas" que es un arreglo de personas, este sería quien representa la relación existente entre las dos clases, pero no necesariamente puede tratarse de un arreglo existiendo diversas estructuras de datos que podrían cumplir la misma función (por ejemplo listas, arboles, pilas, etc.)

Tan recursivos pues!

El tema que me lleva hoy a escribir es la idea de recursión. Bueno, es uno de esos temas difíciles de explicar la primera vez y requiere algunas claridades frente a como funcionan las invocaciones a métodos.

¿Cómo funciona un método?

Cuando uno invoca un método, se "abre" espacio en la computadora para ejecutar un cierto conjunto de instrucciones (el contenido del método). Cuando se realizan muchas invocaciones, mucha memoria RAM del computador está siendo usada para ello. En una versión gráfica, es como si creáramos una caja que nos resuelve un problema dadas unas entradas y asegurando unas salidas.

              +-----------------------+
              |     Metodo!           |
         .    |                       |      .
   ........   |                       |   .....
   Entradas   |                       |  Salidas
              |                       |
              |                       |
              +-----------------------+

De esta manera, un método que tiene la responsabilidad de sumar dos números recibiría (entrada) como entrada dos elementos del conjunto de número enteros y devolvería (salida) un elemento del conjunto de números enteros. Para resolver dicha operación se crearía una "caja" simple que resolvería esa operación.

Cuando un método llama otro método, se abren varias "cajas" que esperan resultados unas de las otras, recordemos que un método tiene una responsabilidad definida. Cuando la resolución de un problema es compleja, se debe romper el problema en partes más sencillas, así mismo cuando un método se está complicando, es importante partirlo en métodos más simples. Cuando un método llama a otro, se crea algo llamado "pila de llamados".

  
  +---------+
  | Jugar   |
  +---------+
  | Menu    |
  +---------+
  | Main    |
  +---------+

La anterior pila de llamados representa un programa que inició con un llamado al método Main (como todo programa en Java), a su vez este llamó a un método que se llama Menú y a su vez este llamó a un método que se llama Jugar. En este momento la pila de llamados tiene en su punta el método jugar, que posiblemente es el que está ejecutando. Cuando este método termine, el método menú recibirá su respuesta y así pasará cuando termine el método Menú. Cada método tiene su espacio para guardar cosas, entre ellas las variables que se declaran dentro de él, sus parámetros y demás cosas.

Ahora sí, a lo que vinimos

Resulta que una recursión es un llamado de un método a sí mismo para la resolución sucesiva de un problema. En términos de la pila de llamados, se generarían espacios del mismo método. Supongamos una función que simplemente se llama a sí misma:

public static int metodo(int parametro)
{
   return metodo(parametro+1);
}

Resulta que el método de nuestro ejemplo crearía un número infinitos de entradas en la pila de llamados (teóricamente, porque en la práctica esa pila tiene límites y al sobrepasarlos se genera un error llamado StackOverflow o volcado de pila). Esto se vería más o menos así: (si el primer llamado fúe metodo(1))

     ...
 +---------+
 |metodo(3)|
 +---------+
 |metodo(2)|
 +---------+
 |metodo(1)|
 +---------+

Resulta que el llamado metodo(1) está esperando que el llamado metodo(2) termine, al igual que este último espera por metodo(3) y metodo(3) por metodo(4) y así sucesivamente. Respecto al ejemplo de Main->Menú->Jugar no cambia mucho, excepto por el hecho de que todas las componentes de la pila tienen el mismo nombre. En el código de ejemplo, estos llamados nunca terminarán porque siempre se genera un llamado nuevo. Esto resultará en un StackOverflow... Para detenerlo necesitamos un caso donde no se hagan llamados recursivos, a esto lo llamaremos posteriormente un caso base. Modifiquemos el código del anterior ejemplo para que eso pase cuando el parámetro llegue a un cierto valor, por ejemplo M.

public static int metodo(int parametro)
{
    if(parametro == M)  
    {
        return 0;
    } 
    return metodo(parametro+1);
}

En ese caso los llamados recursivos se expanderían hasta que el valor de la variable parametro llegue a M, cuando llegue, se retornará cero a todos los métodos anteriores. Aunque este método ya no tiene un StackOverflow, es un método sin mayor utilidad, pero revisemos el siguiente:

public static int factorial(int parametro)
{
   if(n==1)
    {
        return 1;
    }
    else
    {
        return parametro* factorial(parametro-1);
    }
}

En este ultimo caso, tenemos un caso en que se detiene (cuando n sea 1) y uno donde expande el llamado (n diferente de 1). De esta manera tenemos un caso base y un caso inductivo. Espero les sirva!

Lectura...pero de archivos

En este post me voy a dedicar a revisar una forma sencilla de leer y escribir sobre un archivo de texto, pero primero lo primero....

Archivos... Para quien no sabe qué es uno

Bueno, pues en general los archivos son bloques de datos ordenados que se pueden almacenar de manera secuencial en un dispositivo magnético, óptico o similar. Son los que nos llenan el disco duro del computador!. Básicamente hay dos tipos de archivos, los archivos texto y los archivos binarios.

Los archivos de texto esencialmente guardan eso: texto. Se podría pensar que guardan una colección de Strings separados por el carácter de cambio de linea y para leerlos literalmente recorreremos el archivo como si de una colección de cadenas de caracteres se tratara.

Los archivos binarios permiten guardar algunas otras cosas, normalmente representaciones de los objetos que trabajamos en un programa "como los trajeron al mundo", osea en binario. En este post me dedicaré a los primeros...

Nada mejor que un ejemplo

Lo primero que vamos a hacer es leer un archivo sencillo con personas y números de teléfono. Suponga que el archivo contactos.txt tiene el siguiente contenido:

Pepito Perez;4243430
Fulano Rodríguez;6508765

Para leerlo vamos a necesitar varias cosas...
1. La clase File: La clase File de java es una representación de un archivo en un sistema de archivos (¿De verdad?). Las carpetas (directorios) tambien pueden ser representados con esta clase. Entre otras uno puede instanciarla con un archivo para crearlo, saber su carpeta, listar los archivos que están en ella, etc. La usaremos para representar el archivo especifico que vamos a leer.
2. La clase FileReader: Esta clase permite abrir el archivo, es la clase que sabe acceder al disco para abrir un archivo.
3. La clase BufferedReader: Esta clase nos genera un lector con el que podamos leer "pedazo a pedazo" el archivo. Nos provee métodos para leer las líneas del archivo y saber si se acabó.

Miremos el siguiente código fuente:

public ArrayList<Persona> cargarArchivo ()  
      {  
           try   
           {  
                ArrayList<Persona> resultado = new ArrayList<Persona>();  
                File archivo = new File("../data/contactos.txt");  
                BufferedReader lector = new BufferedReader(new FileReader(archivo));  
                String linea = "";  
                int i=0;  
                while (( linea = lector.readLine()) != null )  
                {  
                     String[] partes = linea.split(";");  
                     Persona p = new Persona(partes[0], new Integer(partes[1]));  
                     resultado.add(p);  
                }
                lector.close();
                return resultado;  
           }   
           catch (FileNotFoundException e)   
           {  
                System.out.println("Archivo no encontrado");  
                return null;  
           }   
           catch (IOException e)   
           {  
                System.out.println("Error de lectura");  
                return null;  
           }  
           System.out.println("Carga del archivo exitosa!");  
           return new ArrayList<Persona>();  
      }  

Vamos por partes, dijo Jack el destripador....

El método que está en el ejemplo anterior carga las personas que están en el archivo en un ArrayList y los retorna. Algunas cosas que ver en este código.

1. las clausulas try, catch: En principio estas clausulas no tienen nada que ver con el tema de este post, de hecho son mecanismos que tiene java para manejo de Excepciones, en resumen una excepción es un error y estas clausulas sirven para saber que hacer con él. El bloque de código que se escribe dentro del try simplemente se realizará (aquí va lo que nos interesa), la clausula catch sirve para atrapar ciertos tipos de error, como pueden ver hay dos de ellas, una para error "no encontré el archivo" y otra para "error de lectura". El contenido de esos bloques es código que se ejecutará en caso que esos errores se presenten.

2. File: En el ejemplo se crea un nuevo archivo, el parámetro que se le envía podría ser solamente el nombre del archivo, con lo que buscaría en archivo en la ubicación donde la clase está corriendo (en la misma carpeta). En el ejemplo se usa el comodín ".." que significa "una carpeta arriba". después la carpeta data y el nombre del archivo. 

3. Los lectores. En el ejemplo se instancia un BufferedReader con un FileReader con un File adentro. De esta manera tendremos acceso por fin a lo que necesitamos.

4. El método readLine: Hace lo que dice, lee una linea y luego la próxima en cada llamado. retornará null si ya se acabó el archivo, por eso está en esos términos la condición del ciclo while.

5. Split: Es una utilidad que nos da la clase String, sirve para romper un String en partes dada una cadena, en este caso la usaremos para romper un "renglón" del archivo en dos partes, la que tiene el nombre y la que tiene el número de teléfono. El resultado del método es un arreglo de String con cada parte.

6. Close: Al final sería decente cerrar el archivo que se está usando... por programas mal hechos que no usan esa instrucción es que a veces no podemos sacar nuestras memorias USB de un computador, porque un programa se quedo con un archivo abierto!

En una próxima ocasión escribiré acerca de como crear y escribir en archivos de texto!

Enter the Matrix

La dimensión desconocida ...

Después del asunto de trabajar con arreglos y pensando un poco en el asunto de la dimensión de una variable, retomo el hecho de que las variables podrían eventualmente tener más de una dimensión , en este caso la idea de arreglo se generaliza de manera libre.

¿Pensaron alguna vez en la idea de hacer un arreglo de arreglos?

¿Qué tal un arreglo de arreglos de arreglos?

Si la pregunta es si se puede, en la mayoría de lenguajes de programación SE PUEDE!. El asunto es que al tratar de modelar esta estructura inevitablemente estamos ampliando las dimensiones de una variable. Si una variable entera (solita, como la traje yo al mundo) tiene dimensión cero y un arreglo tiene dimensión 1 (el espacio donde se mueven sus posiciones), una matriz podría considerarse como una variable que tiene dimensión superior a 1, por ejemplo 2 (Lo que implica dos indices de posición o coordenadas)

         0       1      2       3       4

     +------++------++------++------++------+
  0  |  ' ' ||  ' ' ||  ' ' ||  ' ' ||  ' ' |
     |      ||      ||      ||      ||      |
     +------++------++------++------++------+
     +------++------++------++------++------+
  1  |  ' ' ||  ' ' ||  ' ' ||  ' ' ||  ' ' |
     |      ||      ||      ||      ||      |
     +------++------++------++------++------+
     +------++------++------++------++------+
  2  |  ' ' ||  'O' ||  'S' ||  'O' ||  ' ' |
     |      ||      ||      ||      ||      |
     +------++------++------++------++------+
     +------++------++------++------++------+
  3  |  ' ' ||  ' ' ||  ' ' ||  ' ' ||  ' ' |
     |      ||      ||      ||      ||      |
     +------++------++------++------++------+

Extiende la declaración!

La idea inicial que habíamos usado previamente para asuntos dimensionales tenía que ver con el uso del operador [] que nos permitía acceder a posiciones cualquiera de un conjunto en una dimensión (arreglo). La idea cuando aparecen multiples dimensiones es exactamente la misma, pero requiere del uso de más operadores [] para identificar las demás coordenadas. En el caso de dos dimensiones, se requiere uno para trabajar las filas y uno para trabajar las columnas donde se ubica un elemento dentro del conjunto. El anterior ejemplo hace una matriz bidimensional de caracteres, cualquier parecido con la conformación de una sopa de letras o un Scrabble es pura coincidencia...:)

Por extensión, la sintaxis para declarar una matriz tiene la misma estructura que la que usa un arreglo.

char [] arregloLetras = new char[10];
char [][] matrizLetras = new char[15][15];

char [][][] cuboLetras = new char[10][10][10];

En la primera linea se declaro un conjunto de caracteres de tamaño 10, en el segundo ejemplo se declara una matriz de caracteres de tamaño 15X15.  char[][] actua como el tipo (matriz de caracteres), matrizLetras es el nombre de la variable y new char[15][15] crea las variables necesarias para hacer la matriz con 15 X 15 variables de tipo char. Esto se podría interpretar tambien como declarar un arreglo de tamaño 15 donde cada posición es un arreglo de tamaño 15 de caracteres, por eso el uso de dos operadores [] seguidos. El último ejemplo declara una matriz de caracteres de tamaño 10X10X10 (tres dimensiones).

En ese orden de ideas, char es la palabra que designa el tipo "caracter", char[] designa el tipo "conjunto de caracteres" y char[][] designa el tipo "matriz de caracteres" o "conjunto de conjuntos" de caracteres. El ultimo ejemplo se podría comprender como una extensión de lo anterior, osea char[][][] sería una "matriz tridimensional de caracteres" o un "conjunto de conjuntos de conjuntos de caracteres".

Asignación y consulta

La asignación y consulta de una matriz requiere el uso del operador [] así como pasa en los arreglos, pero al tratarse de un conjunto de dos dimensiones, se requiere de su uso 2 veces. De esta manera, las instrucciones: 

matrizLetras[0][0]='x';
matrizLetras[1][5]='y';
matrizLetras[2][3]='z';

Modifican posiciones específicas de la matriz, la primera línea modifica la posición <0,0> de la matriz y asigna el valor 'x'. Los indices de la matriz (valores que se ponen dentro del operador []) se consideran como filas(para el primer indice) y columnas (para el segundo), así en la segunda instrucción se cambia la posición fila = 1, columna = 5 asignando el valor 'y'. En la tercera instrucción se modifica la posición <2,3> de la matriz y se asigna el valor 'z'.

Así mismo, se puede consultar un valor de una matriz mediante el operador []. Para imprimir un valor de la matriz basta con usarlo de igual forma:

System.out.println(matrizLetras[0][0]);
System.out.println(matrizLetras[1][5]);
System.out.println(matrizLetras[2][3]);

De esta manera, estas tres líneas imprimirán en la pantalla los valores 'x', 'y' y 'z' de acuerdo con lo anterior.

Ciclos y matrices - Recorridos

Los indices de una matriz evidentemente son números enteros, por ende se podrían poner dentro del operador [] valores variables. Uno de los usos más importantes tiene que ver con el recorrido de matrices. El recorrido de matrices se suele utilizar cuando hay que pasar por todas las posiciones de una matriz para hacer algo específico. 

 
for(int i=0; i<matrizLetras.length; i++)  
 {  
      for(int j=0; j<matrizLetras[i].length; j++)  
      {  
           matrizLetras[i][j]= '_';  
      }  
 }  

En este ejemplo, hemos usado un primer ciclo que recorra todas las filas de la matriz. Nótese que llamado length tiene ese propósito. En el segundo ciclo, se utiliza el operador length pero para cada posición i de la matriz (según el razonamiento, usar el operador [] una sola vez en una matriz bidimensional, nos entregaría un arreglo y a ese arreglo es al que le estamos pidiendo el tamaño). En resumen, el primer ciclo funciona tantas veces como filas tenga la matríz y cada una de esas veces un segundo ciclo funciona tantas veces como columnas tenga la matriz. Así, en este ejemplo se recorren 15 filas y por cada una de ellas se recorren 15 columnas, osea que la instrucción matrizLetras[i][j] sucederá 15X15 veces (225).

En el anterior ejemplo se asigna el caracter '_' a todas las posiciones de la matriz sin excepción. Si se quisieran hacer recorridos parciales se podría jugar con el ciclo para que no toda posición fuera tenida en cuenta. Para ello se pueden variar los inicios del ciclo o su condición. Un ejemplo de ello es recorrer solo una fila de la matriz, para ello se hace un ciclo solo para las columnas y se deja constante la fila:

      int filaconstante=2;  
      for(int j=0; j<matrizLetras[filaconstante].length; j++)  
      {  
           matrizLetras[filaconstante][j]= 'x';  
      }  
      int columnaconstante=2;  
      for(int i=0; i<matrizLetras[columnaconstante].length; i++)  
      {  
           matrizLetras[i][columnaconstante]= 'y';  
      }  
      for(int i=0; i<matrizLetras[columnaconstante].length; i++)  
      {  
           matrizLetras[i][i]= 'd';  
      }  

En el segundo ciclo se recorre solo una columna y el ciclo varía las filas. En el tercer ciclo se recorre la diagonal de la matriz, osea las posiciones <0,0>, <1,1>.... etc.

Arreglos...¿Y eso que?

El asunto de arreglos siempre ha generado expectativa entre mis estudiantes debido a que este tema suele recordarles que ciertos conceptos sobre uso y declaración de variables no están tan claros como creen. En realidad los arreglos no dejan de ser más que un tipo de variable con la particularidad que permite representar conjuntos de tamaño definido.

Inicios, comparando con lo que ya sabemos

Un día vimos como de la nada se podía crear una variable y darle un valor. Esa declaración de variable requiere inicialmente de un tipo (p.e int, double, char, String, Scanner, etc) y de un nombre para la recién bautizada variable. Eso equivale a separar un espacio en la memoria del computador para almacenar un valor y etiquetarlo con un nombre.

int variable = 5; 


  +-------+
  |       |
  |  5    |
  |       |
  `.......'
   miVariable

En la anterior instrucción especificamos un tipo (int, osea entero) , un nombre para la variable (miVariable) y un valor inicial (5). En el caso de los arreglos no es demasiado diferente.

int[] conjuntoEntero = new int[9];
conjuntoEntero[0]=3;
conjuntoEntero[1]=1;
...
conjuntoEntero[8]=20;


    +-----+-----+-----+------+-----+----+----+-----+-------+
    |  3  |  1  | 15  |  11  | 10  | -1 |  2 |  4  |  -20  |
    |     |     |     |      |     |    |    |     |       |
    +-----+-----+-----+------+-----+----+----+-----+-------+
       0     1     2      3     4    5    6     7      8

Aquí también especificamos un tipo (int[], osea arreglo de enteros), un nombre para la variable (conjuntoEntero) y un valor inicial (evidentemente toca posición por posición). Lo primero que notamos es que no podemos intervenir sobre todo el conjunto al mismo tiempo, se hace posición por posición. Para este propósito se usa el operador [] que nos permite acceder a una posición dentro del arreglo. En este caso se puede hacer lo mismo que con una variable.

conjuntoEntero // es una variable de tipo "arreglo de enteros"
conjuntoEntero[0] // es una variable de tipo "entero"

Ciclos y arreglos...recorriendo un conjunto

Un arreglo tiene un tamaño en principio definido, pero no necesariamente lo conocemos. Una de las cosas típicas que se hace con un arreglo es recorrerlo con diferentes propósitos, por ejemplo sumar sus elementos.

Así se realizaría dicho procedimiento:

int suma = 0;
for ( int i = 0; i< conjuntoEntero.length; i++)
{
 suma = suma + conjuntoEntero[i];
}

La variable suma almacena entonces un cero inicialmente y será incrementada dependiendo del valor de cada posición del arreglo. El ciclo funcionaría entonces desde i =0 hasta el tamaño del arreglo (nótese el llamado a  length que me da su tamaño) y tomaría "el i-ésimo" valor del arreglo y lo suma en la variable suma (valga la redundancia). El índice que estoy aplicando en el arreglo es el mismo valor que uso en el ciclo!!

Conclusiones varias

Los arreglos son tipos de variables también, dicho de una manera matemática los tipos que habíamos usado antes son variables de dimensión cero (int, char, String, etc.), los arreglos son tipos de variables de dimensión 1 (int[], char[], String[]) y evidentemente existen tipos de variables de dimensiones superiores a 1 (matrices). La idea detrás de un arreglo es representar un conjunto de datos de tamaño fijo y eso es lo que se especifica en su declaración.

Cada elemento de un arreglo es del tipo que se declaró previamente. Si el conjunto es de enteros, uno de sus elementos es entero (¿Obvio no?). El operador de indirección ([]) se utiliza para referirse a uno de los elementos. Para hacer operaciones con todo el conjunto se suele usar un ciclo.