En esta sección, aprenderá acerca de las diversas sentencias y operadores que usará para comunicarle a sus programas Java cómo quiere que actúen en base a una entrada diferente.
El lenguaje Java le da operadores y sentencias de control que le permiten tomar decisiones en su código. Muy a menudo, una decisión en el código comienza con una expresión booleana (es decir, una que evalúa ya sea verdadera o falsa). Tales expresiones usan operadores relacionales, que comparan un operando o una expresión con otra, y operadores condicionales.
La Tabla 3 enumera los operadores relacionales y condicionales del lenguaje Java:
Tabla 3. Operadores relacionales y condicionales
Ahora que tiene un grupo de operadores, es momento de usarlos. Este código muestra lo que sucede cuando agrega algo de lógica al accessor getHeight() del objeto Person:
1
2
3
4
5
6
7
public int getHeight() { int ret = height; // If locale of the machine this code is running on is U.S., if (Locale.getDefault().equals(Locale.US)) ret /= 2.54;// convert from cm to inches return ret;}Si el entorno local actual está en los Estados Unidos (donde no se usa el sistema métrico), entonces tal vez tenga sentido convertir el valor interno de altura (en centímetros) a pulgadas. Este ejemplo ilustra el uso de la sentencia if, que evalúa una expresión booleana en paréntesis. Si esa expresión evalúa como verdadera, ejecuta la siguiente sentencia.
En este caso, solo necesita ejecutar una sentencia si el Locale de la máquina en la que se ejecuta el código es Locale.US. Si necesita ejecutar más de una sentencia, puede usar llaves para formar una sentencia compuesta. Una sentencia compuesta agrupa muchas sentencias en una, — y las sentencias compuestas también pueden contener otras sentencias compuestas.
Cada variable en una aplicación Java tiene un ámbito, o espacio de nombres localizado, al cual usted puede acceder por nombre dentro del código. Fuera de ese espacio, la variable está fuera de ámbito y usted obtendrá un error de compilación si intenta acceder a ella. Los niveles de ámbitos en el lenguaje Java se definen de acuerdo a dónde se declare una variable, como se muestra en el Listado 8:
Listado 8. Ámbito variable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SomeClass {
private String someClassVariable; public void someMethod(String someParameter) { String someLocalVariable = "Hello"; if (true) { String someOtherLocalVariable = "Howdy"; } someClassVariable = someParameter; // legal someLocalVariable = someClassVariable; // also legal someOtherLocalVariable = someLocalVariable;// Variable out of scope! } public void someOtherMethod() { someLocalVariable = "Hello there";// That variable is out of scope! }}Dentro de SomeClass, someClassVariable es accesible por medio de todos los métodos de instancia (es decir, no estáticos). Dentro de someMethod,someParameter es visible pero, fuera de ese método, no lo es y lo mismo sucede para someLocalVariable. Dentro del bloque if, someOtherLocalVariable se declara y, fuera de ese bloque if, está fuera de ámbito.
El ámbito tiene muchas reglas pero el Listado 8 muestra las más comunes. Tómese algunos minutos para familiarizarse con ellas.
Hay momentos en el flujo de control de un programa en los que usted quiere participar solo si una expresión particular falla al evaluar como verdadero. En ese momento es cuando else resulta de ayuda:
1
2
3
4
5
6
7
8
9
10
public int getHeight() { int ret; if (gender.equals("MALE")) ret = height + 2; else { ret = height; Logger.getLogger("Person").info("Being honest about height..."); } return ret;}La sentencia else funciona del mismo modo que if en el sentido que ejecuta solo la siguiente sentencia que encuentra. En este caso, dos sentencias se agrupan en una sentencia compuesta (observe las llaves), que luego el programa ejecuta.
También puede usar else para realizar una verificación if adicional, del siguiente modo:
1
2
3
4
5
6
7
8
9
10
if (conditional) { // Block 1} else if (conditional2) { // Block 2} else if (conditional3) { // Block 3} else {
// Block 4} // EndSi conditional evalúa como verdadero, entonces el Block 1 se ejecuta y el programa salta a la siguiente sentencia luego de la llave final (lo que se indica con // End). Si conditionalno evalúa como verdadero, entonces se evalúaconditional2. Si es verdadero, entonces el Block 2 se ejecuta y el programa salta a la siguiente sentencia luego de la llave final. Si conditional2 no es verdadero, entonces el programa sigue con conditional3 y así sucesivamente. Solo si las tres condicionales fallan, se ejecutaría el Block 4.
El lenguaje Java proporciona un operador práctico para hacer simples verificaciones de sentencias if/else. Su sintaxis es:
Si conditional evalúa como verdadero, entonces se ejecuta statementIfTrue; caso contrario, se ejecuta statementIfFalse. Las sentencias compuestas no se permiten para ninguna de las sentencias.
El operador ternario es de ayuda cuando usted sabe que necesitará ejecutar una sentencia como el resultado de la condicional que evalúa como verdadero, y otra si no lo hace. Los operadores ternarios a menudo se usan para inicializar una variable (como un valor de retorno), como de la siguiente manera:
1
1
2
3
(conditional) ? statementIfTrue : statementIfFalse;public int getHeight() { return (gender.equals("MALE")) ? (height + 2) : height;}Los paréntesis que siguen luego del signo de interrogación anterior no se requieren estrictamente pero sí hacen que el código sea más legible.
Además de poder aplicar condiciones a sus programas y ver diferentes resultados en base a diversos escenarios if/then, a veces quiere que su código solo haga lo mismo una y otra vez hasta que se haga el trabajo. En esta sección, aprenda acerca de dos construcciones usadas para iterar el código o ejecutarlo más de una vez. Bucles for y bucles while loops.
Un bucle es una construcción de programación que se ejecuta repetidamente mientras se cumple alguna condición (o conjunto de condiciones). Por ejemplo, puede pedirle a un programa que lea todos los registros hasta el final de un archivo o que realice un bucle por todos los elementos de una matriz, procesando cada uno. (Aprenderá acerca de las matrices en la sección Java Collections de este tutorial).
La construcción de bucle básico en el lenguaje Java es la sentencia for, que le permite iterar un rango de valores para determinar cuántas veces ejecutar un bucle. La sintaxis abstracta para un bucle for es:
1
2
3
for (initialization; loopWhileTrue; executeAtBottomOfEachLoop) { statementsToExecute}Al comienzo del bucle, se ejecuta la sentencia de inicialización (las sentencias de inicialización múltiples se pueden separar con comas). Mientras loopWhileTrue(una expresión condicional de Java que debe evaluar ya sea como verdadero o falso) sea verdadero, el bucle se ejecutará. Al final del bucle, se ejecutaexecuteAtBottomOfEachLoop.
Ejemplo de un bucle for
Si usted quisiera cambiar a un método main() para que se ejecute tres veces, podría usar un bucle for, como se muestra en el Listado 9:
Listado 9. Un bucle for
1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) { Logger l = Logger.getLogger(Person.class.getName()); for (int aa = 0; aa < 3; aa++) { Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE"); l.info("Loop executing iteration# " + aa); l.info("Name: " + p.getName()); l.info("Age:" + p.getAge()); l.info("Height (cm):" + p.getHeight()); l.info("Weight (kg):" + p.getWeight()); l.info("Eye Color:" + p.getEyeColor()); l.info("Gender:" + p.getGender()); }}La variable local aa se inicializa en cero al comienzo del listado. Esta sentencia se ejecuta solo una vez, cuando se inicializa el bucle. Luego, el bucle continúa tres veces y cada vez se incrementa aa en uno.
Como verá más adelante, una sintaxis alternativa de bucle for está disponible para realizar un bucle por las construcciones que implementan la interfazIterable (tales como matrices y otras clases de programas de utilidad Java). Por ahora, solo observe el uso de la sintaxis del bucle for en el Listado 9.
La sintaxis para un bucle while es:
1
2
3
while (loopWhileTrue) { statementsToExecute}Como puede sospechar, while loopWhileTrue evalúa como verdadero, por lo tanto el bucle se ejecutará. En la parte superior de cada iteración (es decir, antes de que se ejecute cualquier sentencia), se evalúa la condición. Si es verdadero, el bucle se ejecuta. Por lo que es posible que un bucle while nunca se ejecute si su expresión condicional no es verdadera por lo menos una vez.
Observe de nuevo el bucle for en el Listado 9. Por comparación, el Listado 10 lo codifica usando un bucle while:
Listado 10. Un bucle while
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) { Logger l = Logger.getLogger(Person.class.getName()); int aa = 0; while (aa < 3) { Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE"); l.info("Loop executing iteration# " + aa); l.info("Name: " + p.getName()); l.info("Age:" + p.getAge()); l.info("Height (cm):" + p.getHeight()); l.info("Weight (kg):" + p.getWeight()); l.info("Eye Color:" + p.getEyeColor()); l.info("Gender:" + p.getGender()); aa++; }Como puede ver, un bucle while requiere un poco más de mantenimiento que un bucle for. Usted debe inicializar la variable aa y también recordar incrementarla al final del bucle.
Si usted quiere un bucle que se ejecute siempre una vez y luego verifique su expresión condicional, pruebe usar un bucle do...while, como se muestra en el Listado 11:
Listado 11. Un bucle do...while
1
2
3
4
5
6
7
8
9
10
11
12
int aa = 0;do { Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE"); l.info("Loop executing iteration# " + aa); l.info("Name: " + p.getName()); l.info("Age:" + p.getAge()); l.info("Height (cm):" + p.getHeight()); l.info("Weight (kg):" + p.getWeight()); l.info("Eye Color:" + p.getEyeColor()); l.info("Gender:" + p.getGender()); aa++;} while (aa < 3);La expresión condicional (aa < 3) no se verifica hasta el final del bucle.
Hay momentos en los que necesita retirarse de un bucle antes de que la expresión condicional evalúe como falso. Esto podría suceder si usted estuviera buscando una matriz de Strings para un valor particular y, una vez que lo encontrara, no le importara los otros elementos de la matriz. Para aquellos momentos en que usted solo quiere retirarse, el lenguaje Java proporciona la sentencia break, como se muestra en el Listado 12:
Listado 12. Una sentencia break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args) { Logger l = Logger.getLogger(Person.class.getName()); int aa = 0; while (aa < 3) { if (aa == 1) break; Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE"); l.info("Loop executing iteration# " + aa); l.info("Name: " + p.getName()); l.info("Age:" + p.getAge()); l.info("Height (cm):" + p.getHeight()); l.info("Weight (kg):" + p.getWeight()); l.info("Eye Color:" + p.getEyeColor()); l.info("Gender:" + p.getGender()); aa++; }La sentencia break lo lleva a la siguiente sentencia ejecutable fuera del bucle en el que se ubica.
En el ejemplo (simplista) del Listado 12, usted solo quiere ejecutar el bucle una vez y retirarse. También puede saltar una sola iteración de un bucle pero continúa ejecutando el bucle. Para eso, necesita la sentencia continue, que se muestra en el Listado 13:
Listado 13. Una sentencia continue
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) {Logger l = Logger.getLogger(Person.class.getName());int aa = 0;while (aa < 3) { if (aa == 1) continue; else aa++; Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE"); l.info("Loop executing iteration# " + aa); l.info("Name: " + p.getName()); l.info("Age:" + p.getAge()); l.info("Height (cm):" + p.getHeight()); l.info("Weight (kg):" + p.getWeight()); l.info("Eye Color:" + p.getEyeColor()); l.info("Gender:" + p.getGender());}En el Listado 13, usted salta la segunda iteración de un bucle pero continúa con la tercera. continue es de ayuda cuando está, digamos, procesando registros y se encuentra con un registro que definitivamente no quiere procesar. Solo salte ese registro y siga con el siguiente.
La mayoría de las aplicaciones del mundo real lidian con colecciones de elementos: archivos, variables, registros de archivos, conjuntos de resultados de bases de datos, entre otros. El lenguaje Java tiene una sofisticada Infraestructura de colecciones que le permite crear y manejar colecciones de objetos de diversos tipos. Esta sección no le enseñará todo acerca de las Colecciones Java pero le presentará las clases de colecciones más comúnmente usadas y le hará comenzar a usarlas.
La mayoría de los lenguajes de programación incluyen el concepto de una matrizpara tener una colección de elementos y el lenguaje Java no es ninguna excepción. Una matriz no es nada más que una colección de elementos del mismo tipo.
Puede declarar una matriz en una de dos formas:
Declaración de una matriz
En general, usted declara una matriz del siguiente modo:
Existen dos formas para crear una matriz entera de elementos. Esta sentencia crea una matriz con espacio para cinco elementos pero está vacía:
Esta sentencia crea la matriz y la inicializa, todo a la vez:
1
1
2
1
2
new elementType [arraySize]// crea una matriz vacía de 5 elementos:int[] integers = new int[5];// crea una matriz de 5 elementos con valores:int[] integers = new int[] { 1, 2, 3, 4, 5 };Nota: Los corchetes en los ejemplos de códigos de esta sección son parte de la sintaxis requerida para las Colecciones Java, no indicadores de elementos opcionales.
Los valores iniciales van entre las llaves y se separan con comas.
Matrices, al modo difícil
Un modo más difícil para crear una matriz sería crearla y luego codificar un bucle para inicializarlo:
1
2
3
4
int[] integers = new int[5];for (int aa = 0; aa < integers.length; aa++) { integers[aa] = aa;}Este código declara la matriz entera de cinco elementos. Si usted intenta poner más de cinco elementos en la matriz, el tiempo de ejecución de Java reclamará y arrojará una excepción. Aprenderá acerca de las excepciones y cómo manejarlas en la Part 2.
Carga de una matriz
Para cargar una matriz, serpentee por los enteros desde 1 a través de la longitud de la matriz (a la cual llega al llamar .length en la matriz, — más sobre eso en un minuto). En este caso, usted se detiene cuando llegue a 5
Una vez que se carga la matriz, puede acceder a ella como antes:
1
2
3
4
1
2
3
4
Esta sintaxis (nueva desde el JDK 5) también funciona:
Logger l = Logger.getLogger("Test");for (int aa = 0; aa < integers.length; aa++) { l.info("This little integer's value is: " + integers[aa]);}Logger l = Logger.getLogger("Test");for (int i : integers) { l.info("This little integer's value is: " + i);}Encuentro la sintaxis más nueva más simple para trabajar y la usaré a lo largo de esta sección.
El índice de elementos
Considere a una matriz como una serie de grupos y en cada grupo va un elemento de cierto tipo. Se gana el acceso a cada grupo al usar un índice:
Para acceder a un elemento, necesita la referencia a la matriz (su nombre) y el índice donde reside el elemento que usted quiere.
El método length
Un método útil, como ya ha visto, es length. Es un método incorporado, por lo tanto su sintaxis no incluye los paréntesis habituales. Solo escriba la palabralength y devolverá, — cómo es de esperar, — el tamaño de la matriz.
Las matrices en el lenguaje Java están basadas en cero. Por lo tanto, para alguna matriz llamada array, el primer elemento en la matriz reside siempre enarray[0] y el último reside en array[array.length - 1].
Una matriz de objetos
Ha visto cómo las matrices pueden tener tipos primitivos pero vale la pena mencionar que también pueden tener objetos. En ese sentido, la matriz es la colección más utilitaria del lenguaje Java.
Crear una matriz de objetos java.lang.Integer no es muy diferente de crear una matriz de tipos primitivos. Una vez más, tiene dos modos de hacerlo:
1
1
2
1
2
3
4
5
6
element = arrayName [elementIndex];// crea una matriz vacía de 5 elementos:Integer[] integers = new Integer[5];// crea una matriz de 5 elementos con valores:Integer[] integers = new Integer[] { Integer.valueOf(1), Integer.valueOf(2) Integer.valueOf(3) Integer.valueOf(4) Integer.valueOf(5));Cada tipo primitivo en el lenguaje Java tiene una clase homóloga JDK, que puede ver en la Tabla 4:
Tabla 4. Primitivos y homólogos JDK
Cada clase JDK proporcionar métodos para analizar y convertir desde su representación interna hasta un tipo primitivo correspondiente. Por ejemplo, este código convierte el valor decimal 238 a un Integer:
1
2
int value = 238;Integer boxedValue = Integer.valueOf(value);Esta técnica se conoce como embalaje porque está poniendo el primitivo en un envoltorio o caja.
De forma similar, para convertir la representación de Integer de nuevo a su homólogo int, usted lo desembalaría de la siguiente forma:
1
2
Integer boxedValue = Integer.valueOf(238);int intValue = boxedValue.intValue();Embalaje automático y desembalaje automático
En un sentido estricto, usted no necesita embalar y desembalar los primitivos de forma explícita. En cambio, podría usar las funciones de embalaje automático y desembalaje automático del lenguaje Java, del siguiente modo:
1
2
3
4
int intValue = 238;Integer boxedValue = intValue;//intValue = boxedValue;Sin embargo, recomiendo que evite usar el embalaje automático y desembalaje automático porque puede llevar a tener problemas de códigos. El código en los fragmentos de embalaje y desembalaje es más evidente, y de ese modo más legible, que el código embalado automáticamente y creo que vale la pena hacer el esfuerzo extra.
Análisis y conversión de tipos embalados
Ha visto cómo obtener un tipo embalado pero, ¿qué tal si se analiza una Stringque usted sospecha que tiene un tipo embalado en la caja misma? Las clases de envoltorio JDK tienen métodos para eso también:
1
2
1
2
También puede convertir los contenidos de un tipo de envoltorio JDK a String:
String characterNumeric = "238";Integer convertedValue = Integer.parseInt(characterNumeric);Integer boxedValue = Integer.valueOf(238);String characterNumeric = boxedValue.toString();Observe que cuando usa el operador de concatenación en una expresión deString (ya ha visto esto en las llamadas al Logger), el tipo primitivo se embala automáticamente y los tipos de envoltorio tienen automáticamente atoString() invocada sobre ellos. Muy útil.
Una Lista es una construcción de colección que, por definición, es una colección ordenada, también conocida como una secuencia. Debido a que una Lista es ordenada, usted tiene completo control sobre el lugar en donde van los elementos en la Lista. Una colección de Lista Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.
La Lista es una interfaz, por lo que usted no puede crear una instancia de ella directamente. Trabajará con su implementación más comúnmente usada,ArrayList:
Observe que hemos asignado el objeto ArrayList a una variable de tipo Lista. La programación Java le permite asignar una variable de un tipo a otro, siempre y cuando la variable a la que se asigna sea una superclase o interfaz implementada por la variable desde la cual se asigna. Veremos más sobre cómo se afectan las asignaciones de variables en la Part 2 en la sección Inheritance.
Tipo formal
¿Qué sucede con el <Object> en el recorte anterior del código? Se llama el tipo formal y le comunica al compilador que esta Lista contiene una colección de tipoObject, lo que significa que puede poner prácticamente lo que quiera en laLista.
Si usted quisiera intensificar las restricciones sobre lo que pudiera o no ir en laLista, la definiría de modo diferente:
Ahora su Lista solo puede tener instancias de Person.
Uso de las Listas
Usar las Listas es muy fácil, como las colecciones Java en general. Aquí hay algunas de las cosas que querrá hacer con las Listas:
Lista.Lista cuán grande es actualmente.Lista.Intentemos algunas de estas. Ya ha visto cómo crear una instancia de la Lista al crear una instancia de su tipo de implementación de ArrayList, por lo que comenzará desde allí.
Para poner algo en una Lista, llame al método add():
1
1
1
2
List<Object> listOfObjects = new ArrayList<Object>();List<Person> listOfPersons = new ArrayList<Person>();List<Integer> listOfIntegers = new ArrayList<Integer>();listOfIntegers.add(Integer.valueOf(238));El método add() agrega el elemento al final de la Lista.
Para preguntarle a la Lista cuán grande es, llame al size():
1
2
3
4
1
2
3
4
Para recuperar un elemento de la Lista, llame al get() y pase el índice del elemento que usted quiere:
List<Integer> listOfIntegers = new ArrayList<Integer>();listOfIntegers.add(Integer.valueOf(238));Logger l = Logger.getLogger("Test");l.info("Current List size: " + listOfIntegers.size());List<Integer> listOfIntegers = new ArrayList<Integer>();listOfIntegers.add(Integer.valueOf(238));Logger l = Logger.getLogger("Test");l.info("Item at index 0 is: " listOfIntegers.get(0));En una aplicación del mundo real, una Lista contendría registros, u objetos de negocios, y usted posiblemente querría examinarlos todos como parte de su proceso. ¿Cómo hace eso de un modo genérico? Tiene que iterar por la colección, lo cual usted puede hacer porque la Lista implementa la interfazjava.lang.Iterable. (Aprenderá acerca de las interfaces en la Part 2).
Si una colección implementa java.lang.Iterable, se llama una colección iterable. Eso significa que usted puede comenzar por un extremo y recorrer la colección elemento por elemento hasta que se le acaben los elementos.
Ya ha visto la sintaxis especial para iterar por las colecciones que implementan la interfaz Iterable, en la sección Loops. Aquí está de nuevo:
1
2
3
for (objectType varName : collectionReference) { // Start using objectType (via varName) right away...}Iteración en una Lista
El ejemplo anterior fue abstracto. Ahora, aquí tiene uno más realista:
1
2
3
4
5
1
2
3
4
5
6
Ese pequeño recorte de código hace lo mismo que este más largo:
List<Integer> listOfIntegers = obtainSomehow();Logger l = Logger.getLogger("Test");for (Integer i : listOfIntegers) { l.info("Integer value is : " + i);}List<Integer> listOfIntegers = obtainSomehow();Logger l = Logger.getLogger("Test");for (int aa = 0; aa < listOfIntegers.size(); aa++) { Integer I = listOfIntegers.get(aa); l.info("Integer value is : " + i);}El primer recorte usa sintaxis taquigráfico: no hay una variable de índice (aa en este caso) para inicializar y ninguna llamada al método get() de la Lista.
Debido a que la Lista extiende la java.util.Collection, que implementaIterable, usted puede usar la sintaxis taquigráfica para iterar por cualquierLista.
Un Conjunto es una construcción de colecciones que por definición contiene elementos únicos, — es decir, ningún duplicado. Mientras que una Lista puede contener el mismo objeto cientos de veces, un Conjunto solo puede contener cierta instancia una vez. Una colección de Conjunto Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.
Debido a que el Conjunto es una interfaz, usted no puede crear una instancia de él directamente, por lo tanto le mostraré una de mis implementaciones favoritas: HashSet. HashSet es fácil de usar y es similar a la Lista.
Aquí hay algunas cosas que querrá hacer con un Conjunto:
Conjunto.Conjunto cuán grande es actualmente.Conjunto.Uso de los Conjuntos
Un atributo característico de un Conjunto es que garantiza la singularidad entre sus elementos pero no le interesa el orden de los elementos. Considere el siguiente código:
1
2
3
4
5
6
7
Set<Integer> setOfIntegers = new HashSet<Integer>();setOfIntegers.add(Integer.valueOf(10));setOfIntegers.add(Integer.valueOf(11));setOfIntegers.add(Integer.valueOf(10));for (Integer i : setOfIntegers) { l.info("Integer value is: " + i);}Puede que usted espere que el Conjunto tenga tres elementos en él pero de hecho solo tiene dos porque el objeto Integer que contiene el valor 10 solo se agregará una vez.
Tenga este comportamiento en mente cuando haga la iteración por un Conjunto, como en el siguiente modo:
1
2
3
4
5
6
7
8
9
10
Set<Integer> setOfIntegers = new HashSet();setOfIntegers.add(Integer.valueOf(10));setOfIntegers.add(Integer.valueOf(20));setOfIntegers.add(Integer.valueOf(30));setOfIntegers.add(Integer.valueOf(40));setOfIntegers.add(Integer.valueOf(50));Logger l = Logger.getLogger("Test");for (Integer i : setOfIntegers) { l.info("Integer value is : " + i);}Es posible que los objetos se impriman en un orden diferente del que usted los agregó porque un Conjunto garantiza la singularidad, no el orden. Verá esto por usted mismo si pega el código anterior en el método main() de su clase Person y lo ejecuta.
Un Mapa es una construcción de colección útil porque le permite asociar un objeto (la clave) con otro (el valor). Como puede imaginar, la clave para el Mapadebe ser única y se usa para recuperar el valor en un momento posterior. Una colección de Mapa Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.
Debido a que el Mapa es una interfaz, usted no puede crear una instancia de él directamente, por lo tanto le mostraré una de mis implementaciones favoritas:HashMap.
Aquí hay algunas de las cosas que querrá hacer con los Mapas:
Mapa.Mapa.Conjunto de claves para el Mapa— para hacer la iteración en él.Uso de los Mapas
Para poner algo en un Mapa, necesita tener un objeto que represente su clave y un objeto que represente su valor:
1
2
3
4
5
6
7
8
public Map<String, Integer> createMapOfIntegers() { Map<String, Integer> mapOfIntegers = new HashMap<String, Integer>(); mapOfIntegers.put("1", Integer.valueOf(1)); mapOfIntegers.put("2", Integer.valueOf(2)); mapOfIntegers.put("3", Integer.valueOf(3)); // . . . mapOfIntegers.put("168", Integer.valueOf(168));}Es este ejemplo, el Mapa contiene Integers, con la clave hecha por una String, que resulta ser su representación de String. Para recuperar un valor Integerparticular, necesita su representación String:
1
2
mapOfIntegers = createMapOfIntegers();Integer oneHundred68 = mapOfIntegers.get("168");Uso del Conjunto con el Mapa
En ocasiones, usted puede encontrarse con una referencia a un Mapa y simplemente quiere recorrer todo el conjunto de contenidos. En este caso, necesitará un Conjunto de las claves para el Mapa:
1
2
3
4
5
6
Set<String> keys = mapOfIntegers.keySet();Logger l = Logger.getLogger("Test");for (String key : keys) { Integer value = mapOfIntegers.get(key); l.info("Value keyed by '" + key + "' is '" + value + "'");}Observe que el método toString() del Integer recuperado desde el Mapa se llama automáticamente cuando se usa en la llamada del Logger. El Mapa no devuelve una Lista de sus claves porque se hace una clave para el Mapa y cada clave es única; la singularidad es la característica distintiva de un Conjunto.