A continuación dejo el resumen del sexto capítulo (Strings, I/O, Formatting, and Parsing) del libro "Sun Certified Programmer for Java 6 Study Guide".

String, StringBuilder y StringBuffer (Objetivo 3.1):
Un String es un objeto inmutable, una vez que el mismo se creó, no puede ser modificado. Cuando se realiza una concatenación de dos String, lo que hace la JVM es crear un nuevo objeto String con el valor de las dos cadenas concatenadas. Cuando se invoca un método del objeto String (por ej.: toUpperCase()), el método devuelve un nuevo objeto String con su correspondiente valor, no se modifica el valor original del String (con el que se invoco el método).
Algunos métodos de los objetos String:

La clase StringBuilder (agregada en Java 5), posee exactamente los mismos métodos que la clase StringBuffer. La única diferencia entre ellas, es que la clase StringBuilder es más rápida debido a que sus métodos no están sincronizados. Estas dos clases se utilizan para realizar muchas modificaciones sobre los caracteres de una cadena. Los objetos de estas clases no crean un nuevo objeto cada vez que se modifican (como los objetos String), es por esto que son más eficientes para realizar muchas modificaciones sobre cadenas.
Algunos métodos de los objetos StringBuilder y StringBuffer:

Ver ejemplo: Main01.java

File e I/O (Objetivo 3.2):
Clases que se necesitan saber para el examen:

Cuando se crea una instancia de la clase File, solo se está creando el nombre de un archivo. Esta clase contiene métodos de utilidad para realizar operaciones sobre archivos y directorios:

La clase Console permite aceptar entradas desde la línea de comandos. El método readLine() devuelve un String que contiene lo que el usuario haya ingresado. El método readPassword() devuelve un arreglo de caracteres que contienen el password solicitado. La clase Console no se puede instanciar a través de su constructor. Para obtener una instancia se debe invocar el método estático System.console().

Resumen (TWO-MINUTE DRILL):

Ver ejemplo: Main02.java

Serialización (Objetivo 3.3):
La serialización permite guardar el estado de un objeto (es decir, todas sus variables de instancia). Si una variable de instancia tiene el especificador transient, la misma no será almacenada por el proceso de serialización.
Para que un objeto pueda ser serializado, el mismo debe implementar la interface Serializable (dicha interface no posee métodos para implementar, solo es un marcador). Un objeto serializado se almacena en un archivo de bytes, se utilizan dos métodos que permiten leer y escribir un stream de datos.

Ambas clases son envoltorios de las clases FileOutputStream y FileInputStream. Los métodos writeObject() y readObject() trabajan con objetos de tipo Serializable.

Cuando se intenta serializar un objeto (Serializable) que contiene (relación TIENE-UN) una referencia a otro tipo de objeto pueden ocurrir ciertas situaciones:

El proceso de serialización de Java posee un mecanismo especial para los objetos que son especiales y difíciles de guardar. Se trata de un conjunto de métodos privados que se pueden implementar en la clase en cuestión. Si dichos métodos concuerdan con la signatura exacta, se invocarán durante el proceso de serialización y deserialización del objeto. Las signaturas son las siguientes:

Gracias a estos dos métodos es posible manejar el proceso de serialización. Esto se puede realizar debido a que los objetos ‘os’ e ‘is’ tienen un conjunto de métodos para invocar el proceso de serialización por defecto y además métodos para almacenar y leer datos adicionales.
Proceso de serialización por defecto:

Métodos para almacenar y leer datos adicionales:

La herencia también se ve afectada por el proceso de serialización. Cuando una clase base implementa la interface Serializable, hace que todas sus subclases también la implementen.
El problema real se da cuando una clase base no es Serializable pero una de sus clases hijas si lo es. Esta situación produce que se serialice solo el estado de la clase hija, dejando de lado todas las variables de instancia de la clase base. Para que este escenario sea posible, la clase base debe poseer un constructor por defecto. En caso contrario se producirá un error en tiempo de ejecución a la hora de deserializar el objeto, ya que se intentará invocar automáticamente el constructor por defecto de clase base.

Resumen (TWO-MINUTE DRILL):

Ver ejemplo: Main03.java

Fechas, números y monedas (Objetivo 3.4):
Clases que se necesitan saber para el examen:

A continuación dejo el resumen del quinto capítulo (Flow Control, Exceptions, and Assertions) del libro "Sun Certified Programmer for Java 6 Study Guide".

Resumen del capítulo 13 (Cadenas de caracteres) del "Libro Thinking in Java (4ta Edición)".

Introducción

Los objetos de clase String son inmutables. Todos los métodos de la clase que parecen modificar una cadena de caracteres, lo que hacen en realidad, es devolver un objeto String completamente nuevo que contiene dicha modificación. Puesto a que este tipo de objetos es inmutable, se pueden establecer tantos alias como se desee, pero no hay ninguna posibilidad de que una referencia modifique algo que pueda afectar a otras referencias.
Los operadores ‘+’ y ‘=+’ para objetos String son los únicos operadores sobrecargados en Java. El compilador cuando se encuentra con alguno de estos operadores (que intentan concatenar Strings), lo que hace es crear un objeto StringBuilder. Con una instancia de esta clase, se invoca el método append() la cantidad de veces necesarias para cada concatenación, y finalmente se invoca el método toString() para devolver el resultado.
Los objetos StringBuilder disponen de un conjunto completo de métodos como: insert(), delete(), replace(), substring(), reverse(), append() y toString().
Ver ejemplo: Main01.java

Clase Formatter

Una de las características incorporadas en Java SE5 es el formateo de la salida al estilo de la instrucción printf() de C. Toda la nueva funcionalidad de formateo de Java es gestionada por la clase Formatter del paquete java.util. Esta clase se puede considerar como una especie de traductor que convierte la cadena de formato y los datos al resultado deseado. Cuando se instancia un objeto Formatter, se le indica a donde se deben mandar los resultados. El constructor de la clase se encuentra sobrecargado para admitir diversas ubicaciones de salida, pero las más útiles son PrintStream, OutputStream y File.
Existe un atajo para realizar el formateo de la salida sin utilizar un objeto Formatter. Todos los objetos PrintStream o PrintWriter (dentro de los que se incluye System.out) tienen disponible el método format().
Para controlar el espaciado y la alineación cuando se insertan los datos, hacen falta especificadores de formato más elaborados:
%[indice_argumento$][indicadores][anchura][.precisión]conversión

• Índice argumento: Indica el índice del argumento que será utilizado para realizar la conversión.
• Indicadores: De manera predeterminada, los datos se justifican a la derecha. Para justificar los datos a la izquierda se debe incluir el indicador ‘-‘.
• Anchura: Permite controlar el tamaño mínimo de un campo. Se garantiza que un campo tenga al menos una anchura de un cierto número de caracteres, rellenándolo con espacios en caso de ser necesario. (Es aplicable a todos los tipos de conversión de datos).
• Precisión: Se utiliza para especificar un máximo. Tiene un significado distinto para los diferentes tipos:
  - Cadenas de caracteres: Especifica el número máximo de caracteres del objeto String que hay que imprimir.
  - Números en coma flotante: Especifica el numero de posiciones decimales que hay que mostrar (el valor predeterminado el 6), efectuando un redondeo si hay más dígitos o añadiendo más ceros al final si hay pocos.
  - Enteros: La precisión no es aplicable ya que no tienen parte fraccionaría. Se generará una excepción si se utiliza este argumento.
  

Caracteres de conversión:

• d: Entero (como decimal)
• c: Carácter Unicode
• b: Valor booleanos: Cadena de caracteres
• f: Coma flotante (como decimal)
• e: Coma flotantes (en notación científica)
• x: Entero (como hexadecimal)
• h: Código hash (como hexadecimal)
  

Java SE5 también ha tomado prestado de C la idea de sprintf(), que es un método que se utiliza para crear cadenas de caracteres. String.format() es un método estático que toma los mismos argumentos que el método format() de Formatter pero devuelve un objeto String.
Ver ejemplo: Main02.java

Expresiones regulares

Las expresiones regulares son herramientas de procesamiento de texto muy potentes y flexibles. Nos permiten especificar patrones complejos de texto que pueden buscarse en una cadena de entrada. Proporcionan un lenguaje compacto y dinámico que puede emplearse para resolver todo tipo de tareas de procesamiento, comparación, selección, edición y verificación de cadenas de una forma general.
La forma más simple de utilizar las expresiones regulares consiste en utilizar la funcionalidad incluida dentro de la clase String. Esta clase permite realizar búsquedas (matches()), partir la cadena (split()) y realizar sustituciones (replaceFirst() o replaceAll()).
Ver ejemplo: Main03.java

En general, lo que se hace es compilar objetos de expresión regular en lugar de emplear las utilidades String, que son bastante limitadas. Para ello, se debe importar la librería java.util.regex, y luego compilar una expresión regular utilizando el método estático Pattern.compile(). Esto genera un objeto Pattern basado en su argumento String. Para utilizar el objeto Pattern, lo que se hace es invocar el método matcher(), pasándole la cadena de caracteres que se quiere buscar. Este método genera un objeto Matcher, el cual tiene muchas operaciones para trabajar con cadenas.

• public boolean matches(): Devolverá true solo si el patrón se corresponde con la cadena de entrada completa.
• public boolean lookingAt(): Devolverá true solo si la cadena de entrada, comenzando por el principio, permite establecer una correspondencia con el patrón.
• public boolean find(): Puede utilizarse para descubrir múltiples correspondencias de patrón en el objeto CharSequence al cuál se aplique. Es como un iterador, que se desplaza hacia adelantea través de la cadena de caracteres de entrada.
• public boolean find(int start): El argumento indica en qué posición de la cadena debe comenzar la búsqueda.
• public String group(): Devuelve la correspondencia completa de la operación anterior de establecimiento de correspondencias (find()).
  

Ver ejemplo: Main04.java

Clase Scanner

Otra característica agregada en Java SE5 es la clase Scanner. Dicha clase permite eliminar buena parte de la complejidad relacionada con el análisis de una entrada. Esta entrada puede ser tanto un archivo como un flujo de datos. El constructor de Scanner admite casi cualquier tipo de objeto de entrada, File, InputStream, String o un objeto que implemente la interface Readable. Con Scanner, los pasos de entrada, extracción de elementos y análisis sintáctico están implementados mediante diferentes tipos de métodos. El método next() devuelve el siguiente elemento String y existen métodos similares para todos los tipos primitivos (excepto char), como para también para los tipos BigDecimal y BigInteger. También existen los métodos “hasNext” correspondientes que devuelven true si el siguiente elemento de entrada es del tipo correcto.
De manera predeterminada, un objeto Scanner divide los elementos de entrada según los caracteres de espaciados, pero también podemos especificar nuestro patrón delimitador en forma de expresión regular a través del método useDelimiter().
Ver ejemplo: Main05.java

Resumen del capítulo 12 (Tratamiento de errores mediante excepciones) del "Libro Thinking in Java (4ta Edición)".

Introducción

Para crear un sistema robusto, cada componente tiene que ser robusto. Al proporcionar un modelo coherente de informe de errores utilizando excepciones, Java permite que los componentes comuniquen los problemas de manera fiable al código cliente. Imponer esta formalidad para el tratamiento de errores permite crear sistemas de gran envergadura utilizando menos código de lo habitual y reducir la complejidad del mismo.
Una excepción se genera cuando ocurre una situación inesperada, lo cual impide continuar con el normal procesamiento, ya que no se posee la información necesaria para tratar con el problema en el contexto actual.
Sucesos que se dan a partir de la generación de una excepción:

1. Se crea un objeto excepción de la misma manera que cualquier otro objeto (utilizando la instrucción new).
2. Se detiene la ruta actual de ejecución y se extrae del contexto actual la referencia al objeto excepción.
3. Luego el mecanismo de tratamiento de excepciones se hace cargo del problema y comienza a buscar un lugar apropiado donde continuar ejecutando el programa.
4. Dicho lugar es la rutina de tratamiento de excepciones, cuya tarea consiste en recuperarse del problema de modo que el programa pueda intentar hacer otra cosa o simplemente continuar con lo que estuviera haciendo.
   

Existen tres secciones importantes a la hora de utilizar el mecanismo de excepciones:

• Región protegida (o bloque try): Este bloque de código es un ámbito de ejecución ordinario, salvo que dentro del mismo se incluye código que podría generar excepciones. Es decir, lo que se hace es “probar” el código (generalmente invocaciones a métodos).
• Rutina de tratamiento: Cuando se genera una excepción en el bloque try, esta se debe tratar en algún lugar. Este lugar son las rutinas de tratamiento. Generalmente existe una rutina de tratamiento para cada tipo de excepción que pueda ser generada en el bloque try (esto permite actuar en consecuencia de la generación de diversos tipos de errores). Estas rutinas están situadas luego del bloque try y se denotan mediante la palabra clave catch. Solo se ejecutará una sola clausula catch, la que se ajuste al tipo de excepción generada.
• Finalización (o bloque finally): Es un bloque de código que se ejecuta siempre, más allá de que se haya generado una excepción, o no se haya hecho. Esta sección generalmente se utiliza cuando es necesario restaurar a su estado original alguna otra cosa distinta de la propia memoria. (Es importante recalcar que la ejecución de este bloque de código se realiza SIEMPRE, más allá de que dentro del bloque try haya una instrucción return.)
  

Ver ejemplo: Main01.java

Excepciones definidas por el usuario

La jerarquía de excepciones de Java no puede prever todos los errores de los que vayamos a querer informar, por eso se pueden crear excepciones definidas por el usuario que indican errores especiales para una biblioteca. Para crear excepciones definidas por el usuario, se debe heredar de una clase de excepción existente, preferiblemente de una cuyo significado esté próximo al de nuestra propia excepción (aunque a menudo esto no es posible). Lo más importante acerca de una excepción es el nombre de la clase, que hace referencia al tipo de error.
Ver ejemplo: codigo/Main02.java

Especificación de excepciones

Mientras se ejecuta un método se puede dar la situación de que se genere una excepción, ante este escenario, se pueden realizar dos cosas. El propio método puede contener una rutina de tratamiento para dicha excepción o que el mismo lance la excepción a un contexto superior. En el segundo caso, la excepción es lanzada al contexto en donde el método fue invocado. Esto significa que la invocación de un método puede generar una excepción (por lo cual la invocación debe estar dentro de un bloque try).
Java proporciona una sintaxis (y es obligatorio utilizarla) para permitir especificar las excepciones que puede generar un método. Se trata de la especificación de excepciones, la cual forma parte de la declaración del método y aparece luego de la lista de argumentos. Utiliza la palabra clave throws y contiene todos los tipos potenciales de excepciones que puede generar el método. El compilador provocará un error en caso de que se intente lanzar una excepción (de tipo comprobada) no declarada en la clausula throws.
NOTA: Las excepciones no comprobadas (excepciones que heredan de la clase RuntimeException o algún subtipo de ella) no se necesitan declarar en la clausula throws. Es obligatorio declarar todas las excepciones comprobadas potenciales que puede lanzar un método.
Ver ejemplo: codigo/Main03.java

La clase Throwable describe todas las cosas que pueden generarse como una excepción. Existen dos tipos generales de objetos Throwable (que heredan de ella). El subtipo Error representa los errores de tiempo de compilación y del sistema de los que no tenemos que preocuparnos de capturar. El subtipo Exception es el tipo básico que puede generarse desde cualquiera de los métodos de la biblioteca estándar de Java.
Existe un conjunto completo de tipos de excepción que son generadas de forma automática por Java y que no es necesario incluir en las especificaciones de excepciones (como se mostro en el ejemplo de código anterior Main03.java). Estas excepciones están agrupadas y son subtipos de la clase RuntimeException. Son denominadas excepciones no comprobadas. Las mismas indican errores de programación, normalmente no se suelen capturar, ya que el sistema las trata automáticamente.

Las excepciones que se necesitan saber para el exámen son:
Derivadas de RuntimeException:

• ArrayIndexOutOfBoundsException: Excepción que hereda de IndexOutOfBoundsException. Se lanza cuando se intenta acceder a un elemento de un arreglo con un índice inválido o con un valor negativo.
  
• ClassCastException: Se lanza cuando se intenta castear una variable de referencia a un tipo que no cumple con la relación ES-UN.
• IllegalArgumentException: Se lanza cuando un método recibe un argumento formateado diferente a como el método lo espera. Por ej.: el método parseInt() genera esta excepción.
• IllegalStateException: Se lanza cuando el estado de un ambiente no es el correcto para la operación que se esta intentando. Por ej.: utilizar un objeto Scanner que esta cerrado.
  
• NullPointerException: Se lanza cuando se intenta acceder a un objeto con una variable de referencia con valor null.
• NumberFormatException: Excepción que hereda de IllegalArgumentException. Se lanza cuando un método que convierte un String a un número, recibe un String que no puede ser convertido.
  

Derivadas de Error:

• AssertionError: Se lanza cuando cuando la expresión dentro de un assert tiene el resultado false.
• ExceptionInInitializerError: Hereda de LinkageError. Se lanza para indicar que ha ocurrido una excepción al momento de inicializar una variable estática o un bloque de inicialización estático.
• StackOverflowError: Hereda de VirtualMachineError. Se lanza cuando se produce un desbordamiento de la pila. Esta situación se da debido a un método que recursa profundamente.
• NoClassDefFoundError: Hereda de LinkageError. Se lanza la JVM no puede encontrar la definición de una clase que necesita. Sus causas pueden ser: un error al especificar la clase en la línea de comandos, un tema relacionado al classpath, o la falta del archivo .class.
  

Restricciones de la excepciones

Cuando sustituimos un método, sólo podemos generar aquellas excepciones que hayan sido especificadas en la versión del método correspondiente a la clase base. Esta restricción implica que el código que funcione con la clase base funcionará también automáticamente con cualquier objeto derivado de la clase base.
En cambio los constructores pueden generar todas aquellas excepciones que deseen, independientemente de lo que genere el constructor de la clase base. Sin embargo, puesto que siempre hay que invocar algún constructor de la clase base, el constructor de la clase derivada deberá declarar todas las excepciones del constructor de la clase base en su propia especificación de excepciones.
En resumen, la interfaz de especificación de excepciones de un método concreto puede estrecharse durante la herencia y cuando se realizan sustituciones, pero nunca ensancharse (solo puede ensancharse con excepciones derivadas a la declarada en el método de la clase base ver ejemplo). En cambio en un constructor de una clase derivada, la interfaz de especificación de excepciones puede ensancharse pero no estrecharse.
Ver ejemplo: codigo/Main04.java

Resumen del capítulo 11 (Almacenamiento de objetos) del "Libro Thinking in Java (4ta Edición)".

Introducción

La biblioteca java.util posee un conjunto bastante completo de clases contenedoras. Existen cuatro tipo básicos: List, Set, Queue y Map (lista, conjunto, cola y mapa). Los contenedores proporcionan formas más sofisticadas (que las matrices) de almacenar objetos.
La biblioteca de contenedores Java toma la idea de “almacenamiento de los objetos” y la divide en dos conceptos distintos, expresados mediante las interfaces básicas de la biblioteca:

• Collection: una secuencia de elementos individuales a los que se aplica una o más reglas.
  - List: almacena los elementos en la forma en la que fueron insertados.
  - Set: no puede tener elementos duplicados.
  - Queue: produce los elementos en el orden determinado por una disciplina de cola.
• Map: un grupo de parejas de objetos clave-valor, que permite efectuar búsquedas de valores utilizando una clase. Un mapa permite buscar un objeto utilizando otro objeto. También se lo denomina matriz asociativa o diccionario.
  

Estas interfaces utilizan tipos genéricos, es decir, se debe especificar el tipo de objeto/s que almacenará el contenedor. Esto se realiza a través de corchetes angulares que rodean los parámetros de tipo.
De ser posible, se debe intentar escribir la mayor parte del código para que se comunique con estas interfaces. El único lugar donde se debería especificar el tipo concreto del contenedor es en la creación del mismo.
Ver ejemplo: Main01.java

Existen métodos de utilidad en las clases Arrays y Collections de java.util que añaden grupos de elementos a una colección:

• Collections.addAll (Collection c, T… elements): toma un objeto de tipo Collection como primer argumento y una lista de valores separados por coma. Añade los elementos a la colección.
• Arrays.asList (T… a): toma una lista de valores separados por coma y lo transforma en un objeto List.
  

Ver ejemplo: Main02.java

List

Las listas garantizan que los elementos se mantengan en una secuencia concreta. La interface List añade varios métodos a Collection que permiten la inserción y la eliminación de elementos en mitad de una lista.
Existen dos tipos de objetos List:

• ArrayList: Es el que mejor permite acceder a los elementos de forma aleatoria, pero que resulta más lento a la hora de insertar y eliminar elementos en mitad de una lista.
• LinkedList: Proporciona un acceso secuencial óptimo, siendo las inserciones y borrados en mitad de una lista enormemente rápidos. Resulta relativamente lento para los accesos aleatorios, pero tiene muchas más funcionalidades que ArrayList.
  

Métodos de la interface:

• boolean contains(Object o): Permite averiguar si un objeto se encuentra dentro de la lista.
• boolean remove(Object o): Permite eliminar un objeto, pasando la referencia al mismo.
• int indexOf(Object o): Pasando como parámetro una referencia a un objeto, devuelve el número de índice en el que ese objeto está almacenado.
  

Estos últimos tres métodos utilizan el método equals() para realizar sus operaciones. Es decir, sobrescribiendo este método (perteneciente a la clase Object) se puede alterar el funcionamiento de estas operaciones.

• List subList(int fromIndex,int toIndex): Permite crear una sublista (respaldada) a partir de otra lista de mayor tamaño. Los cambios efectuados en la lista devuelta se verán reflejados en la lista original, y viceversa.
• boolean containsAll(Collection c): Verifica si los elementos pertenecen a la lista.
• boolean retainAll(Collection c): Es una operación de intersección de conjuntos, el comportamiento resultante depende de la implementación del método equals().
• boolean removeAll(Collection c): Elimina de la lista todos los objetos que estén en el argumento de tipo List. También opera de manera distinta dependiendo del método equals().
• boolean isEmpty(): Devuelve true si la lista se encuentra vacía.
• void clear(): Elimina todos los elementos de la lista.
• E set(int index, E element): Se encarga de sustituir el elemento situado en el índice indicado (el primer argumento) con el segundo argumento.
  

Ver ejemplo: Main03.java

Set

Los objetos de tipo Set (conjuntos) no permiten almacenar más de una instancia de cada objeto, impide la duplicación. Para insertar un nuevo elemento se debe verificar la no pertenencia, por este motivo la operación más importante de un conjunto suele ser el de la búsqueda. Set tiene la misma interfaz que Collection, por lo que no existe ninguna funcionalidad adicional.
Existen tres tipos de contenedores Set:

• HashSet: Utiliza el mecanismo de hash para acelerar las búsquedas de elementos.
• TreeSet: Mantiene los elementos ordenados en una estructura de datos de tipo árbol rojo-negro. Este objeto es útil para mantener los objetos ordenados.
• LinkedHashSet: Es un subtipo de HashSet, por lo tanto también emplea una función hash para acelerar las búsquedas, pero mantiene los elementos en orden de inserción utilizando una lista enlazada.
  

Ver ejemplo: Main04.java

Queue

Una cola es normalmente un contenedor de tipo FIFO (first-in, first-out). El orden en el que se introduzcan los elementos coincidirá con el orden en que estos serán extraídos. Las colas son especialmente importantes en la programación concurrente.
Existen dos tipos de contenedores Queue:

• LinkedList: Dispone de métodos para soportar el comportamiento de una cola e implementa la interface Queue, por lo que un objeto LinkedList puede utilizarse como implementación de Queue.
• PriorityQueue: Es una implementación automática de una cola con prioridad. Este tipo de contenedor implica que el elemento que va a continuación será aquel que tenga una necesidad mayor (la prioridad más alta). El mecanismo de ordenación predeterminado utiliza el orden natural de los objetos de la cola, pero se puede modificar dicho elemento proporcionando otro objeto Comparator.

Arroja una excepción Retorna un valor especial
Inserta boolean add(E e) boolean offer(E e)
Elimina E remove() E poll()
Obtiene E element() E peek()

Ver ejemplo: Main05.java

Map

Los mapas permiten asociar objetos con otros objetos. Es decir, almacenan parejas de clave-valor. En los contenedores no se pueden almacenar primitivas, por eso la característica autoboxing convierte las primitivas en sus correspondientes objetos envoltorios. Este tipo de contenedores puede expandirse fácilmente para que sean multidimensionales, basta con definir un objeto Map cuyos valores sean también mapas.
Existen tres tipos de contenedores Map:

• HashMap: Están diseñados para un acceso rápido.
• TreeMap: Mantiene sus claves ordenadas y no es tan rápido como el anterior.
• LinkedHashMap: Mantiene sus elementos en orden de inserción, pero proporciona un acceso rápido con mecanismos de hash.
  

Métodos de la interface:

• boolean containsKey(Object key): Permite evaluar si existe una determinada clave en el mapa.
• boolean containsValue(Object value): Permite evaluar si existe un determinado valor en el mapa.
• V get(Object key): Dado un objeto clave, devuelve el valor asociado a dicha clave.
• V put(K key, V value): Agrega un nuevo elemento al mapa.
• void putAll(Map m): Agrega todos los elementos de un mapa a otro.
• Set keySet(): Devuelve un conjunto Set con todas las claves. (Las claves no pueden estar repetidas).
• Collection values(): Devuelve una colección con todos los valores del mapa.
  

Ver ejemplo: Main06.java

Iteradores

Iterator
Es una interface que permite desplazarse a través de una secuencia y seleccionar cada uno de los objetos que la componen.

• boolean hasNext(): Permite ver si hay más objetos en la secuencia.
• E next(): Obtiene el siguiente objeto de la secuencia.
• void remove(): Elimina el último elemento devuelto por el iterador.
  

ListIterator
Es un subtipo más potente de Iterator que solo se genera mediante las clases List. ListIterator es bidireccional, puede generar los índices de los elementos siguiente y anterior, en relación al lugar de la lista hacia el que el iterador está apuntando y también posee otras funcionalidades. Los métodos que adiciona esta interface son:

• boolean hasPrevious(): Realiza la misma acción que hasNext() pero en sentido contrario.
• E previous(): Idem next() pero en sentido contrario.
• int nextIndex(): Obtiene el número de índice del elemento siguiente.
• int previousIndex(): Obtiene el número de índice del elemento anterior.
• void set(E e): Permite sustituir el elemento al que apunta por el iterador.
• void add(E e): Inserta un elemento en la lista.
  

NOTA: NO HAY NECESIDAD DE UTILIZAR LAS CLASES ANTIGUAS Vector, Hashtable y Stack.

Resumen del capítulo 10 (Clases Internas) del "Libro Thinking in Java (4ta Edición)".

Introducción

Las clases internas nos permiten agrupar clases relacionadas y controlar la visibilidad mutua de esas clases. Un objeto de una clase interna conoce todos los detalles de la instancia de su clase contenedora y puede comunicarse con ella. Esto se logra debido a que la instancia de la clase interna dispone de un enlace al objeto contenedor que la ha creado (de este modo se puede acceder a todos los miembros del objeto contenedor). Solo se puede instanciar una clase interna a través de una referencia al objeto de la clase contenedora.
Ver ejemplo: Main01.java

Desde una instancia de una clase interna se puede referenciar al objeto contenedor de la siguiente manera: NombreClaseContenedra.this
Como se puede ver en el ejemplo Main01.java, no es posible crear un objeto de la clase interna a menos que ya se disponga de un objeto de la clase externa (o contenedora). Esto se debe a que el objeto de la clase interna se conecta de manera transparente al de la clase externa que lo haya creado. (Esto resuelve también las cuestiones relativas a los ámbitos de los nombres en la clase interna)
Las clases normales (no internas) no pueden ser privadas o protegidas (solo pueden tener acceso público o de paquete). Las clases internas pueden tener cualquiera de los cuatro tipos de acceso. Esto permite ocultar las implementaciones de las clases internas y evitar las dependencias de la codificación de tipos. Main02.java: Por defecto los métodos de una interface son públicos, a través de la implementación (de dicha interface) de una clase interna privada (o protegida) los mismos pueden ser no visibles y no estar disponibles.
Ver ejemplo: Main02.java

Clases internas locales

Las clases internas pueden crearse dentro de un método o incluso dentro de un ámbito arbitrario. Estas clases (definidas dentro de métodos) se denominan clases internas locales. Main03.java: Las clases definidas dentro de bloques if – else, se compilan con todo el resto del código. Sin embargo estas clases no están disponibles fuera del ámbito en el que se definen, por lo demás se asemejan a clases normales.
Ver ejemplo: Main03.java

Clases internas anónimas

Una clase interna anónima, es una clase que no tiene nombre. Generalmente se utilizan para implementar una interface (o extender de otra clase) y devolverse a través de un método. Es decir, se crean solo con el objetivo de darle una implementación a una interface. Este tipo de clases están en cierta forma limitadas si se comparan con el mecanismo normal de herencia, porque pueden extender una clase o implementar solo una interface, pero no pueden hacer ambas cosas al mismo tiempo.
Luego de definir una clase interna anónima se cierra la expresión con un punto y coma. Si se está definiendo una clase interna anónima y se quiere usar un objeto que este definido fuera de la clase interna anónima, el compilador requiere que la referencia al argumento sea FINAL. Si esto no se hace el compilador generará un mensaje de error.
Ver ejemplo: Main04.java

Clases anidadas (Clases internas estáticas)

Una clase anidada es una clase interna estática. Este tipo de clases internas son útiles cuando no es necesario disponer de una conexión entre el objeto de la clase interna y el objeto de la clase externa. No se puede acceder a un objeto no estático de la clase externa desde un objeto de una clase anidada (debido a que no existe una conexión con la clase externa).
A diferencia de las clases internas normales que no pueden tener miembros estáticos o clases anidadas, las clases anidadas si pueden contener estos elementos.
Ver ejemplo: Main05.java

A continuación dejo unos ejemplos de código con explicaciones. Estos ejemplos surgieron a partir de la realización de los ejercicios del capítulo 4 (Operators) del libro "Sun Certified Programmer for Java 6 Study Guide".
Para ver el post con el resumen de dicho capítulo haz click aquí.
Cada ejemplo tiene un link para visualizar el código original desde el proyecto (SVN) google.

Las concatenaciones se ejecutan de izquierda a derecha. Se pueden realizar concatenaciones entre diferentes tipos de operandos, es decir, se pueden concatenar tipos primitivos con objetos o viceversa (una concatenación de un objeto se traduce en el llamado al método toString(), para ver una explicación más detallada de la concatenación de objetos ver el ejemplo ConcatenacionObejtos.java).
En resumen, si el primer operando de una concatenación es un String se tomarán todos los siguientes como cadenas (línea 5 y 6). En caso contrario, se realizarán todas las operaciones de adición hasta que aparezca la primer cadena de caracteres, la cuál provocará que se tome todos los demás valores como cadenas (línea 7).

EJEMPLO 2 (Ver código original)