Intento explicarte visualmente el problema.
Mira, este sería el array de Clientes nada más empezar el programa:
| null | null | null | null | null | null | null | null | null | null |Son 10 posiciones que contienen objetos de la clase Cliente. Y como al principio estos objetos aún no han sido iniciados (todavía no has añadido Clientes) pues comienzan con valor null.
Para añadir Clientes hay que controlar en cual de las 10 posiciones (que van de 0 a 9) se va a registrar el nuevo Cliente. Para controlar esto, podemos usar una variable int que empiece con valor 0, ya que esa sería la primera posición disponible.
int pos = 0;
Bien, vamos a añadir el primer Cliente. Lo haremos donde nos diga la variable pos, es decir, en la posición 0.
clientes[pos] = new Cliente("Cliente_00");
| Cliente _00| null | null | null | null | null | null | null | null | null |Al añadir un cliente, incrementamos la variable pos:
pos++;
Ahora pos tiene valor 1. De este modo, pos sirve para decirnos cuantos clientes tenemos registrados (ahora mismo solo 1) y también sirve para que el programa sepa en que posición ha de registrar el próximo cliente (en la posición 1 del array).
Guau, aparentemente usando esta lógica, todo es perfecto. Sigamos añadiendo Clientes, vamos a añadir tres clientes más...
| Cliente_00 | Cliente_01 | Cliente_02 | Cliente_03 | null | null | null | null | null | null |Tras añadir tres clientes, ahora pos tendría valor 4. Es decir, tenemos 4 clientes y el próximo se ha de añadir en la posición 4.
Todo funciona de maravilla.
Pero ahora vamos a "borrar" un cliente.
Si nos piden borrar Cliente_03, no habrá problema. En su posición actual establecemos valor null y a la variable pos le restamos -1.
Para averiguar donde está el cliente llamado "CLiente_03", usamos un bucle
int buscar = 0;
for (int j = 0; j < clientes.length; j++) {
if (clientes[j].getNombre().equals("Cliente_03"))
buscar = j; //Si el nombre coincide, hemos encontrado la posición donde hay que borrar
}
clientes[buscar] = null;
pos--;
| Cliente_00 | Cliente_01 | Cliente_02 | null | null | null | null | null | null | null |Todo queda guay. Variable pos ahora tiene valor 3, porque tenemos 3 Clientes y si añadimos un cliente, ha de ir en la posición 3.
Sin problemas....
Volvamos al array con todos los clientes:
| Cliente_00 | Cliente_01 | Cliente_02 | Cliente_03 | null | null | null | null | null | null |Recordamos, aquí pos tiene valor 4
¿Y si el cliente que quieren borrar es Cliente_01?
Bueno, hacemos como antes, ¿no? Buscamos su posición, ponemos valor null y restamos -1 a pos
| Cliente_00 | null | Cliente_02 | Cliente_03 | null | null | null | null | null | null |Ahora pos tiene valor 3, porque tenemos tres clientes. Pero, aquí es donde viene el problema, si queremos insertar un nuevo cliente,
pos dice que ha de ir en la posicion 3Ouch..!!
Eso no puede ser, en la posición 3 tenemos a Cliente_03. Si añadimos un nuevo cliente, debería entrar en la posición 1, donde tenemos el valor null del cliente anterior que hemos borrado.
O en todo caso en la posición 4 que está libre....
¿Ves el problema que conlleva usar arrays? Para hacer algo como añadir y "borrar" clientes, hay que buscar una fórmula para saber bien en que posiciones se puede grabar un nuevo cliente.
Usar una variable como estaba haciendo ahora para contar los clientes que se añaden y borran, puede servir, pero tiene el inconveniente de que si se borra un cliente que no es el último existente en el array, ya no sabrá indicarnos la posición correcta donde se ha de guardar.
Esto se puede solventar de distintas formas.
Una forma sería reordenar todos los elementos cada vez que nos pidan borrar un cliente, de forma que los elementos null siempre queden al final.
Así la variable que usemos para contar, siempre apuntará a la primera posición disponible
Otra forma sería
no guiarnos por esta variable para añadir clientes, sino que antes de añadir buscamos en el array la primera posición que sea null, y ahí metemos al cliente.
for (int j = 0; j < clientes.length; j++) {
if (clientes[j] == null)
clientes[j] = new Cliente("Fulanito");
}
Esta forma es quizás más fácil, pero hay que contemplar la posibilidad de que pasa si ya no quedan posiciones null disponibles porque el array ya está lleno.
Para esto lo más fácil es de nuevo usar una variable contador como hacíamos al principio, solo que esta variable no la usaremos para decidir en que posiciones se guardan clientes.
Solo servirá para saber de formar rápida cuantos clientes tenemos en todo momento.
Porque si resulta que ya tenemos los 10 clientes, no vamos a perder el tiempo en buscar posiciones null, porque no las hay.
if (cuentaClientes == 10)
System.out.println("No caben más clientes, hay que borrar para poder añadir otro cliente");
else {
for (int j = 0; j < clientes.length; j++) {
if (clientes[j] == null)
clientes[j] = new Cliente("Fulanito");
}
cuentaClientes++; //Aumenta porque hemos añadido nuevo Cliente
}
Perdón si la explicación es demasiado extensa. Espero que se haya entendido.
Intenta tú ahora escribir el código final según tu programa actual. Si no lo consigues, intentaremos ayudarte.
Un saludo.