miércoles, 10 de febrero de 2010

Ejercicio/Problema sobre Colecciones en Java (07.06.01)

En la clase pelicula agregue los métodos compareTo, equals y hashCode.
En el programa TestCartelera.java cree una lista ordenada (TreeSet) de 5 películas y muestrelas en orden alfabetico. Muestrelas en orden inverso también.
Agregue dos películas mas y muestre las películas.
Coloque las 7 peliculas en una mapa (TreeMap) el objeto pelicula será la clave y su valor será un String que almacena el nombre del cliente que lo alquila.
Revise los métodos de la clase Collections.

public class Pelicula6 {
private int codigo;
private String titulo;
private float precio;
private String tipo;
Pelicula(int codigo, String titulo, float precio, String tipo) {
...
}
...
}
public class TestCartelera {
public static void main (String[] args) {
...
}
}

Compartir:

Nuevo HashMap desde java 1.5 (07.05.03)

AgendaHashMap.java
import java.util.*;
public class AgendaHashMap
{
public static void main(String args[])
{
// Definir un HashMap
HashMap<String,String> agenda = new HashMap<String,String>();

// Agregar pares "clave"-"valor" al HashMap
agenda.put("Doctor", "(+52)-4000-5000");
agenda.put("Casa", "(888)-4500-3400");
agenda.put("Hermano", "(575)-2042-3233");
agenda.put("Tio", "(421)-1010-0020");
agenda.put("Suegros", "(334)-6105-4334");
agenda.put("Oficina", "(304)-5205-8454");
agenda.put("Abogado", "(756)-1205-3454");
agenda.put("Papa", "(55)-9555-3270");
agenda.put("Tienda", "(874)-2400-8600");

// Un nuevo loop para extraer/imprimir valores
for(String s : agenda.keySet()) {
System.out.println(s);
}
for(String s : agenda.values()) {
System.out.println(s);
}

// Definir un arreglo con valores determinados
String personas[] = {"Tio", "Suegros", "Abogado"};

// Eliminar los valores contenidos en el arreglo
for(String persona : personas) {
agenda.remove(persona);
}

// Mostrar la agenda
for (Map.Entry<String,String> telefono : agenda.entrySet()) {
System.out.println(telefono.getKey()+" = "+telefono.getValue());
}
}
}
Compartir:

Nuevo ArrayList desde java 1.5 (07.05.02)

Producto.java
public class Producto {

private String nombre;
private int cantidad;

public Producto(String s, int i) {
nombre = s;
cantidad = i;
}

public String toString(){
return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {
return this.nombre;
}
}


MercadoLista.java
import java.util.*;

public class MercadoLista
{
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto
Producto pan = new Producto("Pan", 6);
Producto leche = new Producto("Leche", 2);
Producto manzanas = new Producto("Manzanas", 5);
Producto brocoli = new Producto("Brocoli", 2);
Producto carne = new Producto("Carne", 2);

// Definir un ArrayList de Productos
ArrayList<Producto> lista = new ArrayList<Producto>();

// Colocar Instancias de Producto en ArrayList
lista.add(pan);
lista.add(leche);
lista.add(manzanas);
lista.add(brocoli);

// Las listas inician en 0 (Cero)
// Indica el indice de insercion
lista.add(1, carne);
lista.add(carne);

// Imprimir contenido de ArrayLists
System.out.println(" Lista del mercado con " + lista.size() +
" productos");

// Utilizar el for optimizado para recorrer la lista.
for ( Producto producto : lista ) {
System.out.println(producto);
}

// Eliminar elemento de ArrayList
lista.remove(2);
System.out.println(" Lista del mercado con " + lista.size() +
" productos");

// Utilizar el for optimizado para recorrer la lista.
for ( Producto producto2 : lista ) {
System.out.println(producto2);
}

// Eliminar todos los valores del ArrayList
lista.clear();
System.out.println(" Lista del mercado con " + lista.size() +
" productos");

// Nueva forma de utilizar el for para primitivas
int[] array = {1,2,4,8,16,32,64};
for (int i : array) {
System.out.println(i);
}
}
}
Compartir:

Colecciones desde java 1.5 (07.05.01)

A partir de la version 5 de java se presentan tres mejoras en el manejo de colecciones.
Genericos: Al momento de compilar se agrega la clase de la cual esta compuesta la coleccion, de tal manera que no se requiere cast para leer una coleccion que almacena elementos del mismo tipo.

Loop optimizado: Eliminando la necesidad de crear iteradores. Tambien se aplica a primitivas.

Autoboxing: Automaticamente se comvierten primitivas a objetos (int <---> Integer) tanto al almacenar como al leerlas de la coleccion.
Compartir:

TreeMap. Colecciones en Java (07.04.02)

- En un TreeMap los elementos estan ordenados por la clave
- Luego se definen dos referencias de la interfase SortedMap
- En la primera se colocan las claves que se encuentran entre A y O. Metodo submap("A", "O")
- La segunda almacena las claves desde la P hacia el final.
- Estas comparaciones se han hecho con la clase String.
- Otras clases deberán definir sus propios métodos compareTo, equals y hashCode.

AgendaTreeMap.java
import java.util.*;
public class AgendaTreeMap
{
public static void main(String args[])
{
// Definir un TreeMap
TreeMap agenda = new TreeMap();

// Agregar pares "clave"-"valor" al HashMap
agenda.put("Doctor", "(+52)-4000-5000");
agenda.put("Casa", "(888)-4500-3400");
agenda.put("Hermano", "(575)-2042-3233");
agenda.put("Tio", "(421)-1010-0020");
agenda.put("Suegros", "(334)-6105-4334");
agenda.put("Oficina", "(304)-5205-8454");
agenda.put("Abogado", "(756)-1205-3454");
agenda.put("Papa", "(55)-9555-3270");
agenda.put("Tienda", "(874)-2400-8600");

// Notese que el orden del TreeMap refleja un orden ascendente
// en sus elementos independientemente del orden de insercion.
// Debido al uso de String se refleja un orden alfabetico
mostrarMapa(agenda);

// Definir dos TreeMap nuevos
SortedMap agendaAO = agenda.subMap("A", "O");
SortedMap agendaPZ = agenda.tailMap("P");

System.out.println("---- Agenda A-O ----");
mostrarMapa(agendaAO);

System.out.println("---- Agenda P-Z ----");
mostrarMapa(agendaPZ);
}

public static void mostrarMapa(Map agenda) {
System.out.println(" Agenda con " + agenda.size() +
" telefonos");
for( Iterator it = agenda.keySet().iterator(); it.hasNext();) {
String clave = (String)it.next();
String valor = (String)agenda.get(clave);
System.out.println(clave + " : " + valor);
}
}
}
Compartir:

HashMap. Ejemplo de clases implementadas Map (07.04.01)

La clase que implementan la interfase Map es HashMap.
La clase que implementa la sub-interfase SortedMap es TreeMap.

- Se define una instancia de la clase HashMap
- Se colocan 9 pares clave-valor con el método put.
- Se muestra el contenido mediante un iterador que extrae los valores del HashMap.
- Se define un arreglo de String con tres claves para eliminar de la agenda.
- Se elimina las claves de la agenda
- el método keySet de la clase HashMap devuelve un conjunto (un objeto Set) que contiene las llaves del mapa, el cual se puede iterar.

Ejercicio: Verifique si permite duplicados

AgendaHashMap.java
import java.util.*;
public class AgendaHashMap
{
public static void main(String args[])
{
// Definir un HashMap
HashMap agenda = new HashMap();

// Agregar pares "clave"-"valor" al HashMap
agenda.put("Doctor", "(+52)-4000-5000");
agenda.put("Casa", "(888)-4500-3400");
agenda.put("Hermano", "(575)-2042-3233");
agenda.put("Tio", "(421)-1010-0020");
agenda.put("Suegros", "(334)-6105-4334");
agenda.put("Oficina", "(304)-5205-8454");
agenda.put("Abogado", "(756)-1205-3454");
agenda.put("Papa", "(55)-9555-3270");
agenda.put("Tienda", "(874)-2400-8600");

// Definir Iterator para extraer/imprimir valores
mostrarMapa(agenda);

// Definir un arreglo con valores determinados
String personas[] = {"Tio", "Suegros", "Abogado"};

// Eliminar los valores contenidos en el arreglo
for(int i = 0; i < personas.length; i++) {
agenda.remove(personas[i]);
}
mostrarMapa(agenda);
}

public static void mostrarMapa(Map agenda) {
System.out.println(" Agenda con " + agenda.size() +
" telefonos");
for( Iterator it = agenda.keySet().iterator(); it.hasNext();) {
String clave = (String)it.next();
String valor = (String)agenda.get(clave);
System.out.println(clave + " : " + valor);
}
}
}
Compartir:

Collections. Ordenar y buscar en Colecciones. (07.03.05)

- La clase Collections (que no es la interface Collection) nos permite ordenar y buscar elementos en listas.
- Se usaran los métodos sort y binarySearch
- Los objetos de la lista deben tener métodos equals, hashCode y compareTo adecuados.

MercadoCollections.java
import java.util.*;
public class MercadoCollections
{
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto
Producto pan = new Producto("Pan", 6);
Producto leche = new Producto("Leche", 2);
Producto manzanas = new Producto("Manzanas", 5);
Producto brocoli = new Producto("Brocoli", 2);
Producto carne = new Producto("Carne", 2);

// Definir un ArrayList
ArrayList lista = new ArrayList();

// Colocar Instancias de Producto en ArrayList
lista.add(pan);
lista.add(leche);
lista.add(manzanas);
lista.add(brocoli);
lista.add(1,carne);

// Imprimir contenido de ArrayList
mostrarLista(lista);

// Ordenar elemntos de ArrayList
Collections.sort(lista);

// Imprimir contenido de ArrayList
mostrarLista(lista);

// Buscar un elemento que se compare con Pan de tipo String
String buscar = "Pan";
int indice = Collections.binarySearch(lista,buscar);

System.out.println(buscar+" es el elemento "+indice);

}

public static void mostrarLista(Collection lista) {
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
int i=0;
for( Iterator it = lista.iterator(); it.hasNext(); i++) {
Producto producto = (Producto)it.next();
System.out.println(i+"-"+producto);
}
}
}


Producto.java
import java.util.*;
public class Producto implements Comparable {

private String nombre;
private int cantidad;

public Producto(String s, int i) {
nombre = s;
cantidad = i;
}

public String toString(){
return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {
return this.nombre;
}

public boolean equals( Object objeto ) {
// Indica en base a que atributos se iguala el objeto
if (objeto == null) return false;
Producto producto = (Producto)objeto;
if (this.getNombre() == producto.getNombre() ) return true;

return false;
}

public int hashCode() {
// retorna un identificador unico del objeto.
return this.getNombre().hashCode();
}

public int compareTo( Object objeto ) {
// Indica en base a que atributos se compara el objeto
// Devuelve +1 si this es > que objeto
// Devuelve -1 si this es < que objeto
// Devuelve 0 si son iguales

// Dependera del argumento como comparar los atributos.
String nombreObjeto;
if (objeto instanceof Producto ) {
Producto producto = (Producto)objeto;
nombreObjeto = producto.getNombre().toLowerCase();
}
else
if (objeto instanceof String) {
String producto = (String)objeto;
nombreObjeto = producto.toLowerCase();
}
else {
nombreObjeto = "";
}

String nombreThis = this.getNombre().toLowerCase();

return( nombreThis.compareTo( nombreObjeto ) );
}
}
Compartir:

TreeSet. Manejar colecciones ordenadas. (07.03.04)

- Primero modificamos la clase Producto implementando un comparador para el ordenamiento.
- La clase implementa Comparable
- El método compareTo de la interfase Comparable indica que atributos se usaran para comparar.

import java.util.*;
public class Producto implements Comparable {

private String nombre;
private int cantidad;

public Producto(String s, int i) {
nombre = s;
cantidad = i;
}

public String toString(){
return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {
return this.nombre;
}

public boolean equals( Object objeto ) {
// Indica en base a que atributos se iguala el objeto
if (objeto == null) return false;
Producto producto = (Producto)objeto;
if (this.getNombre().equals(producto.getNombre()) ) return true;

return false;
}

public int hashCode() {
// retorna un identificador unico del objeto.
return this.getNombre().hashCode();
}

public int compareTo( Object objeto ) {
// Indica en base a que atributos se compara el objeto
// Devuelve +1 si this es > que objeto
// Devuelve -1 si this es < que objeto
// Devuelve 0 si son iguales

Producto producto = (Producto)objeto;
String nombreObjeto = producto.getNombre().toLowerCase();
String nombreThis = this.getNombre().toLowerCase();

return( nombreThis.compareTo( nombreObjeto ) );
}
}

- Un TreeSet no permite elementos duplicados.
- Un TreeSet mantiene la lista ordenada.
- El elemento a comparar debe contar con métodos equals, hashCode y compareTo.

MercadoTreeSet.java
import java.util.*;
public class MercadoTreeSet
{
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto
Producto pan = new Producto("Pan", 6);
Producto leche = new Producto("Leche", 2);
Producto manzanas = new Producto("Manzanas", 5);
Producto brocoli = new Producto("Brocoli", 2);
Producto carne = new Producto("Carne", 2);
Producto res = new Producto("Carne", 3);

// Definir un TreeSet
TreeSet lista = new TreeSet();
lista.add(pan);
lista.add(leche);
lista.add(manzanas);
lista.add(brocoli);
lista.add(carne);
lista.add(res);

// Imprimir contenido de TreeSet
// Aunque se agregan 6 elementos, el TreeSet solo contiene 5
// TreeSet no permite elementos duplicados,
// TreeSet detecta que el elemento "Carne" esta duplicado
// Notese que el orden del TreeSet refleja un orden ascendente
mostrarLista(lista);

// No es posible eliminar elementos por indice
// Un TreeSet solo elimina por valor de Objeto
lista.remove(manzanas);
mostrarLista(lista);

// Eliminar todos los valores del TreeSet
lista.clear();
mostrarLista(lista);
}

public static void mostrarLista(Collection lista) {
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
for( Iterator it = lista.iterator(); it.hasNext();) {
Producto producto = (Producto)it.next();
System.out.println(producto);
}
}
}
Compartir:

HashSet. Evitar objetos duplicados. (07.03.03)

- Primero modificamos la clase Producto agregando dos métodos equals y hashCode
- El método equals desarrolla como se comparan dos objetos
- El método hashCode devuelve un identificador único.

Producto.java
public class Producto {

private String nombre;
private int cantidad;

public Producto(String s, int i) {
nombre = s;
cantidad = i;
}

public String toString(){
return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {
return this.nombre;
}

public boolean equals( Object objeto ) {
if (objeto == null) return false;

Producto producto = (Producto)objeto;
if (this.getNombre().equals(producto.getNombre()) )
return true;

return false;
}

public int hashCode() {
return this.getNombre().hashCode();
}

}

- Aun cuando se agregaron 6 elementos, la lista solo cuenta con 5. Set no permite duplicados.
- La evaluacion de duplicidad de objetos se realiza mediante los métodos equals y hashCode.
- Un Set no cuenta con indice, por lo que para eliminar un elemento se indica el objeto.

MercadoHashSet.java
import java.util.*;
public class MercadoHashSet
{
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto
Producto pan = new Producto("Pan", 6);
Producto leche = new Producto("Leche", 2);
Producto manzanas = new Producto("Manzanas", 5);
Producto brocoli = new Producto("Brocoli", 2);
Producto carne = new Producto("Carne", 2);
Producto res = new Producto("Carne", 3);

// Definir un HashSet
HashSet lista = new HashSet();
lista.add(pan);
lista.add(leche);
lista.add(manzanas);
lista.add(brocoli);
lista.add(carne);
lista.add(res);

// Imprimir contenido de HashSet
// Aunque son insertados 6 elementos, el HashSet solo contiene 5
// Se debe a que un Set no permite elementos duplicados.

System.out.println(" Lista del mercado con " + lista.size() +
" productos");

// Definir Iterator para extraer e imprimir valores

for( Iterator it = lista.iterator(); it.hasNext(); ) {
Object objeto = it.next();
Producto producto = (Producto)objeto;
System.out.println(producto);
}

// No es posible eliminar elementos por indice
// En un HashSet solo se elimina por valor de Objeto

lista.remove(manzanas);
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
for( Iterator it2 = lista.iterator(); it2.hasNext();) {
Producto producto = (Producto)it2.next();
System.out.println(producto);
}

// Eliminar todos los valores del ArrayList
lista.clear();
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
}
}

Compartir:

Definiendo una clase para colecciones en java (07.03.01)

Para manipular las colecciones usaremos la clase Producto compuesta por dos atributos, un constructor y un método get.

Producto.java
public class Producto {
private String nombre;
private int cantidad;
public Producto(String s, int i) {
nombre = s;
cantidad = i;
}

public String toString(){
return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {
return this.nombre;
}
}
Compartir:

La clase List (07.02.04)

Las interfases List, Set y SortedSet son descendientes de la interfase Collection
El concepto de Polimorfismo aplica para todas las clases que implementan estas interfases.
Las clases que implementan la interfase List son: ArrayList y LinkedList
Las clases que implementan la interfase Set son: HashSet y LinkedHashSet
La clase que implementa la sub-interfase SortedSet es: TreeSet.
Compartir:

Interfaces de colecciones (07.02.03)

Interface
Collection. Representa un grupo de objetos. Sin implementaciones directas, agrupa la funcionalidad general que todas las colecciones ofrecen.
Set. Colección que no puede tener objetos duplicados.
SortedSet . Set que mantiene los elementos ordenados
List. Colección ordenada que puede tener objetos duplicados
Map. Colección que enlaza claves y valores; no puede tener claves duplicadas y cada clave debe tener al menos un valor.
SortedMap. Map que mantiene las claves ordenadas.

- La interface Collection. La interfase raiz de las colecciones.
- La interface List. Colecciones ordenadas (secuencias) en las que cada elemento ocupa una posición identificada por un índice. El primer índice es el 0. Las listas admiten duplicados.
- La interface Map. Son pares de datos(clave, valor). No puede haber claves duplicadas y cada clave se corresponde con al menos un valor.
Compartir:

Arquitectura de las colecciones en Java (07.02.02)

Las interfaces y las clases están relacionadas en un armazón (framework) de colecciones para facilitar su uso.
- Interfaces de colecciones que son definiciones abstractas de los tipos de colecciones.
- Clases que implementan las interfaces.
- Clases abstractas que implementan parcialmente las interfaces.
- Métodos estáticos que son algoritmos (por ejemplo ordenar una lista).
- Interfaces de soporte para las colecciones. (una infraestructura).
Compartir:

Colecciones en Java (07.02.01)

Java provee un conjunto librerías para manipular y almacenar datos.
Estas librerías se llaman colecciones.
Las colecciones se organizan en:
- Interfaces: Manipulan los datos independientemente de los detalles de implementación.
- Clases: Implementan las interfaces.
Para programar con colecciones se debe:
- Elegir una interfaz adecuada a la funcionalidad requerida.
- Elegir una clase que implemente la interfaz
- Extender la clase si fuera necesario.

En que se diferencia una clase de una interface?
Compartir:

La Clase Object en Java (07.01.01)

Todas las clases en java heredan de la clase java.lang.Object.
Los siguientes métodos se heredan de la clase Object

boolean equals(Object obj) Indica si otro objeto es igual a otro.
int hashcode() Proporciona un valor hashcode para el objeto (id)
String toString() Proporciona una representación en cadena del objeto

Convertir primitivas en referencias (07.01.02)
Las primitivas no se comparan con null.
Las primitivas no pueden integrar una Colección.
Para cada primitiva java provee un clase para convertirlo en referencia y tratarlo como un objeto y resolver los problemas previos.

String cadena = String.valueOf(1024);
int entero = Integer.parseInt(cadena);
Integer objetoPrecio = new Integer(25);
int enteroPrecio = objetoPrecio.intValue();
String cadenaPrecio = objetoPrecio.toString();
Compartir:

miércoles, 3 de febrero de 2010

Problemas sobre ciclos/bucles DO WHILE FOR en Java (01.06.03)

1. Ejercicio
Averigüe mediante un programa si su numero de DNI es un numero primo.


2. Ejercicio
Implemente el programa MCD que en base a dos positivos, muestre el máximo común divisor entre ellos. Algoritmo de Euclides:
* datos de entrada a y b positivos
* mientras b ? 0 repetir las tres instrucciones siguientes:

r ? resto de a entre b (dar a r el valor del resto de a por b)

a ? b (el nuevo valor de a es el antiguo valor de b)

b ? r (el nuevo valor de b es el valor de r)

* el resultado es el ultimo valor de a


Ejemplo:
Se busca el máximo común divisor de a = 945 y b = 651
945 = 1×651 + 294
651 = 2×294 + 63
294 = 4×63 + 42
63 = 1×42 + 21
42 = 2×21 + 0 entonces mcd(945; 651) = 21 (el último resto no nulo).

3. Ejercicio
Cree el programa EsPerfecto que determine si un numero es perfecto. Un número es perfecto cuando es igual a la suma de todos sus divisores excepto él mismo. Por ejemplo, el número 28 es perfecto (28 = 1 + 2 + 4 +7 + 14)

4. Ejercicio
Con un programa muestre la Tabla de Pitágoras (Tabla de Multiplicar del 1 al 10).

5. Ejercicio
Con un programa muestre los números de la Criba de Eratostenes (Tabla de números primos del 1 al 150)
Compartir:

Problemas sobre IF condicionales en Java (01.06.02)

1. Ejercicio
Se tienen tres enteros positivos a, b y c. Determine si son los lados de un triangulo. Si es un triangulo clasifiquelo segun sus lados.

2. Ejercicio
Al comprar en peru.deremate.com mas de 100 DVD nos hacen un descuento de 37%, entre 25 y 100 el descuento es de 23%, entre 10 y 24 un 11%, si compras menos de 10 no hay descuento. Que importe debo pagar?

3. Ejercicio
En el bus le entregaron 9 soles en monedas. Una de ellas es falsa pues su peso es mayor. Las ocho verdaderas pesan lo mismo. Encuentre el sol falso usando dos veces una balanza.

4. Ejercicio
Realice un programa que encuentre el día de la semana correspondiente a una fecha dada por tres datos como año, mes y dia. Por ejemplo, el día de la semana para la fecha año=2004 mes=10 día=15 es martes.
Compartir:

Problemas sobre Variables en Java (01.06.01)

1. Ejercicio
Dada un cantidad en pesos, obtenga la equivalencia en dólares, asumiendo que la unidad cambiaría esta en otra variable.

2. Ejercicio
Calcule la masa del aire; si la presión, el volumen y la temperatura de una masa de aire se relacionan por la formula:
masa = (presión * volumen)/(0.37 * (temperatura + 460))

3. Ejercicio
Calcular el numero de pulsaciones que una persona debe tener por cada 10 segundos de ejercicio, si la formula es:
numero de pulsaciones = (220 - edad)/10

4. Ejercicio
Calcular el nuevo salario de un obrero si obtuvo un incremento del 25% sobre su salario anterior.
Compartir:

Sentencia Continue en Java (01.05.06)

Se usa solo en ciclos FOR.
Abandona la ejecución del cuerpo y continua a la siguiente iteración.
Mostrar todos los años bisiestos del siglo XXI.

for ( int anio=2001; anio <= 3000; anio++ ) {
if ( (anio % 100 == 0) && (anio % 400 != 0) )
continue;
if (anio % 4 == 0)
System.out.println(anio);
}
Compartir:

Sentencia Break en Java (01.05.05)

En todo bucle, la sentencia BREAK transfiere el control fuera del bucle.
Son necesarias cuando se trata de bucles infinitos.
Un empleado ha llegado a su edad de jubilación (65) y ha trabajado desde los 25 años. Su CTS se deposita en un banco que le otorga interes por estos depositos. Un nuevo gobierno ha decretado que esta liquidación tendra un maximo de 250,000 soles

while (edad <= 65) {
liquidación = (liquidación + salario)*(1+interes);
if (liquidación >= 250000)
break;
edad++;
}
Compartir:

Errores sobre Ciclos WHILE FOR en Java (01.05.04)

El transbordador espacial se encuentra a una altura de 10 Km y esta en fase de aterrizaje.

// Caso 1
int altura = 10;
while (altura > 0);
System.out.println(altura--);
System.out.println("Hemos aterrizado");// Caso 2

int altura = 10;
while (altura > 0)
System.out.println(altura);
altura--;
System.out.println("Hemos aterrizado");
// Caso 3
int altura = 10;
for (; altura > 0; altura--);
System.out.println(altura);
System.out.println("Hemos aterrizado");
Compartir:

EL CICLO FOR en Java (01.05.03)

Combina en una sentencia la definición de un ciclo repetitivo.
Para el caso del tipo de cambio, el código fuente será:

for (int i=1; i<=10; i++) {
System.out.println(i*3.5);
}

La inicialización y la iteración puede ser compuesta.

for (int i=0, j=10; i<j; i++, j--) {
System.out.println(j-i);
}

Se pueden crear bucles infinitos.

for (;;) {
System.out.println("Hola mundo!");
}
Compartir:

Ejercicios sobre Condicionales IF Java (01.04.07)

Ejercicio 1
Que es la Edad?

public class Edad {
public static void main (String [] arg)
{
int edad = 15;
if (edad <= 18)
System.out.println ("Eres un niño");
System.out.println ("La edad es un estado mental");
}
}

Ejercicio 2

Elegir la mejor Nota

public class Nota {
public static void main (String [] arg)
{
int tuNotaFinal = 17;
int miNotaFinal = 12;
int mejorNotaFinal ...

System.out.println ("La mejor nota es: " + mejorNotaFinal);
}
}


Ejercicio 3
En MegaPlaza se hace un 20% de descuento a los clientes
cuya compra supere los 300
¿Cual será la cantidad que pagara una persona por su compra?

C:\java>notepad Compra.java


public class Compra {
public static void main(String[] args) {
double compra, descuento, total;
compra = 410;
descuento = compra*0.20;
total = compra - descuento;
if (compra>300) {
System.out.println("El descuento es de: " + descuento);
System.out.println("El total a pagar es: " + total);
}
else
System.out.println("Sin descuentos, el total es:" + total);
}
}

C:\java>javac Compra.java
C:\java>java Compra
El descuento es de: 82.0
El total a pagar es: 328.0

Ejercicio 4

Un obrero necesita calcular su salario semanal, el cual se obtiene de la siguiente manera:
Si trabaja 40 horas o menos se le paga $16 por hora
Si trabaja mas de 40 horas se le paga $16 por cada una de las primeras 40 horas y $20 por cada hora extra.

C:\java>notepad Salario.java

public class Salario {
public static void main(String[] args) {
int horasTrabajadas, horasExtras, salarioSemanal;

horasTrabajadas = 47;

if ( horasTrabajadas > 40 ) {
horasExtras = horasTrabajadas - 40;
salarioSemanal = horasExtras * 20 + 40 * 16;
System.out.println("El salario con horas extras es de " +
salarioSemanal);
}
else {
salarioSemanal = horasTrabajadas * 16;
System.out.println("Su sueldo es de " + salarioSemanal);
}
}
}

Ejercicio 5
// Un año es bisiesto si es divisible por 4
// excepto aquellos divisibles por 100 pero no por 400
// Según el año determine la cantidad de dias de un mes.
//
public class Mes {
public static void main (String [] arg)
{
int anio = 1948;
int mes = 02;
int dias;
...
System.out.println ("Tiene "+dias+" dias");
}
}
Compartir:

La sentencia SWITCH en Java (01.04.06)

Es usada cuando se requiere tomar una accion entre varias en base a una expresión.
La expresión debe ser byte, char, short o int.
No puede ser un long, double, float, String o cualquiere otro tipo.
Si la expresión se iguala a una condicion, esta se ejecuta.
Si no se iguala a ninguna condicion, se realiza la sentencia marcada con default.
Las condiciones deben ser constantes.
Use break para salir del switch
Siempre coloque una opcion default.

int dia
switch (dia) {
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("Tienes que ir a trabajar");
break;
case 6:
case 7:
System.out.println("Quedate en casa");
break;
default:
System.out.println("En que planeta vives?");

}

char letra='e';
switch(letra);
{

case 'a':
case 'A':
case 'e':
case 'E':
case 'i':
case 'I':
case 'o':
case 'O':
case 'u':
case 'U':
System.out.println("Es una vocal");
break;
default: System.out.println("Es una consonante");
}
Compartir:

El operador condicional (?:) (01.04.05)

Es una alternativa a la estructura if..else

if (mes <= 7)
impuesto = 0.18;
else
impuesto = 0.19;

Es una expresión que retorna un valor.
Si la expresión logica es verdadera se obtiene el primer valor.
Si la expresión logica es falsa se obtiene el segundo valor.

impuesto = ( mes <= 7 ) ? 0.18 : 0.19;
Compartir:

Errores en condicionales IF Java. (01.04.04)

Encuentre los errores en los siguientes ejemplos.
//
int x = 3, y = 5;
if ( x >= 0)
if ( y < x )
System.out.println("y es menor que x");
else
System.out.println("x es negativo");
//
int x = 7;
if ( x = 0)
System.out.println("x es cero");
//
int x = 15, y = 24;
if ( x % 2 == 0 && y % 2 == 0 );
System.out.println("x e y son pares");

Compartir:

IF anidados. Condicionales en Java (01.04.03)

Cuando se requieren muchas condiciones, se pueden anidar sentencias IF.
Debe tener cuidado en el correcto uso de la sentencia ELSE

//
if (velocidad >= 30)
if (velocidad > 100)
System.out.println("Vamos muy rapido");
else
System.out.println("Llegaremos a tiempo.");
else
System.out.println("Que lento vamos");

//
if (velocidad >= 100)
System.out.println("Vas muy rapido");
else if (velocidad > 30)

System.out.println("Vas manejando bien.");
else
System.out.println("Vas muy lento");
//
Este enfoque es utilizado poco, ya que se crea un código algo complicado de entender.
Es preferible usar las llaves { } para separar los bloques.
if (velocidad >= 25) {
if (velocidad > 100) {
System.out.println("Vamos muy rapido!");
}
else {
System.out.println("Llegaremos a tiempo");
}
}
else {
System.out.println("Que lento es la movilidad");
}
Compartir:

IF y ELSE Condicionales en Java (01.04.02)

Esta sentencia provee una selección de procesos básico. Una expresión boleana controla que sentencia se ejecutara.
Si la expresión es true, se realizara la primera expresión es false se realizara la segunda.
La clausula else es opcional.

if ( i % 2 == 0 )
System.out.println("Es par");
else
System.out.println("Es impar");
//
if (diasDeAlquilerTranscurridos > diasAlquilerContratados )
System.out.println("Primero pagar moras por alquiler");
else
System.out.println("Puede alquilar nuevas peliculas");
//
if ( numero > 0 ) {
System.out.println("El numero es positivo");
}
//
if (mes <= 7)
System.out.println("El impuesto es 18%");
else
System.out.println("El impuesto es 19%");
Compartir:

Control de Flujo. Bloques en Java (01.04.01)

El código se ejecuta secuencialmente por defecto
Un conjunto de sentencias requieren de llaves { } para agruparse como un bloque.
El bloque entre llaves { } se conoce también como sentencia compuesta.
Una sentencia simple es una expresión que termina con punto y coma.
var1 += var2++ + 4;

Cada bloque se ejecuta como una única sentencia dentro del flujo.
{
int i = 0;
boolean termino = true;
System.out.println("i = " + i);
i++;
}
Compartir:

Ejercicios sobre Variables en Java (01.03.09)

Ejercicio 1
Encuentre los errores en el siguiente código:

1. int class = 200;
2. short texto = 43;
3. short hola mundo;
4. int boolean3 = boolean + boolean + boolean;
5. long almuerzo = entrada + sopa + segundo // falta postre
6. double viejo = 78.3;
7. doble nuevo = 0.1;
8. boolean consecuezia = true;
9. boolean maximo = 7 > 3;
10. char calle = "Via expresa";
11. char rio = 'N';
12. boolean causa = 7;
13. boolean igualdad = "true";
14. double precio = S/.20.50;
15. int uno = 3;
16. long cinco = uno + uno + uno;
17. boolean comparacion = cinco > uno;

Ejercicio 2.

/* Ejercicio:
* Se pide calcular el costo del alquiler de dos peliculas
* por dos 2 dias.
* Odisea 2001 = 2.95 por dia
* El padrino = 3.50 por dia
* Impuesto = 17%
*
* Pero solo se tiene un billete de 10.
* Se pueden alquilar?
*/

public class Operadores {

public static void main(String[] args) {
// Declaracion de variables
double pelicula1;
double pelicula2;

// Asignacion de valores
pelicula1 = 2.95;
pelicula2 = 3.50;

// Estas 4 sentencias pueden ser combinadas en una sola:
// double pelicula1 = 2.95, pelicula2 = 3.50;

// Otras variables a usar en este programa
int numeroDeDias = 2;
boolean alquilar;
double totalAlquiler, total, porcentajeImpuesto = 1.17;

// Muestra el precio de los dos peliculas
System.out.println("Odisea 2001 : " + pelicula1);
System.out.println("El Padrino : " + pelicula2);

// Calcula el alquiler total
totalAlquiler =pelicula1*numeroDeDias + pelicula2*numeroDeDias;
System.out.println("Total Alquiler = " + totalAlquiler);

// Calcula el total de la venta aplicando el impuesto
total = totalAlquiler*porcentajeImpuesto;
System.out.println("Total Venta = " + total);

// Verifica si se pueden alquilar
alquilar = total < 10;
System.out.println("Puedo Alquilar? " + alquilar);

}
}


C:\java>javac Operadores.java
C:\java>java Operadores
Odisea 2001 : 2.95
El Padrino : 3.5
Total Alquiler = 12.9
Total Venta = 15.093
Puedo Alquilar? false

Ejercicio 2.1.
/* Ejercicio:
* Prueba de tipos
*/
public class TestTipos {
public static void main(String[] args) {
// Test de cast
int b=10;
short c=5;
int a = b + c;
char mas = '+';
System.out.print(b);
System.out.print(mas);
System.out.print(c);
System.out.print('=');
System.out.println(a);
int d = 1024; // cambie 1024 por 65535
short e = (short)d;
System.out.print(d + "\t");
System.out.println(e);
long g = 2048;
double f = g;
g = (long)f;
System.out.print(f + "\t");
System.out.println(g);

long p = (long) 12345.56;
int q = (int)p; // elimine (int)
System.out.print(p + "\t");
System.out.println(q);
char t = 't'; // cambie 't' por 65535
int j = t;
short k = (short) t; // elimine (short)
System.out.println(t);
System.out.println(j);
System.out.println(k);
float r = 12.35F; //quite la F final
System.out.println(r);

// Test infinito
System.out.println(1.0/0);
System.out.println( 1/0); //comente esta linea

// Lectura de teclado
String teclado = "";
int numero=0;
try{
System.out.print("Ingrese un entero:");
java.io.BufferedReader br = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
teclado = br.readLine(); //ingrese diversos valores por teclado
numero = Integer.parseInt(teclado);
}catch(Exception ex){ ex.printStackTrace(System.out);}
System.out.println(teclado);
System.out.println(numero);
}
}
Compartir:

Precedencia de operadores Java (01.03.08)

operadores sufijo expr++ expr--
operadores unarios +expr -expr !
multiplicadores * / %
suma/resta + -
relacionales < > <= >=
igualdad == !=
AND lógico &&
OR lógico ||
condicional ? :
asignación = += -= *= /= %=

Determina el orden en el cual se ejecutan los operadores
Operadores con la misma precedencia se realizan de izquierda a derecha
Usa el paréntesis para cambiar este orden.

int var1 = 0;
var1 = 2 + 3 * 4;
var1 = 12 – 6 + 3;
Compartir:

Operadores con Cadenas Java. (01.03.07)

1. A la colección de caracteres se les llama cadenas.
2. Los datos de tipo String almacenan cadenas.
3. El operador + tambien puede encadenar dos datos de tipo String.

String nombre = "Isaac";
String apellido = "Asimov";
String nombreCompleto = nombre + apellido;
String letras = "Hola, soy una cadena";
char letrita = 'c';
Compartir:

Operadores Compuestos en Java (01.03.06)

1. La operación de asignación puede combinarse con operadores aritméticos como + y -

//
int total = 0, cantidad = 10;
total += cantidad; // asignación con incremento
total -= 3; // asignación con decremento
total *= 2; // asignación con multiplicación
//
int diasDeAlquiler;
diasDeAlquiler = diasDeAlquiler + 3;
diasDeAlquiler += 3;
//
double total = 0, num = 1;
double porcentaje = 0.50;
total = total + num;
total += num;
total -=num;
total *= porcentaje;
Compartir:

Operadores de Comparación en Java (01.03.04)

1. Son relaciones de igualdad y desigualdad.
2. Se debe diferenciar el operador de comparación con el operador de asignación

boolean valor;
int a = 1, b = 2, c = 3, d = 4, e = 3;
valor = b > a; // mayor que
valor = b >= a; // mayor igual que
valor = c < d; // menor que
valor = c <= d; // menor igual que
valor = a != d; // diferente que
valor = c == e; // igual que

int nivelBuenCredito = 3;
int nivelCreditoCliente;
boolean esBuenCredito = false;
esBuenCredito = (nivelCreditoCliente == nivelBuenCredito);
Compartir:

Operadores Incremento y Decremento en Java (01.03.03)

1. El operador ++ incrementa en 1 la variable que acompaña.
2. El operador - - decrementa en 1 la variable que acompaña.

int var1 = 3;
var1 ++;
int var1 = 3, var2 = 0;
var2 = ++var1; // Se incrementa var1 y luego se asigna a var2;
var2 = var1++; // Se asigna a var2 y luego se incrementa var2;

int nota = 17, pendientes = 10;
nota++; // es idéntico a nota = nota + 1;
pendientes--; // es idéntico a pendientes = pendientes - 1;
Compartir:

Operadores aritméticos en Java. (01.03.02)

1. Realizan las operaciones aritméticas básicas.
2. Trabajan sobre variables numéricas.


int a, b, c, d;
a = 2 + 2; // adicion
b = a * 3; // multiplicacion
c = b - 2; // substraccion
d = b / 2; // division
e = b % 2; // resto de la division (modulo)
a = a – 1;

Los datos byte, char y short se convierten en int después de una operación
Si un operando es long, el otro se convierte en long y la respuesta será long.

byte b1 = 1, b2 = 2, b3;
b3 = b1 + b2 // error el resultado es entero
Compartir:

Tipos de Variables Java (01.02.04)

1. Los principales tipos de variables son:

int Desde -2^31 hasta +2^31
long Desde -2^63 hasta +2^63
float Es un numero decimal de 32 bits.
double Es un numero decimal de 64 bits.
char Es un solo carácter, como letra o digito o carácter especial.
boolean Almacena valores de verdad como true o false.

2. Las cadenas no son un tipo de variable sino una Clase de tipo String

String Cadena de caracteres.

Declaración de Variables

1. La forma básica de declarar variables es:
tipo identificador = valor;
2. Las variables de instancia se pueden usar en cualquier lugar de la clase.
3. Las variables locales se pueden usar solo en el ámbito donde son declarados.

Ejercicio

C:\java>notepad Variables.java
public class Variables {
/* Variables instancia */
public static int peliculasAlquilados = 0;
public static void main(String[] args) {
/* Variables locales */
double tasaDeInteres = 0.15;
int peliculasEnStock = 50;
int numeroDeDias = 3;
char categoriaDePelicula = 'G';
System.out.println(peliculasAlquilados);
System.out.println(tasaDeInteres);
System.out.println(peliculasEnStock);
System.out.println(numeroDeDias);
System.out.println(categoriaDePelicula);
}
}

C:\java>javac Variables.java
C:\java>java Variables
0
0.15
50
3
G
Compartir:

martes, 2 de febrero de 2010

Nombres de Variables en Java (01.02.03)

1. Deben empezar con una letra del alfabeto ingles o subrayado.
2. Los siguientes caracteres pueden ser dígitos.
3. No se deben usar palabras reservadas.
4. Las palabras reservadas son aquellas propias del lenguaje Java como:
public, void, static, boolean, float, int, class, true, false, null, for, if, else, extends ...
5. El estándar es iniciar con minúscula y usar mayúsculas para nuevos significados.
6. Ejemplos de nombre de variables. Identifica en esta lista, nombres estandares, no estandares e incorrectos.

costo
costoItem
costoItem2
costoItemFacturado
costo_Item
_costoItem
costoItemfacturado
costoitem
costo#item
class
2costoItem
costo-item
Compartir:

Estándares de nombres en Java (01.02.02)

1. Nombres de archivos fuente: Cliente.java, Hola.java, Producto.java
2. Nombres de programas, clases: Cliente, Hola, Producto.
3. Nombres de métodos, funciones: obtenerCliente, imprimirHola, alquilarProducto.
4. Nombres de variables: nombreCliente, limiteCreditoCliente.
5. Nombres de constantes: PI, MÁXIMO_NUMERO_ITEMS, ANCHO_MINIMO.
6. Java es “case-sensitive” por lo que:
“cliente” es diferente de “Cliente” y es diferente de “CLIENTE”.
Compartir:

Declarar variables en Java (01.02.01)

Variables
1. Es una unidad básica de almacenamiento.
2. En Java debe ser declarada antes de utilizarse.
3. Cada variable tiene un tipo y un identificador.
4. Es un nombre simbólico con un valor.
5. Las variables pueden ser iniciadas.
6. La plantilla de declaración de variables es:

tipo identificador = valor;
7. Ejemplos de declaración de variables:

int miEdad = 36;
boolean estaAprobado = true;
double costoMaximo = 17.98;
Compartir:

Como ejecutar un programa Java. (01.01.05)

1. Para compilar un programa java se usa el javac.exe
C:\java>javac Hola.java
2. Para ejecutar el programa ya compilado (seudo compilado) se usa el java.exe
C:\java>java Hola
Hola desde java

3. Al ejecutar un programa java, el JVM empieza a buscar el método main de la clase principal para ejecutarlo.

4. Se debe respetar las mayúsculas y minúsculas puesto que es "case sensitive"
Compartir:

Características de un programa Java. (01.01.04)

1. El nombre de la clase debe ser igual al nombre del archivo.
2. El nombre del archivo tiene extensión java.
3. Los comentarios se colocan entre /* y */ o se inician con //
4. La clase se encierra entre { y }
5. Los métodos también se encierran entre { y }, como el método main.
6. Las sentencias (acciones) se terminan con punto y coma.
7. Se usa el punto para evocar atributos o métodos de una clase.
8. Los argumentos de los métodos se colocan entre ( y ).
9. Se usa la identación para obtener un código mas legible.

C:\java> notepad Hola.java

/* Primer programa java */

public class Hola {
public static void main(String[] args) {
System.out.println("Hola desde java");
}
}
Compartir:

Java en tu computadora/ordenador (01.01.03)

Los programas tienen extensión.java (Hola.java)
Usa el Java Developer Kit (JDK) para compilar el código fuente. (javac.exe)
Genera un compilado con extensión .class (Hola.class)
Usa el Java Virtual Machine (JVM) como interprete (java.exe)

Instalación del Java
1. Tanto el JDK como el JVM están disponibles en http://java.sun.com/ en un solo paquete conocido como J2SE.
2. En windows se puede instalar el exe por ejemplo en el directorio C:\j2sdk1.4.2
3. Adicionalmente se debe configurar la PC para que se reconozca su ubicación (Path); por ejemplo en Windows XP seria:
Mi PC/Ver informacion del Sistema/Propiedad del sistema
/Opciones Avanzadas/Variables de entorno
/Variables del sistema
/Path/Modificar
Nombre de variable=Path
Valor de la variable=;C:\j2sdk1.4.2\bin
/Aceptar/Aceptar/Aceptar

4. En Linux se debe realizar para instalarlo en un directorio como /usr/java/jdk1.3.1:
# rpm -ivh jdk-1.3.1.i386.rpm

5. Para cambiar el path debe realizar:
PATH=/usr/java/jdk1.3.1
export PATH
Compartir:

Java para aplicaciones corporativas (01.01.02)

Allí donde la red sea algo crítico, Java facilita la programación corporativa.
Desarrollo rápido de aplicaciones
Java facilita la creación de entornos de desarrollo de aplicaciones mediante el uso de frameworks y patrones.
Aplicaciones efectivas y eficientes
Las grandes empresas prefieren programas que se desarrollen rápidamente y funcionen a que lo haga eficientemente.

Portabilidad para programador y programa

La empresa es una pléyade de computadores (PC, Mac, HP, Linux, Windows,...), pero el mismo programa funcionara en cualquier estación con el mismo programador.

Costos de desarrollo
La llegada de Java e Intranet ha reducido los costos de las aplicaciones, además es creciente el software gratuito por explotar.
Compartir:

Características del lenguaje Java (01.01.01)

Simple
Reduce en un 50% los errores más comunes de programación en lenguajes como C y C++ al eliminar aritmética de punteros, referencias, necesidad de liberar memoria.

Robusto
Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de ejecución.

Arquitectura neutral
El código compilado tiene un formato independiente de la arquitectura de la máquina en que se ejecutará.

Seguro
No usa punteros para prevenir el acceso ilegal a la memoria.

Interpretado
Requiere un runtime (JRE) para ser ejecutado, lo que lo hace 10 veces mas lento que un programa C compilado.

Orientado a objetos
Soporta las tres características propias del paradigma de la orientación a objetos: encapsulamiento, herencia y polimorfismo

Distribuido
Se ha construido con extensas capacidades de interconexión TCP/IP, presenta librerías con protocolos http y ftp para obtener información a través de la red.
Compartir: