Cadenas y operadores
El tutorial ha presentado hasta el momento varias variables de tipo String pero sin mucha explicación. Aprenda más acerca de las cadenas en esta sección y también descubra cuándo y cómo usar los operadores.
Cadenas
El manejo de cadenas en C es un trabajo intensivo porque son matrices de finalización nula de caracteres de 8 bits que usted tiene que manipular. En el lenguaje Java, las cadenas son objetos de primera clase de tipo String, con métodos que le ayudan a manejarlas. (Lo más cerca que el código Java llega al mundo C con respecto a las cadenas es el tipo de datos primitivos char, que puede tener un solo carácter Unicode, por ejemplo a).
Ya ha visto cómo crear una instancia de un objeto String y establecer su valor (en el Listado 5) pero existen varias otras formas de hacer eso. Aquí hay un par de formas para crear una instancia String con un valor de hello:
String greeting = "hello";
greeting = new String("hello");
Debido a que las Strings son objetos de primera clase en el lenguaje Java, puede usar new para crear una instancia de ellas. Establecer una variable de tipo String tiene el mismo resultado porque el lenguaje Java crea un objeto String para tener el literal, luego asigna ese objeto a la variable de instancia.
Concatenación de cadenas
Puede hacer muchas cosas con String y la clase tiene muchos métodos útiles. Sin siquiera usar un método, ya ha hecho algo interesante con dos Strings al concatenarlas o combinarlas:
.info("Name: " + p.getName());
El signo más (+) es taquigráfico para concatenar Strings en el lenguaje Java. (Existe una sanción de rendimiento por hacer este tipo de concatenación dentro de un bucle pero por ahora no tiene que preocuparse por eso).
Ejemplo de concatenación
Intentemos concatenar Strings dentro de la clase Person. En este momento, tiene una variable de instancia de name pero sería bueno tener un firstName y un lastName. Entonces podría concatenarlas cuando otro objeto solicite el nombre completo de Person.
Lo primero que necesita hacer es agregar las nuevas variables de instancias (en la misma ubicación en el código de origen donde se define actualmente el name):
//private String name;
private String firstName;
private String lastName;
Ya no necesita el name; lo ha reemplazado con el firstName y el lastName.
Encadenamiento de llamadas de métodos
Ahora puede generar getters y setters para el firstName y el lastName (como se muestra en la Ilustración 6), eliminar el método setName() y cambiar el getName() para que se vea así:
public String getName() {
return firstName.concat(" ").concat(lastName);
}
Este código ilustra el encadenamiento de las llamadas de métodos. Esta es una técnica comúnmente usada con objetos inmutables como String, donde una modificación a un objeto inmutable siempre devuelve la modificación (pero no cambia el original). Entonces, usted opera sobre el valor cambiado de retorno.
Operadores
Como puede esperar, el lenguaje Java puede calcular y ya ha visto como asignar variables. Ahora, le daré un breve vistazo a algunos de los operadores del lenguaje Java que necesitará mientras sus aptitudes mejoran. El lenguaje Java usa dos tipos de operadores:
Unario: Solo se necesita un operando.
Binario: Se necesitan dos operandos.
Los operadores aritméticos del lenguaje Java se resumen en la Tabla 2:
Tabla 2. Operadores aritméticos del lenguaje Java
Operador Uso Descripción
+ a + b Suma a y b
+ +a Potencia a a int si es un byte, short, o char
- a - b Resta b de a
- -a Aritméticamente niega a
* a * b Multiplica a y b
/ a / b Divide a por b
% a % b Devuelve el resto de la división de a por b (el operador de módulo)
++ a++ Incrementa a por 1; calcula el valor de a antes de incrementarlo
++ ++a Incrementa a por 1; calcula el valor de a después de incrementarlo
-- a-- Disminuye a por 1; calcula el valor de a antes de disminuirlo
-- --a Disminuye a por 1; calcula el valor de a después de disminuirlo
+= a += b Taquigrafía para a = a + b
-= a -= b Taquigrafía para a = a - b
*= a *= b Taquigrafía para a = a * b
%= a %= b Taquigrafía para a = a % b
Operadores adicionales
Además de los operadores en la Tabla 2, ha visto varios otros símbolos que se llaman operadores en el lenguaje Java. Por ejemplo:
El punto (.), que califica los nombres de los paquetes e invoca métodos.
Los paréntesis (()), que delimitan una lista separada por comas de parámetros para un método.
new, que (cuando le sigue un nombre de constructor) crea una instancia de un objeto.
La sintaxis del lenguaje Java también incluye una cantidad de operadores que se usan específicamente para programación condicional, es decir, programas que responden de forma diferente en base a una entrada diferente. Los verá en la siguiente sección.
Operadores condicionales y sentencias de control
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.
Operadores relacionales y condicionales
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
Operador Uso Retorna verdadero si...
> a > b a es mayor que b
>= a >= b a es mayor que o igual a b
< a < b a es menor que b
<= a <= b a es menor que o igual a b
== a == b a es igual a b
!= a != b a no es igual a b
&& a && b Ambos a y b son verdaderos, evalúa condicionalmente a b (si a es falso, b no se evalúa)
|| a || b a o b es verdadero, evalúa condicionalmente a b (si a es verdadero, b no se evalúa)
! !a a es falso
& a & b Ambos a y b son verdaderos, siempre evalúa a b
| a | b a o b es verdadero, siempre evalúa a b
^ a ^ b a y b son diferentes
La sentencia if
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:
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.
Ámbito variable
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
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.
La sentencia else
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:
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:
if (conditional) {
// Block 1
} else if (conditional2) {
// Block 2
} else if (conditional3) {
// Block 3
} else {
// Block 4
} // End
Si 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úa conditional2. 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 operador ternario
El lenguaje Java proporciona un operador práctico para hacer simples verificaciones de sentencias
if/else.
Su sintaxis es:
if/else.
Su sintaxis es:
(conditional) ? statementIfTrue : statementIfFalse;
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:
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.
Listado 12. Una sentencia break
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.
Continuación del bucle
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
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.
Colecciones Java
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.
Matrices
La mayoría de los lenguajes de programación incluyen el concepto de una matriz para 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.
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.
Puede declarar una matriz en una de dos formas:
Crearlo con un cierto tamaño, que se fija por la vida de la matriz.
Crearlo con un cierto conjunto de valores iniciales. El tamaño de este conjunto determina el tamaño de la matriz, — será exacta y suficientemente grande para tener todos esos valores y su tamaño se fija por la vida de la matriz.
Declaración de una matriz
En general, usted declara una matriz del siguiente modo:
1
new elementType [arraySize]
Existen dos formas para crear una matriz entera de elementos. Esta sentencia crea una matriz con espacio para cinco elementos pero está vacía:
// crea una matriz vacía de 5 elementos:
int[] integers = new int[5];
Esta sentencia crea la matriz y la inicializa, todo a la vez:
// crea una matriz de 5 elementos con valores:
int[] integers = new int[] { 1, 2, 3, 4, 5 };
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:
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:
Logger l = Logger.getLogger("Test");
for (int aa = 0; aa < integers.length; aa++) {
l.info("This little integer's value is: " + integers[aa]);
}
Esta sintaxis (nueva desde el JDK 5) también funciona:
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:
1
element = arrayName [elementIndex];
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 palabra length 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 en array[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:
// 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));
Embalaje y desembalaje
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
Primitivo Homólogo JDK
booleano java.lang.Boolean
byte java.lang.Byte
caract. java.lang.Character
corto java.lang.Short
int java.lang.Integer
largo java.lang.Long
flotante java.lang.Float
doble java.lang.Double
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:
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:
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:
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 String que usted sospecha que tiene un tipo embalado en la caja misma? Las clases de envoltorio JDK tienen métodos para eso también:
String characterNumeric = "238";
Integer convertedValue = Integer.parseInt(characterNumeric);
También puede convertir los contenidos de un tipo de envoltorio JDK a String:
Integer boxedValue = Integer.valueOf(238);
String characterNumeric = boxedValue.toString();
Observe que cuando usa el operador de concatenación en una expresión de String (ya ha visto esto en las llamadas al Logger), el tipo primitivo se embala automáticamente y los tipos de envoltorio tienen automáticamente a toString() invocada sobre ellos. Muy útil.
Listas
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:
List<Object> listOfObjects = new ArrayList<Object>();
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 tipo Object, lo que significa que puede poner prácticamente lo que quiera en la Lista.
Si usted quisiera intensificar las restricciones sobre lo que pudiera o no ir en la Lista, la definiría de modo diferente:
List<Person> listOfPersons = new ArrayList<Person>();
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:
Poner algo en la Lista.
Preguntarle a la Lista cuán grande es actualmente.
Obtener algo de la 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():
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():
List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Current List size: " + listOfIntegers.size());
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("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 interfaz java.lang.Iterable. (Aprenderá acerca de las interfaces en la Part 2).
Iterable
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:
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:
List<Integer> listOfIntegers = obtainSomehow();
Logger l = Logger.getLogger("Test");
for (Integer i : listOfIntegers) {
l.info("Integer value is : " + i);
}
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 (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 implementa Iterable, usted puede usar la sintaxis taquigráfica para iterar por cualquier Lista.
Conjuntos
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:
Poner algo en el Conjunto.
Preguntarle al Conjunto cuán grande es actualmente.
Obtener algo del 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:
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:
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.
Mapas
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 Mapa debe 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:
Poner algo en el Mapa.
Obtener algo del Mapa.
Obtener un 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:
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 Integer particular, necesita su representación String:
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:
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.
Archivo del código Java
Ahora que ha aprendido un poco sobre la escritura de aplicaciones Java, puede que se esté preguntando cómo empaquetarlas para que otros desarrolladores puedan usarlas o cómo importar códigos de otros desarrolladores en sus aplicaciones. Esta sección le muestra cómo.
Uso de aplicaciones de terceros
Mientras usted se siente más y más cómodo al escribir aplicaciones Java, querrá usar más y más aplicaciones de terceros para soportar su código. A modo de ejemplo, digamos que usted quiere usar joda-time, una biblioteca de sustitución JDK para hacer manejo de fecha/tiempo, manipulaciones y cálculos.
Supongamos que ya ha descargado joda-time, que se almacena en un archivo JAR. Para usar las clases, su primer paso es crear un directorio lib en su proyecto y dejar el archivo JAR en él:
Haga clic derecho en la carpeta raíz Intro en la vista Project Explorer.
Elija New > Folder y llame la carpeta lib.
Haga clic en Finish.
La carpeta nueva aparece al mismo nivel que src. Ahora copie el archivo .jar joda-time en su nuevo directorio lib. Para este ejemplo, el archivo se llama joda-time-1.6.jar. (Al nombrar un archivo JAR es común incluir el número de la versión).
Ahora todo lo que necesita hacer es comunicarle a Eclipse que incluya las clases del archivo joda-time-1.6.jar en su proyecto:
Haga clic derecho en el proyecto Intro en su espacio de trabajo, luego seleccione Properties.
En el recuadro de diálogo de Propiedades, seleccione la pestaña de Bibliotecas, como se muestra en la Ilustración 9:
Ilustración 9. Properties > Java Build Path
Path to select the Properties dialog box and Libraries tab.
Haga clic en el botón Add External JARs, luego navegue hasta el directorio lib del proyecto, seleccione el archivo joda-time-1.6.jar y haga clic en OK.
Una vez que Eclipse haya procesado los códigos (es decir, los archivos de clases) en el archivo JAR, están disponibles para hacer referencia (importar) desde su código Java. Observe en Project Explorer que hay una carpeta nueva llamada Bibliotecas referenciadas que contiene el archivo joda-time-1.6.jar.
No hay comentarios:
Publicar un comentario