Arreglo De Objetos En Java

Este tipo de arreglo tiene la misma definición de un Arreglo de datos

Primitivos, estos difieren en la instancia que poseen, mas claramente,
estos se crean en base a una clase ya existente y definida con
sus atributos y métodoscorrespondientes, recordando: Una clase es la
definición de un objeto, ya que esta posee los atributos (características)
y funciones (métodos) que describen un objeto. La definición de
un Arreglo de Objetos es la misma que un Arreglo de datos Primitivos,
su syntaxis es de la siguiente forma:

1
clase nombreArreglo[] = new clase [numeroElementos];

El uso de este tipo de arreglos es para usar adecuadamente los

espacios de memorias reservados por un arreglo, ya que no es lo mismo
tener en un campo un valor (De un mismo tipo) que varios valores (De
diferentes tipos), pero ya que una imagen vale mas que mil palabras,
espero que con la siguiente imagen quede algo mas claro.

Como apreciamos en la anterior imagen podemos almacenar mas de

un dato en un solo campo de un arreglo, y no solo mas de un valor, sino
también del mismo tipo, supongamos que tenemos un estudiante, este
tiene un Código, Nombre, Notas (n1, n2, n3, nF); entonces, en un solo
campo podemos almacenar todos los datos de un solo estudiante (Int,
String, Double, Double, Double, Double, respectivamente).

Para almacenar datos en este tipo de arreglos es necesario crear un

Objeto para manipular la inserción de cada dato en el campo del arreglo.
Como ejemplo, mostraré como ingresar, mostrar, buscar y eliminar los
datos básicos de un Usuario de Banco (Código, nombre, apellido,
teléfono, saldo).

Ejemplo Arreglo de Objetos o Arreglo de

Clases
Para empezar crearemos nuestra clase con los datos del Usuario
(Código, nombre, apellido, teléfono, saldo) y el encapsulamiento de
estos para la manipulación:

package arrobj;

2 import java.math.BigInteger;
3
4 public class userBanc {
5 private int cod;
6 private BigInteger telefono;
7 private String nombre, apellido;
8 private Double saldo;
9
10 /**
11 * @return the cod
12 */
13 public int getCod() {
14 return cod;
15 }
16
17 /**
* @param cod the cod to set
18
*/
19 public void setCod(int cod) {
20 this.cod = cod;
21 }
22
23
24 /**
25 * @return the nombre
26 */
27 public String getNombre() {
28 return nombre;
29 }
30
31 /**
32 * @param nombre the nombre to set
33 */
34 public void setNombre(String nombre) {
35 this.nombre = nombre;
36 }
37
38 /**
* @return the apellido
39
*/
40 public String getApellido() {
41 return apellido;
42 }
43
44 /**
45 * @param apellido the apellido to set
46 */
47 public void setApellido(String apellido) {
48 this.apellido = apellido;
49 }
50
51 /**
52 * @return the saldo
53 */
54 public Double getSaldo() {
55 return saldo;
56 }
57
58 /**
* @param saldo the saldo to set
59
*/
60 public void setSaldo(Double saldo) {
61 this.saldo = saldo;
62 }
63
64 /**
65 * @return the telefono
66 */
67 public BigInteger getTelefono() {
68 return telefono;
69 }
70
71 /**
72 * @param telefono the telefono to set
73 */
74 public void setTelefono(BigInteger telefono) {
75 this.telefono = telefono;
76 }
77
78 }
79
80
81
82
Ahora la clase principal, en la cual estará el menú con las operaciones
que se pueden realizar con este tipo de arreglos:

1 package arrobj;
2
3 import java.math.BigInteger;
import javax.swing.JOptionPane;
4
5
public class ArrObj {
6
7
int contUser=0, cod=1; //variable llevar control usuarios ingresados
8
userBanc usuario [] = new userBanc[5]; //creando el arreglo de objetos (clase userBanc)
9
10
public ArrObj(){ //constructor de la clase ArrObj
11
12
String ax;
13
int op=0;
14
15
do{
16
ax = JOptionPane.showInputDialog(null, "1. Ingresar n"
17 +"2. Mostrarn"
18 +"3. Buscarn"
19 +"4. Eliminarn"
20 +"5. Salir");
21 if(ax!=null && !ax.equals("")){
22 op = Integer.parseInt(ax);
23
24 switch(op){
25 case 1:
26 ingresar();
27 break;
28 case 2:
29 mostrar();
30 break;
31 case 3:
32 buscar();
33 break;
34 case 4:
35 eliminar();
break;
36
case 5:
37 break;
38 default:
39 JOptionPane.showMessageDialog(null, "No es una opción valida!!!");
40 }
41 }
42
43 }while(op!=5);
44 }
45
46 public void ingresar(){
47
48 BigInteger telefono;
49 String nombre, apellido;
50 Double saldo;
51
52 nombre = JOptionPane.showInputDialog(null, "Ingrese el Nombre del usuario: ");
53 apellido = JOptionPane.showInputDialog(null, "Ingrese el Apellido del usuario: ");
54 telefono = new BigInteger(JOptionPane.showInputDialog(null, "Ingrese el Telefono del
55 Usuario: ")) ;
56 saldo = Double.parseDouble(JOptionPane.showInputDialog(null, "Ingrese el Saldo inicial
57 del Usuario: "));
58
59 userBanc temp = new userBanc();
60
61 temp.setCod(cod);
62 temp.setNombre(nombre);
63 temp.setApellido(apellido);
64 temp.setTelefono(telefono);
65 temp.setSaldo(saldo);
66
67 usuario[contUser] = temp;
68 contUser++;
69 cod++;
70 }
71
72 public void mostrar(){
73
74 String ay="";
75
76 for(int i=0; i<contUser; i++){
77 ay+="Codigo: "+usuario[i].getCod()+"n"
78 + "Nombre: "+usuario[i].getNombre()+"n"
79 + "Apellido: "+usuario[i].getApellido()+"n"
80 + "Telefono: "+usuario[i].getTelefono()+"n"
81 + "Saldo: "+usuario[i].getSaldo()+"nn";
82 }
83 JOptionPane.showMessageDialog(null, ay);
84 }
85
86 public void buscar(){
87
88 String ax;
89 int c;
90
91 ax = JOptionPane.showInputDialog(null, "Digite el codigo a buscar");
92 if(ax!=null && !ax.equals("")){
93 c = Integer.parseInt(ax); ax="";
94 if(contUser!=0){
95 for(int i=0; i<contUser; i++){
96 if(usuario[i].getCod() == c){
97 ax="";
98 ax+="Codigo: "+usuario[i].getCod()+"n"
99 + "Nombre: "+usuario[i].getNombre()+"n"
100 + "Apellido: "+usuario[i].getApellido()+"n"
101 + "Telefono: "+usuario[i].getTelefono()+"n"
102 + "Saldo: "+usuario[i].getSaldo()+"n";
103 break;
104 }
105 else{
106 ax="No se ha encontrado el usuario :(";
}
107
}
108
109 JOptionPane.showMessageDialog(null, ax);
110 }
111
112 }
113 }
114
115 public void eliminar(){
116 int c;
117 userBanc alumTemp[] = new userBanc[contUser-1];//creando un arreglo temporal
118 con un campo menos
119
120 c = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite el
121 codigo del estudiante a eliminar: "));//pidiendo el codigo a eliminar
122 if( c <=contUser ){ //si el codigo a eliminar es menor o igual al
contador de estudiantes
123
124
for(int i=0; i<contUser; i++){ //Inicio ciclo para realizar
125
la eliminacion
126
if(c == usuario[i].getCod()){ //si el codigo a
127 aliminar coincide con el codigo que hay en la posicion i
128 continue; //continua con el ciclo
129 }
130 else{
131 if(usuario[i].getCod() < c)
132 alumTemp[i] = usuario[i];//si esl
133 codigo es menor se almacena tal cual
134 if(usuario[i].getCod() > c){
135 usuario[i].setCod(i);//si el codigo es
136 mayor se le resta para que quede en consecutivo
137 alumTemp[i-1] = usuario[i]; //se
138 almacena con el nuevo codigo
139 }
140 }
141 } //Fin ciclo para realizar la eliminacion
142 usuario=null; cod--; contUser--; //se hacen las
modificaciones para los nuevos valores
143
usuario = new userBanc[5]; //se vuelve a crear el
144
arreglo
145
for(int i=0; i<alumTemp.length; i++){ //se almacenan los
146 valores no eliminados
147 usuario[i]=alumTemp[i];
148 }
149 }
150 else
JOptionPane.showMessageDialog(null, "El estudiante a eliminar
no existe !!!");
}

public static void main(String[] args) {

ArrObj w = new ArrObj(); //creacion del objeto w, llamado al constructor de la clase

ArrObj
System.exit(0);
}
A tener en cuenta, los métodos set* son los que asignan los valores y
los métodos get* son para obtener los valores; de la linea 57 a la 65,
podemos ver como es el proceso para asignar valores y usar cada
campo del arreglo; en el metodo eliminar, se uso una Modificación en el
Tamaño del Arreglo, para hacer el arreglo algo dinamico, y no matarnos
la cabeza con redundancia en los códigos almacenados.