/**
 * Clase que simula a una Persona.
*/
public class Persona implements Comparable<Persona> {

   private String nombre;

   private String apellidos;

   private int edad;

   //Constructor

   public Persona(String nombre, String apellidos, int edad) {

      this.nombre = nombre;

      this.apellidos = apellidos;

      this.edad = edad;
   }



   public String getNombre() {
      return nombre;
   }

   public String getApellidos() {
      return apellidos;
   }

   public int getEdad() {
      return edad;
   }

   public void visualiza() {
      System.out.println ("Nombre: " + getNombre() + " " +  getApellidos() + " edad: " + getEdad());
   }

   @Override public String toString() {
      return "Name: " + getNombre() + " " +  getApellidos() + "; Age: " + getEdad();
   }

   /**
    * Comparamos dos personas. La que manda a llamar al metodo y la que se pasa
    * como parametro.
   */
   @Override public boolean equals(Object obj) {
      if(obj == null) return false;

      Persona p = (Persona)obj;

      return nombre.equals(p.nombre) && apellidos.equals(p.apellidos) && edad == p.edad;
   }

   /*
    * Para estructuras que usan hash es necesario implementar este metodo para
    * que puedan funcionar. Este metodo regresa un entero que sera la clave/llave
    * de nuestro objeto y, por ejemplo, para eliminar lo primero que va a comparar
    * es la clave, si existe para a usar equals para terminar de comparar el objeto.
    *
    * La idea es que las claves sean diferentes para evitar "colisiones". Las coliciones
    * son objetos con valores diferentes, pero con la misma clave.
    * Se trata de evitar la colisiones para que sigua siendo eficiente la estructura.
    * En caso de colision, los objetos con la misma clave se colocarian sobre una lista.
    *
    * La clave puede ser tan complicada como queramos o, como en este caso, todos los
    * objetos tendran como clave el 1 (uno).
   */
   @Override public int hashCode() {
      return 1;//nombre.hashCode() * apellidos.hashCode() * edad;
   }

   // Tiene el metodo compareTo porque implementa la interfaz Comparable.
   // Esto nos servira para realizar el ordenamiento y busquedas.
   @Override public int compareTo(Persona p) {
      // Podemos hacer las comparaciones con cualquiera de sus atributos.
      // En este caso lo hacemos por su nombre.
      return nombre.compareTo(p.getNombre());
      /*
      if(edad > p.edad) {
         return 1;
      } else if(edad < p.edad) {
         return -1;
      } else {
         return 0;
      }
      */
   }

   /*
   public static void main(String [] Args) {

      Persona p1 = new  Persona ("Juan", "Nadrie Garcia", 33);
      Persona p2 = new  Persona ("Pedro", "Nunes", 34);
      Persona p3 = new  Persona ("Mauro", "Ruiz perez", 36);
      Persona m1 = new Persona ("Roberto", "Gonzalez García", 33);
      Persona m2 = new Persona ("Sofia", "Nunes", 34);
      Persona m3 = new Persona ("Karla", "Ruiz Carrillo",33);


      System.out.println ("Ejemplo:");
      p1.visualiza();


      Persona [] tlist = new Persona[6];

      tlist[0] = p1;
      tlist[1] = p2;
      tlist[2] = p3;
      tlist[3] = m1;
      tlist[4] = m2;
      tlist[5] = m3;
      System.out.println ("\n\nLista:");
      for (int i = 0; i < 6; i++) {
          tlist[i].visualiza();
      }
   }
   */
}