lunes, 21 de octubre de 2013

Aprender a programar unsando arreglo y matrices en java





Aunque ya en entradas antiguas he publicado ejemplos con arreglos y matrices usando java,  faltó hacer un pequeño tutorial del uso de los mismo, y digo pequeño porque en Internet hay mucha información sobre éste tema y mi interés es redactar un artículo fácil de entender que te ayudará a crear una base sólida y comprender ejemplos más complejos con los que te puedas topar en el futuro.

Podemos empezar definiendo arreglos como una colección de cosas, donde ésas cosas pueden ser variables u objetos, para el caso que Java solo puedes guardar en un arreglo un tipo de variable u objeto.

Los arreglos se usan para almacenar datos y posteriormente recuperarlos fácilmente y cómodamente, por ejemplo si deseamos tener a la mano una lista de nombres de personas podemos crear un arreglo de tipo String, si queremos almacenar una lista de valores enteros podemos crear un arreglo de tipo int, si queremos tener una lista de personas podemos crear un arreglo de tipo Persona; así puedes hacer lista de botones (JButton), iconos (Icon) y cualquier cosa que necesites.

Una de las características que hay que tener en cuenta al momento que usar un arreglo es que se debe especificar la cantidad de elementos que vamos a almacenar, en otras palabras especificar su tamaño; si intentamos almacenar más de lo que puede soportar el arreglo se generará una excepción y al tiempo un error de lógica.

Figura que usaremos para representar arreglos
Hosting

Usando código, para crear una arreglo usamos la siguiente sintaxis:

<tipo_variable_u_objeto> <nombre_arreglo>[];

y para inicializar el arreglo y especificar su tamaño usamos la siguiente sintaxis:

<nombre_arreglo> = new <tipo_variable_u_objeto>[tamaño]; 

cabe aclarar que podemos crear el arreglo e inicializar al mismo tiempo así:

<tipo_variable_u_objeto> <nombre_arreglo>[] = new <tipo_variable_u_objeto>[tamaño];

Algo muy importante que  tenemos que tener en cuenta antes de pasar con los ejemplos, es que cuando inicializamos nuestro arreglo cada espacio es llenado con valores predeterminados, para el caso que nuestro arreglo sea de tipo número serán llenados con ceros (0) y sin son objetos con valores nulos (null), en la categoría de objetos se incluyen los de tipo String.

Para almacenar o acceder a las posiciones de un arreglo usamos indices que para Java inician en 0 y terminan en (tamaño_del_arreglo - 1) .

Imaginemos que necesitamos almacenar una lista de 5 números y luego mostrarlos en la pantalla, el código nos quedaría de la siguiente forma:

public class EjemploArreglo{
 public static void main(String args[]){
  int arregloDeNumeros[];//Creamos en arreglo
  int tamaño = 5;
  
  arregloDeNumeros = new int[tamaño];//Inicializamos y establecemos un tamaño
  
  //demostramos que el valor predeterminado es 0
  System.out.println("Predeterminado para la posicion 0 => " + arregloDeNumeros[0]);
  
  arregloDeNumeros[0] = 2;//Almacenando en la posicion 0
  arregloDeNumeros[1] = 54;//Almacenando en la posicion 1
  arregloDeNumeros[2] = 56;//Almacenando en la posicion 2
  arregloDeNumeros[3] = 45;//Almacenando en la posicion 3
  arregloDeNumeros[4] = 78;//Almacenando en la posicion 4
  
  System.out.println("Imprimiendo en pantalla");
  for(int i = 0;i < tamaño;i++){ //Recorremos el arreglo tantas veces con elementos tenga
   System.out.println(arregloDeNumeros[i]);
  }
 }
}




Cabe anotar que también que podemos llenar nuestro arreglo con nuestros propios valores predeterminados que es igual que decir "inicializarlo con valores de manera implícita", así:
public class EjemploArreglo{
 public static void main(String args[]){
  int arregloDeNumeros[] = {2,54,56,45,78};
  
  //De ésta forma podemos saber el tamaño de cualquier arreglo
  //Util cuando el usuario final establece el tamaño y deseamos conocerlo
  int tamaño = arregloDeNumeros.length;
  
  System.out.println("Tamaño del arreglo " + tamaño);
  
  System.out.println("Imprimiendo en pantalla");
  for(int i = 0;i < tamaño;i++){ //Recorremos el arreglo tantas veces con elementos tenga
   System.out.println(arregloDeNumeros[i]);
  }
 }
}

Lo expuesto hasta aquí es básico pero suficiente para que pruebes con otros tipos de objetos y variables distinto a numero (int), recorrer los elementos y modificarlos.

Ahora pasemos a las matrices, también llamadas tablas y más técnicamente arreglos bidimensionales; aunque suene un poco extraño una matriz es un array de array's, es decir un arreglo que contiene arreglos, para ilustrar mejor veamos la siguiente figura.

Representación de matrices
Si miramos el ejemplo anterior, tenemos una matriz de 8 filas y 8 columnas, Java vería algo así:

[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ],
[ [A][B][C][D][E][F][G][H] ]

La forma de crear, inicializar y recorrer una matriz de este tipo es:

public class EjemploArreglo{
 public static void main(String args[]){
  String matrizDeLetras[][];
  int filas = 4;
  int columnas = 3;
  matrizDeLetras = new String[filas][columnas];
  
  //String matrizDeLetras[][] = new String[4][3]; podemos crear e inicializar de una vez
  
  matrizDeLetras[0][0] = "A";
  matrizDeLetras[0][1] = "B";
  matrizDeLetras[0][2] = "C";
  
  matrizDeLetras[1][0] = "D";
  matrizDeLetras[1][1] = "E";
  matrizDeLetras[1][2] = "F";
  
  matrizDeLetras[2][0] = "G";
  matrizDeLetras[2][1] = "H";
  matrizDeLetras[2][2] = "I";
  
  matrizDeLetras[3][0] = "J";
  matrizDeLetras[3][1] = "K";
  matrizDeLetras[3][2] = "L";
  
  for(int i = 0;i < filas;i++){//El incremento de la i representa el paso por las filas
   for(int j = 0;j < columnas;j++){//El incremento de la j representa el paso por cada columna de i fila
    System.out.print(matrizDeLetras[i][j]);//Imprimimos en pantalla el valor de fila i, columna j
   }
   System.out.println();//Damos un salto de linea
  }  
 }
}




Hasta ahora lo visto aquí sobre matrices muestra que cada fila tiene un número homogéneo o iguales de columnas, a éste tipo de matrices se les denomina matrices regulares, y como te puedes imaginar existe una contraparte llamada matrices irregulares en las cuales el número de columnas por filas es distinto; usare la siguiente figura para ilustrar.

Representación de una matriz irregular
Si miramos el ejemplo anterior, tenemos una matriz de 5 filas, Java vería algo así:

[ [A] ],
[ [B][C][D] ],
[ [E][F] ],
[ [G] ],
[ [H][I][J] ]

La forma de crear, inicializar, llenar y recorrer una matriz irregular la describo en el siguiente código:

public class EjemploArreglo{
 public static void main(String args[]){
  String matrizDeLetrasIrregular[][];
  int filas = 5;
  
  matrizDeLetrasIrregular = new String[filas][];
  
  matrizDeLetrasIrregular[0] = new String[1];//Le asignamos a la fila cero, una columna
  matrizDeLetrasIrregular[1] = new String[4];//Le asignamos a la fila uno, cuatro columnas
  matrizDeLetrasIrregular[2] = new String[2];//Le asignamos a la fila dos, dos columnas
  matrizDeLetrasIrregular[3] = new String[1];//Le asignamos a la fila tres, una columna
  matrizDeLetrasIrregular[4] = new String[3];//Le asignamos a la fila cuatro, tres columnas
  
  //Llenamos la primera fila
  matrizDeLetrasIrregular[0][0] = "A";
  
  //Llenamos la segunda fila
  matrizDeLetrasIrregular[1][0] = "B";
  matrizDeLetrasIrregular[1][1] = "C";
  matrizDeLetrasIrregular[1][2] = "D";
  matrizDeLetrasIrregular[1][3] = "E";
  
  //Llenamos la tercera fila
  matrizDeLetrasIrregular[2][0] = "F";
  matrizDeLetrasIrregular[2][1] = "G";

  //Llenamos la cuarta fila
  matrizDeLetrasIrregular[3][0] = "H";

  //Llenamos la quinta fila
  matrizDeLetrasIrregular[4][0] = "I";
  matrizDeLetrasIrregular[4][1] = "J";
  matrizDeLetrasIrregular[4][2] = "K";
  
  //matrizDeLetrasIrregular.length me indica cuantas filas tiene la matriz
  for(int i = 0;i < matrizDeLetrasIrregular.length;i++){
   //matrizDeLetrasIrregular[i].length me indica cuantas columnas tiene la matriz en la fila i
   for(int j = 0;j < matrizDeLetrasIrregular[i].length;j++){
    System.out.print(matrizDeLetrasIrregular[i][j]);//Imprimimos en pantalla el valor de fila i, columna j
   }
   System.out.println();//Damos un salto de linea
  }  
 }
}

Para terminar quiero agregar que de la misma forma como recorremos las listas y matrices para imprimir sus valores en pantalla, podemos usarlo de manera similar para llenarlos.

Espero sus comentario y sugerencias.

Como siempre, esperando serles de utilidad.



domingo, 1 de septiembre de 2013

Aprendiendo a programa en Java usando BlueJ






BlueJ es una aplicación de tipo IDE bastante útil  tanto para profesores como para aprendices, a mi modo de ver nos ayuda a crear bases solidas acerca de la programación orientada a objetos, ya que en la medida que vamos programando nos va mostrando el esquema o diseño final de tu aplicación; ademas de lo dicho anteriormente, genera una buena practica del uso de comentarios en nuestro código lo cual lo hará mas fácil de entender para otro programador o incluso para nosotros mismos.

Por simplicidad, podemos suponer que el aprendiz tendrá una herramienta menos confusa y más practica para aprender a programar en java.

Hosting

La aplicación esta disponible para muchas plataformas, incluso puedes descargarlo tipo .jar, aquí les dejo el link para la descargar del ejecutable y otro con un tutorial oficial en español del mismo.


Ademas les dejo este vídeo creado por Manuel Tezozomoc Lopez Fosado que nos permite darle un vistazo de las posibilidades de BlueJ.





lunes, 26 de agosto de 2013

Ebooks gratis en español para descargar, primera parte





La Universidad Abierta de Catalunya pone a disposición documentos digitales de muy buena calidad, he leído varios y hoy quiero compartir con ustedes una lista con varios documentos en formato digital listos para ser descargados.

Espero les guste y los compartan con sus amigos.




  










Pagina 1,Pagina2



sábado, 17 de agosto de 2013

Expresiones regulares usando Java, parte I





Al programar, muchas veces nos vemos en la necesidad de validar si ciertas cadenas de textos cumplen o no con un patrón especifico, por ejemplo, saber si un texto esta compuesto en su totalidad por números, generalmente lo resolvemos de la siguiente forma:

public boolean esNumero(String cadena){
  try {
     Integer.parseInt(cadena);
     return true;
  } catch (Exception e) {
     return false;
  }
}

O tal vez así:

public boolean esNumero(String cadena){
    char numeros[] = {'1','2','3','4','5','6','7','8','9','0'};
    boolean bandera = true;
    for(char charCadena:cadena.toCharArray()){
        boolean banderaTemp = false;
        for(char charNumero:numeros){
            if(charCadena != charNumero){
            banderaTemp |= false;
        }else{
            banderaTemp |= true;
        }
    }
        bandera &= banderaTemp;
    }
    return bandera;
}

En otros casos necesitamos buscar fragmentos de textos en cadenas muchos más largas, por ejemplo, si estamos construyendo un editor de texto en java lo podemos hacer así:

public int buscarPosicionInicio(String cadenaABuscar,String cadenaDondeBuscar){
    int pos = cadenaDondeBuscar.indexOf(cadenaABuscar);
    if(pos == -1){
        System.out.println("El texto no fue encontrado");
    }
    return pos;
}

Admito que el código anterior pudo haber salido mas corto.

Para finalizar, muchas veces nos topamos con la necesitad de extraer textos o quizás remplazarlo de una cadenas más larga, estos dos últimos casos seria lo mismo, extraer un texto es equivalente a remplazarlo por una cadena vacía ("").

Los métodos que anteriormente escribí puede que sean de mucha utilidad, pero hay una técnica que nos facilita la resoluciones de problemas de este tipo y además nos agrega robustez a nuestros programas, dicha técnica hace uso de algo llamado Expresiones Regulares.

Hosting

EXPRESIONES REGULARES
En el área de la programación las expresiones regulares son un método por medio del cual se pueden realizar búsquedas dentro de cadenas de caracteres. Sin importar si la búsqueda requerida es de dos caracteres en una cadena de 10 o si es necesario encontrar todas las apariciones de un patrón definido de caracteres en un archivo de millones de caracteres, las expresiones regulares proporcionan una solución para el problema. Adicionalmente, un uso derivado de la búsqueda de patrones es la validación de un formato específico en una cadena de caracteres dada, como por ejemplo fechas o identificadores. Por Wikipedia

El uso de expresiones regulares no es nada difícil, basta con decir que en muchas ocasiones hacemos uso de ellas sin darnos cuenta, por ejemplo, si queremos referirnos a cualquier archivo de extensión jpg solemos expresarlo asi "*.jpg", si queremos buscar archivos de textos que empiecen con la letra "a" lo hacemos con la expresión "a*.txt"; lo anterior es una de las forma en que hacemos uso de las expresiones regulares en la informática, aunque poco a poco y según nuestras necesidades estas se harán más complejas, pero con práctica y dedicación lograremos comprenderlo y aplicarlo en nuestros proyectos.

Antes de empezar con ejemplos de expresiones regulares usando Java, sugiero descargar la aplicación kiki las cual esta disponible tanto para Windows como para Gnu/Linux, en mi caso particular solo hay que usar el Centro de software de Ubuntu y listo.

Captura de Kiki en acción

Anotaciones para usar kiki




Existen una seria de normas para construir de manera correcta nuestras expresiones regulares para java y estas las podemos ver recopiladas en la pagina oficial  de Oracle http://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html, aunque están en ingles al traducirla se entiende muy bien; usaremos las más usadas que nos darán bases para posteriormente abarcar las demás.

[abc] Representa un carácter que puede
ser 'a' ó 'b' ó 'c'.
[^abc] Representa cualquier carácter
excepto 'a' y 'b' y 'c'; en este caso cuando digo cualquier caracter,
no me refiero solo a letras.
[a-z] Representa el rango comprendido
de la 'a' hasta la 'z', ojo no incluye 'ñ', vocales con tildes, ni
consonantes con diéresis, en pocas palabras solo se aceptan el alfabeto
ingles.
[a-zñ] Representa el rango comprendido
de la 'a' hasta la 'z', esta vez si incluye 'ñ', ojo solo incluye a la
'ñ', si queremos incluir más caracteres los colocamos al lado de la 'ñ'.
[A-Z] Representa el rango comprendido
de la 'A' hasta la 'Z', ojo no incluye 'ñ', solo el alfabeto ingles.
[a-zA-Z] Representa el rango comprendido
de la 'a' hasta la 'z' ó 'A' hasta la 'Z',pero solo el alfabeto ingles.
[a-d[m-p]] Es equivalente a [a-dm-p],
nótese que es parecido a la expresión anterior, representa el rango
comprendido de la 'a' hasta la 'b' y 'm' hasta la 'p', es decir solo
quedan incluidas 'a','b','c','d' y 'm','n','o','p'.
[a-z&&[def]] Es equivalente a [def], es la
intersección del conjunto de la 'a' hasta la 'z' y el conjunto
'd','e','f', el resultado es el mismo conjunto 'd','e','f'; aunque se
ve innecesario esta expresión  nos ayudara a comprender la que
sigue.
[a-z&&[^def]] Representa la intersección del
conjunto de la 'a' hasta la 'z' y el conjunto todo el abecedario
excepto los caracteres 'd','e','f', el resultado es el conjunto del
abecedario excluyendo 'd','e','f'.
[a-z&&[^m-p]] Representa la intersección del
conjunto de la 'a' hasta la 'z' y el conjunto todo el abecedario
excepto los caracteres 'm','n','o','p'.

Nota: Todas la expresiones descritas anteriormente solo representan un carácter.
Ahora veamos dos caracteres más que nos ayudaran a representar expresiones más largas, '*' y el '+'; el primero representa "cero o más" mientras el segundo "uno o más"; hagamos algunos ejemplos usando java para que sea mas fácil de entender.
Usaremos el siguiente código para evaluar nuestros ejercicios, y en la practica veremos lo útil que será usar expresiones regulares.




import java.util.regex.Pattern;

public class Ejemplo {
 
    public static void main(String[] args) {
        String expresionRegular = "[abc]";
        String cadenaAEvaluar = "a";
        boolean b = Pattern.matches(expresionRegular,cadenaAEvaluar);
        if(b){
            System.out.println("La expresion SI representa la cadena a evaluar");
        }else{
            System.out.println("La expresion NO representa la cadena a evaluar");
        }      
    }
}

Donde las variables expresionRegular y cadenaAEvaluar la modificaremos según el ejercicio.

Cuando:
expresionRegular = "[abc]";
cadenaAEvaluar = "a";
El resultado sera "La expresión SI representa la cadena a evaluar"
Sin embargo usamos otras letra distintas a 'a' ó 'b' ó 'c', ó mas de un carácter en cadenaAEvaluar, nos arrogara el resultado "La expresión NO representa la cadena a evaluar".


Cuando:
expresionRegular = "[0-1]";
cadenaAEvaluar = "a";
El resultado sera "La expresión NO representa la cadena a evaluar"
Para que la cadenaAEvaluar sea correcta, debemos introducir un numero, ejemplo "2"

Como ejercicio propongo que observemos los resultados con las demás expresiones.

Continuemos, ahora cabe la pregunta, ¿y si quiero evaluar mas de un carácter?
Recordemos el método isNumero propuesto al inicio, que nos dice si una cadena es un numero, usando expresiones regulares expresionRegular seria igual a "[0-9]+" que expresa una cadena 1 ó mas caracteres compuestos por números, el método quedaría más corto:

public boolean esNumero(String cadena){
        return Pattern.matches("[0-9]+",cadena);
}

Otro ejemplo, digamos que deseamos saber si una cadena esta compuesta por un numero y una palabra en minúsculas, separada con un punto, ejemplo "12345.holamundo"

Para los números de uno o más cifras ya sabemos que es "[0-9]+", para las letras minúsculas es muy similar "[a-z]+", la expresión resultante quedara de la siguiente forma "[0-9]+.[a-z]+"


 Es decir, cuando:
 expresionRegular = "[0-9]+.[a-z]+"
 cadenaAEvaluar = "12345.holamundo";
 El resultado sera "La expresión SI representa la cadena a evaluar"

Ya puedes ver todo lo que puedes hacer?, puedes construir tu expresiones regulares para validar Email, números de celular del tipo "310-234-5678", direcciones web, etc

Aquí termino ésta primera parte, espero sus comentario para mejorar.

Y como siempre esperando serles de utilidad.



martes, 30 de abril de 2013

Llenar y eliminar filas una tabla en java.






En java una tabla es un objeto de la clase Jtable, que nos permite dibujar tablas con sus respectivas filas y columnas semejantes a una hoja de calculo.

Las operaciones básica que podemos hace una tabla son: insertar columnas, insertar filas y eliminar filas.

Una forma muy sencilla de hacer las operaciones anteriormente descritas es usando algo llamado modelo,que no es más que los datos implícitos que maneja la tabla, las operaciones o modificaciones que hagamos en el modelo, se verán reflejados (dibujados) en la tabla.

Primero creamos nuestra tabla

private JTable tabla;
//o tambien asi
private javax.swing.JTable tabla;


Luego unicializamos nuestra tabla.
tabla = JTable(); 
//o tambien asi
tabla = new javax.swing.JTable();

Creamos nuestro modelo
DefaultTableModel modelo;

Inicializamos
modelo = new DefaultTableModel();


Vinculamos nuestro modelo a la tabla
tabla.setModel(modelo);


Hosting

Listo, ahora es solo cuestión de hacer operaciones sobre nuestros datos usando nuestro modelo, empezamos por agregar las columnas que necesitaremos durante la ejecución de nuestro programa.

modelo.addColumn("Id");
modelo.addColumn("Primer nombre");
modelo.addColumn("Segundo nombre");
modelo.addColumn("Primer apellido");
modelo.addColumn("Segundo apellido");
modelo.addColumn("Sexo");
modelo.addColumn("Direccion");
modelo.addColumn("Telefono");

Para agregar filas, primero crearemos un arreglo del tipo Object para ir almacenando nuestros datos que posteriormente adjuntaremos a nuestro modelo.


Object []object = new Object[8];
object[0] = jTextFieldId.getText();
object[1] = jTextFieldPNombre.getText(); 
object[2] = jTextFieldSNombre.getText(); 
object[3] = jTextFieldPApellido.getText(); 
object[4] = jTextFieldSApellido.getText(); 
object[5] = jComboBoxSexo.getSelectedItem(); 
object[6] = jTextFieldDireccion.getText(); 
object[7] = jTextFieldTelefono.getText(); 
        
modelo.addRow(object);

Otra forma de agregar datos a nuestra tabla usando el modelo es haciendo uso del método setValueAt de nuestro modelo donde debemos conocer previamente la fila y la columna donde se insertará el dato, así:

modelo.setValueAt(dato, fila, columna);
     
Para eliminar una fila de la tabla, solo necesitamos saber por medio de su posición dentro de las demás  filas,para eso usamos el método getSelectedRow() de la clase Jtable, luego mandamos por parámetros dicha posición al método removeRow de nuestro modelo, así:

modelo.removeRow(fila);

Para finalizar sugiero que agreguen más funcionalidades al programa, como por ejemplo.
- Poder eliminar varias filas.
- No permitir campos vacíos.
- No permitir id repetidas.

No olvides dejar tus comentarios.





domingo, 17 de marzo de 2013

Lista de Objetos usando Java.





Saludos a todos.

En ésta oportunidad escribiré acerca de una aplicación muy básica pero con conceptos que nos pueden ser de mucha en el aprendizaje de la programación en Java.

La idea básica de la aplicación es construir una clase llamada Persona, que contendrá propiedades y métodos propios de una persona del mundo real, con dicha clase construiremos objetos de personas y las iremos almacenando en una lista; además realizaremos dos operaciones con la lista, agregar y eliminar.

La apariencia final de la aplicación es ésta:


Para iniciar la clase Persona tendrá las siguientes propiedades:

    private String id;
    private String primerNombre;
    private String segundoNombre;
    private String primerApellido;
    private String segundoApellido;
    private String direccion;
    private String telefono;

Además por cada propiedad tendrá dos métodos que iniciaran con las palabra inglesa 'get' o 'set' respectivamente (no es obligatorio usar éstas palabras, pero es sugerido), para el caso de la propiedad 'id' quedaría así:

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

El método getId retorna el valor de la propiedad 'id' y setId permite asignarle un valor a la propiedad 'id'; a la práctica antes descrita se le conoce como encapsulamiento y lo que persigue es que no se puedan acceder a las propiedades de la clase directamente, sino haciendo uso de métodos.

Ubiquémonos en el cuerpo del método setId y encontramos la siguiente linea:
this.id = id;



Hosting

Si observamos, podemos notar que dicho método recibe por parámetro una variable de tipo String llamada 'id', pero también tenemos una propiedad en la clase Persona con el mismo nombre; en caso de ser necesario podemos anteponer la palabra reservada this para dejar claro que hacemos referencia a la propiedad propia de la clase.

Una vez tengamos creada la clase Persona, ya podemos crear objetos de la misma, agrego que una clase no es lo mismo que un objeto; la clase en términos menos técnicos es como una plantilla que nos sirve de guía para construir objetos cada vez que los necesitemos; los objetos o también llamados instancias son una representación de los objetos del mundo real.

Para la construcción de objetos de la clase Persona usamos la palabra reservada new de la siguiente forma:

Persona persona1 = new Persona();
Persona persona2 = new Persona();
Persona persona3 = new Persona();
Persona persona4 = new Persona();

Ahora solo nos falta una lista para ir almacenando nuestras instancias, en java podemos hacerlo de muchas formas como por ejemplo:

Persona persona = new Persona();//creamos el objeto persona
ArrayList<Persona> arrayList = new ArrayList<Persona>();//creamos el objeto lista
arrayList.add(persona);//almacenamos la persona en la lista

Ademas tambien podemos usar arreglos, nos quedaría algo así:

Persona persona1 = new Persona();//creamos el objeto persona1
Persona persona2 = new Persona();//creamos el objeto persona2
Persona[] ListaPersonas = new Persona[100];//Creamos una arreglo para 100 personas
ListaPersonas[0] = persona1;//almacenamos la persona1 en la posicion 0
ListaPersonas[1] = persona2;//almacenamos la persona2 en la posicion 1





Pero no he usado ninguna de las anteriores formas para almacenas a los objetos 'persona', he preferido usar una lista del tipo DefaultListModel; la razón es que ésta lista es un modelo de otro objeto llamado Jlist que una vez los 'asociamos'  me permitirá visualizar informacion de cada persona en la lista, cada vez que agregue o elimine una persona de la lista automaticamente se verá el cambio en el Jlist, para el codigo nos quedará algo asi:

JList jListPersonas = new Jlist();//Creamos el objeto que nos visualizará las personas
DefaultListModel modelo = new DefaultListModel();//creamos la lista modelo
jListPersonas.setModel(modelo);//Asociamos la lista modelo a el objeto que nos visualizará las personas

Persona persona = new Persona();//creamos el objeto persona

persona.setId(“78076126”);//Llenamos datos con los métodos que inician con set
persona.setPrimerNombre(“rey”);
persona.setSegundoNombre(“fernando”);
persona.setPrimerApellido(“salcedo”);
persona.setSegundoApellido(“padilla”);
persona.setDireccion(“Kra 33A - #22a 17”);
persona.setTelefono(“77300000”);
        
modelo.addElement(persona);//Agregamos la persona a la lista

Reitero que los objetos de tipo persona que se agregue a la lista modelo seran visualizados automaticamente en la Gui del programa.

Algo que es de notar es el siguiente metodo de la clase Gui, donde hago uso de los métodos de la clase Persona que inician con 'get' que sirve para acceder a los valores de las propiedades de los objetos persona y que posteriormente mostraré en un JTextField.

private void llenarListaConPersona(Persona persona) {
        jTextFieldId.setText(persona.getId());
        jTextFieldPNombre.setText(persona.getPrimerNombre());
        jTextFieldSNombre.setText(persona.getSegundoNombre());
        jTextFieldPApellido.setText(persona.getPrimerApellido());
        jTextFieldSApellido.setText(persona.getSegundoApellido());
        jTextFieldDireccion.setText(persona.getDireccion());
        jTextFieldTelefono.setText(persona.getTelefono());





Sugerencias

- En la clase Persona sobreescribimos un método llamada toString que pertenece a la clase padre Object que retorna la propiedad 'id', cambie ésto de tal forma que éste método retorne el primer nombre de la persona y vea lo que pasa cuando usar el programa, investigue que pasó.

- En la clase Persona borre método toString ó meta dentro de comentario y vea lo que pasa cuando usar el programa, investigue que pasó.

- Modifique o agregue, para que el programa no permita campos vacíos.

- Modifique o agregue, para que el programa no permita id repetidas.

- Agregue un nuevo botón en la parte inferior derecha que permita eliminar a todas las personas de la lista.

Comente como resolvió las sugerencias, así podrá compartir su punto de vista y podrá observar como hicieron los demás.

Nota final; este ejemplo es solo una manera didáctica, pero al manejar grandes volúmenes de información por experiencia no sugiero ésta práctica, ya que consume muchos recursos y tendrá una aplicación lenta.





Como siempre esperando serles de utilidad.

lunes, 7 de enero de 2013

Operaciones sobre base de datos de Zoho (Reports)





Saludos,

Ya una vez hice un ejemplo de como usar la base de datos en la nube de Zoho para hacer consultas (click aqui), pero ademas de hacer consultas podemos insertar filas, modificarlar, eliminarlas y muchas cosas mas.






Toda la documentación esta disponible en sus pagina oficial (Click aqui).

Como siempre deseando serles de utilidad.




Entrada destacada

Matriz de adyacencia para un grafo

"La matriz de adyacencia es una matriz cuadrada que se utiliza como una forma de representar relaciones binarias."; aunque pa...