Lista de Contactos

Enunciado

Se quiere construir una aplicación que maneje una lista de contactos personales.

De un contacto se conoce:

- Un nombre y un apellido. La combinación del nombre y el apellido de cada contacto debe ser única, y es por defecto una palabra clave para su búsqueda. Estos campos son obligatorios para la creación de un contacto.
- Una dirección.
- Un correo electrónico.
- Un conjunto de número telefónicos.
- Un conjunto de palabras clave que se utilizan para facilitar su búsqueda.

La aplicación debe permitir:

1. Agregar un nuevo contacto.
2. Eliminar un contacto.
3. Ver la información detallada de un contacto.
4. Modificar la información de un contacto.
5. Mostrar la lista completa de contactos.
6. Buscar contactos por palabras claves.

n3 ListaDeContactos

Archivos

01 Archivo zip

02 Descripción

03 Requerimientos funcionales

Mundo

Interfaz

Pruebas

Interfaz
	InterfazListaDeContactos
	PanelBanner
	PanelContacto
	PanelLista
	PanelOpciones

Mundo
	Contacto
	ListaDeContactos

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n3_listaDeContactos
 
 * Autor: Equipo Cupi2 2017
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.listaContactos.interfaz;
 

 
import java.awt.BorderLayout;
 
import java.util.ArrayList;
 

 
import javax.swing.JFrame;
 
import javax.swing.JOptionPane;
 
import javax.swing.JPanel;
 
import javax.swing.UIManager;
 

 
import uniandes.cupi2.listaContactos.mundo.Contacto;
 
import uniandes.cupi2.listaContactos.mundo.ListaDeContactos;
 

 
/**
 
 * Ventana principal de la lista de contactos.
 
 */
 
@SuppressWarnings("serial")
 
public class InterfazListaDeContactos extends JFrame
 
{
 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 
    /**
 
     * Lista de contactos.
 
     */
 
    private ListaDeContactos lista;
 

 
    /**
 
     * Panel que contiene el banner de la aplicación.
 
     */
 
    private PanelBanner panelBanner;
 

 
    /**
 
     * Panel para desplegar la lista de contactos.
 
     */
 
    private PanelLista panelLista;
 

 
    /**
 
     * Panel para mostrar la información del contacto.
 
     */
 
    private PanelContacto panelContacto;
 

 
    /**
 
     * Panel de opciones.
 
     */
 
    private PanelOpciones panelOpciones;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Crea la ventana principal de la aplicación.
 
     */
 
    public InterfazListaDeContactos( )
 
    {
 
        setTitle( "Lista de Contactos" );
 
        setSize( 550, 700 );
 
        setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
 

 
        lista = new ListaDeContactos( );
 

 
        setLayout( new BorderLayout( ) );
 

 
        panelBanner = new PanelBanner( );
 
        panelLista = new PanelLista( this );
 
        panelContacto = new PanelContacto( this );
 
        panelOpciones = new PanelOpciones( this );
 

 
        JPanel centro = new JPanel( );
 
        centro.setLayout( new BorderLayout( ) );
 

 
        add( panelBanner, BorderLayout.NORTH );
 
        add( centro, BorderLayout.CENTER );
 
        centro.add( panelLista, BorderLayout.NORTH );
 
        centro.add( panelContacto, BorderLayout.CENTER );
 
        add( panelOpciones, BorderLayout.SOUTH );
 

 
        setLocationRelativeTo( null );
 
        setResizable( false );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Retorna la lista de los nombres de todos los contactos.
 
     * @return Lista con nombres y apellidos de todos los contactos.
 
     */
 
    public ArrayList<String> darContactos( )
 
    {
 
        return lista.darTodosLosContactos( );
 
    }
 

 
    /**
 
     * Muestra la información del contacto seleccionado.
 
     */
 
    public void visualizarContacto( )
 
    {
 
        String nombre = panelLista.darNombreSeleccionado( );
 
        String apellido = panelLista.darApellidoSeleccionado( );
 
        if( nombre == null )
 
        {
 
            JOptionPane.showMessageDialog( this, "No ha seleccionado ningún contacto", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
        }
 
        else
 
        {
 
            Contacto c = lista.buscarContacto( nombre, apellido );
 
            if( c != null )
 
            {
 
                panelContacto.mostrarContacto( c );
 
            }
 
            else
 
            {
 
                JOptionPane.showMessageDialog( this, "El contacto no existe", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
            }
 
        }
 
    }
 

 
    /**
 
     * Elimina el contacto seleccionado. <br>
 
     * <b>post: </b> Si el contacto existe, se elimina el contacto de la lista.
 
     */
 
    public void eliminarContacto( )
 
    {
 
        String nombre = panelLista.darNombreSeleccionado( );
 
        String apellido = panelLista.darApellidoSeleccionado( );
 
        if( nombre == null )
 
        {
 
            JOptionPane.showMessageDialog( this, "No ha seleccionado ningún contacto", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
        }
 
        else
 
        {
 
            boolean accion = lista.eliminarContacto( nombre, apellido );
 

 
            if( accion )
 
            {
 
                panelLista.actualizarLista( lista.darTodosLosContactos( ) );
 
                panelContacto.limpiarCampos( );
 
            }
 
            else
 
            {
 
                JOptionPane.showMessageDialog( this, "No se puede eliminar el contacto", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
            }
 
        }
 
    }
 

 
    /**
 
     * Busca y despliega todos los contactos encontrados por una palabra clave.
 
     */
 
    public void buscarContactosPalabra( )
 
    {
 
        String palabra = JOptionPane.showInputDialog( this, "Escriba la palabra clave a buscar", "Lista de Contactos", JOptionPane.PLAIN_MESSAGE );
 
        if( palabra != null )
 
        {
 
            if( palabra.equals( "" ) )
 
            {
 
                JOptionPane.showMessageDialog( this, "Debe ingresar una palabra clave", "Lista de Contactos", JOptionPane.INFORMATION_MESSAGE );
 
            }
 
            else
 
            {
 
                ArrayList<String> listaC = lista.buscarContactosPalabraClave( palabra );
 
                if( listaC.size( ) == 0 )
 
                {
 
                    JOptionPane.showMessageDialog( this, "No se encontraron contactos con esa palabra clave", "Lista de Contactos", JOptionPane.INFORMATION_MESSAGE );
 
                }
 
                else
 
                {
 
                    panelLista.actualizarLista( listaC );
 
                }
 
            }
 
        }
 
    }
 

 
    /**
 
     * Agrega un nuevo contacto a la lista, si no existe otro contacto con los mismos nombres y apellidos. <br>
 
     * <b>post: </b> Se agrega un nuevo contacto a la lista en caso de que éste no exista aún en ella.
 
     */
 
    public void agregarContacto( )
 
    {
 
        String nombre = panelContacto.darNombre( );
 
        String apellido = panelContacto.darApellido( );
 
        if( nombre.equals( "" ) || apellido.equals( "" ) )
 
        {
 
            JOptionPane.showMessageDialog( this, "El nombre y el apellido del contacto son requeridos", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
        }
 
        else
 
        {
 
            String direccion = panelContacto.darDirección( );
 
            String correo = panelContacto.darCorreo( );
 
            ArrayList<String> palabras = panelContacto.darPalabras( );
 
            ArrayList<String> telefonos = panelContacto.darTelefonos( );
 

 
            boolean accion = lista.agregarContacto( nombre, apellido, direccion, correo, telefonos, palabras );
 
            if( !accion )
 
            {
 
                JOptionPane.showMessageDialog( this, "Ya existe un contacto con el mismo nombre y apellido", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
            }
 
            else
 
            {
 
                panelLista.actualizarLista( lista.darTodosLosContactos( ) );
 
                panelContacto.limpiarCampos( );
 
            }
 
        }
 

 
    }
 

 
    /**
 
     * Modifica los datos de un contacto a la lista, excepto el nombre y el apellido. <br>
 
     * <b>post: </b> Se actualizan los datos del contacto si existe.
 
     */
 
    public void modificarContacto( )
 
    {
 
        String nombre = panelContacto.darNombre( );
 
        String apellido = panelContacto.darApellido( );
 
        if( nombre.equals( "" ) || apellido.equals( "" ) )
 
        {
 
            JOptionPane.showMessageDialog( this, "El nombre y el apellido del contacto son requeridos", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
        }
 
        else
 
        {
 
            String direccion = panelContacto.darDirección( );
 
            String correo = panelContacto.darCorreo( );
 
            ArrayList<String> palabras = panelContacto.darPalabras( );
 
            ArrayList<String> telefonos = panelContacto.darTelefonos( );
 

 
            boolean accion = lista.modificarContacto( nombre, apellido, direccion, correo, telefonos, palabras );
 
            if( !accion )
 
            {
 
                JOptionPane.showMessageDialog( this, "El contacto no existe. Verifique el nombre y apellido", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
            }
 
            else
 
            {
 
                panelLista.actualizarLista( lista.darTodosLosContactos( ) );
 
                panelContacto.limpiarCampos( );
 
            }
 
        }
 

 
    }
 

 
    // -----------------------------------------------------------------
 
    // Puntos de Extensión
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Llamado al metodo1 del mundo para realizar la extensión 1. <br>
 
     * <b>post: </b> Se retorna el valor de la operación 1 y se muestra en pantalla.
 
     */
 
    public void reqFuncOpcion1( )
 
    {
 
        String respuesta = lista.metodo1( );
 
        JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
 
    }
 

 
    /**
 
     * Llamado al metodo2 del mundo para realizar la extensión 2. <br>
 
     * <b>post: </b> Se retorna el valor de la operación 2 y se muestra en pantalla.
 
     */
 
    public void reqFuncOpcion2( )
 
    {
 
        String respuesta = lista.metodo2( );
 
        JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Main
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Ejecuta la aplicación.
 
     * @param pArgs Parámetros de la ejecución. No son necesarios.
 
     */
 
    public static void main( String[] pArgs )
 
    {
 
        try
 
        {
 
            // Unifica la interfaz para Mac y para Windows.
 
            UIManager.setLookAndFeel( UIManager.getCrossPlatformLookAndFeelClassName( ) );
 

 
            InterfazListaDeContactos interfaz = new InterfazListaDeContactos( );
 
            interfaz.setVisible( true );
 
        }
 
        catch( Exception e )
 
        {
 
            e.printStackTrace( );
 
        }
 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n3_listaDeContactos
 
 * Autor: Equipo Cupi2 2017
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.listaContactos.interfaz;
 

 
import java.awt.BorderLayout;
 
import java.awt.Dimension;
 
import java.awt.GridLayout;
 
import java.awt.event.ActionEvent;
 
import java.awt.event.ActionListener;
 
import java.util.ArrayList;
 

 
import javax.swing.BorderFactory;
 
import javax.swing.DefaultListModel;
 
import javax.swing.JButton;
 
import javax.swing.JLabel;
 
import javax.swing.JList;
 
import javax.swing.JOptionPane;
 
import javax.swing.JPanel;
 
import javax.swing.JScrollPane;
 
import javax.swing.JTextField;
 
import javax.swing.border.TitledBorder;
 

 
import uniandes.cupi2.listaContactos.mundo.Contacto;
 

 
/**
 
 * Panel para visualizar los datos de un contacto seleccionado.
 
 */
 
@SuppressWarnings("serial")
 
public class PanelContacto extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Constante usada para indicar que se quiere limpiar la pantalla.
 
     */
 
    private final static String LIMPIAR = "LIMPIAR";
 

 
    /**
 
     * Constante usada para indicar que se quiere agregar el contacto.
 
     */
 
    private final static String AGREGAR = "AGREGAR";
 

 
    /**
 
     * Constante usada para indicar que se quiere modificar el contacto.
 
     */
 
    private final static String MODIFICAR = "MODIFICAR";
 

 
    /**
 
     * Constante usada para indicar que se quiere agregar un teléfono a la lista.
 
     */
 
    private final static String AGREGAR_TELEFONO = "AGREGAR_TELEFONO";
 

 
    /**
 
     * Constante usada para indicar que se quiere eliminar un teléfono de la lista.
 
     */
 
    private final static String ELIMINAR_TELEFONO = "ELIMINAR_TELEFONO";
 

 
    /**
 
     * Constante usada para indicar que se quiere agregar una palabra a la lista.
 
     */
 
    private final static String AGREGAR_PALABRA = "AGREGAR_PALABRA";
 

 
    /**
 
     * Constante usada para indicar que se quiere eliminar una palabra de la lista.
 
     */
 
    private final static String ELIMINAR_PALABRA = "ELIMINAR_PALABRA";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * La ventana principal de la aplicación.
 
     */
 
    private InterfazListaDeContactos principal;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de Interfaz
 
    // -----------------------------------------------------------------
 

 
    private JLabel lblNombre;
 
    private JLabel lblApellido;
 
    private JLabel lblDireccion;
 
    private JLabel lblCorreo;
 

 
    private JTextField txtNombre;
 
    private JTextField txtApellido;
 
    private JTextField txtDireccion;
 
    private JTextField txtCorreo;
 

 
    private JList<String> listaTelefonos;
 
    private JList<String> listaPalabras;
 

 
    private JButton btnLimpiar;
 
    private JButton btnAgregar;
 
    private JButton btnModificar;
 

 
    private JButton btnAgregaPalabra;
 
    private JButton btnEliminaPalabra;
 
    private JButton btnAgregaTelefono;
 
    private JButton btnEliminaTelefono;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Crea el panel para visualizar, modificar y crear contactos nuevos.
 
     * @param pPrincipal Ventana principal de la aplicación. pPrincipal != null.
 
     */
 
    public PanelContacto( InterfazListaDeContactos pPrincipal )
 
    {
 
        principal = pPrincipal;
 
        setLayout( new BorderLayout( ) );
 
        setBorder( new TitledBorder( "Datos Personales del Contacto" ) );
 

 
        // Inicializa y organiza los elementos de datos principales del contacto
 
        organizarDatos( );
 

 
        // Inicializa y organiza los elementos de los botones del panel
 
        organizarBotones( );
 

 
        // Organiza e inicializa las listas de teléfonos y palabras clave del
 
        // contacto
 
        organizarListas( );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Inicializa y organiza los elementos de los botones del panel.
 
     */
 
    private void organizarBotones( )
 
    {
 
        JPanel panelBotones = new JPanel( );
 

 
        btnAgregar = new JButton( );
 
        btnAgregar.setText( "Agregar Contacto" );
 
        btnAgregar.setActionCommand( AGREGAR );
 
        btnAgregar.addActionListener( this );
 

 
        btnModificar = new JButton( );
 
        btnModificar.setText( "Modificar Contacto" );
 
        btnModificar.setActionCommand( MODIFICAR );
 
        btnModificar.addActionListener( this );
 

 
        btnLimpiar = new JButton( );
 
        btnLimpiar.setText( "Limpiar" );
 
        btnLimpiar.setActionCommand( LIMPIAR );
 
        btnLimpiar.addActionListener( this );
 

 
        panelBotones.add( btnAgregar );
 

 
        // Agregar espacios vacios entre los botones
 
        panelBotones.add( btnModificar );
 
        panelBotones.add( btnLimpiar );
 

 
        add( panelBotones, BorderLayout.SOUTH );
 
    }
 

 
    /**
 
     * Inicializa y organiza los elementos de los datos principales del contacto.
 
     */
 
    private void organizarDatos( )
 
    {
 
        JPanel panelDatos = new JPanel( );
 
        panelDatos.setBorder( BorderFactory.createEmptyBorder( 20, 5, 20, 5 ) );
 
        panelDatos.setLayout( new GridLayout( 4, 2, 1, 10 ) );
 

 
        lblNombre = new JLabel( "Nombre" );
 
        lblApellido = new JLabel( "Apellido" );
 
        lblDireccion = new JLabel( "Dirección" );
 
        lblCorreo = new JLabel( "Correo Electrónico" );
 

 
        txtNombre = new JTextField( 10 );
 
        txtApellido = new JTextField( 10 );
 
        txtDireccion = new JTextField( 10 );
 
        txtCorreo = new JTextField( 10 );
 

 
        panelDatos.add( lblNombre );
 
        panelDatos.add( txtNombre );
 
        panelDatos.add( lblApellido );
 
        panelDatos.add( txtApellido );
 
        panelDatos.add( lblDireccion );
 
        panelDatos.add( txtDireccion );
 
        panelDatos.add( lblCorreo );
 
        panelDatos.add( txtCorreo );
 

 
        add( panelDatos, BorderLayout.CENTER );
 
    }
 

 
    /**
 
     * Organiza e inicializa la lista de teléfonos del contacto.
 
     */
 
    private void organizarListas( )
 
    {
 
        // Lista de teléfonos
 

 
        JPanel panelTelefonos = new JPanel( );
 
        panelTelefonos.setLayout( new BorderLayout( ) );
 
        panelTelefonos.setBorder( new TitledBorder( "Teléfonos" ) );
 

 
        JScrollPane deslizableTelefonos = new JScrollPane( );
 
        listaTelefonos = new JList<String>( );
 
        deslizableTelefonos.setPreferredSize( new Dimension( 150, 0 ) );
 
        deslizableTelefonos.setViewportView( listaTelefonos );
 
        deslizableTelefonos.setVerticalScrollBarPolicy( javax.swing.JScrollPane.VERTICAL_SCROLLBAR_ALWAYS );
 
        deslizableTelefonos.setHorizontalScrollBarPolicy( javax.swing.JScrollPane.HORIZONTAL_SCROLLBAR_NEVER );
 
        listaTelefonos.setModel( new DefaultListModel<String>( ) );
 

 
        btnAgregaTelefono = new JButton( "Agregar" );
 
        btnAgregaTelefono.setActionCommand( AGREGAR_TELEFONO );
 
        btnAgregaTelefono.addActionListener( this );
 

 
        btnEliminaTelefono = new JButton( "Eliminar" );
 
        btnEliminaTelefono.setActionCommand( ELIMINAR_TELEFONO );
 
        btnEliminaTelefono.addActionListener( this );
 

 
        JPanel panBotTelefonos = new JPanel( new GridLayout( 3, 1 ) );
 
        panBotTelefonos.add( btnAgregaTelefono );
 
        panBotTelefonos.add( new JLabel( ) );
 
        panBotTelefonos.add( btnEliminaTelefono );
 

 
        panelTelefonos.add( deslizableTelefonos, BorderLayout.CENTER );
 
        panelTelefonos.add( panBotTelefonos, BorderLayout.EAST );
 

 
        // Lista de palabras
 

 
        JPanel panelPalabras = new JPanel( );
 
        panelPalabras.setLayout( new BorderLayout( ) );
 
        panelPalabras.setBorder( new TitledBorder( "Palabras Clave" ) );
 

 
        JScrollPane deslizablePalabras = new JScrollPane( );
 
        listaPalabras = new JList<String>( );
 
        deslizablePalabras.setPreferredSize( new Dimension( 150, 0 ) );
 
        deslizablePalabras.setViewportView( listaPalabras );
 
        deslizablePalabras.setVerticalScrollBarPolicy( javax.swing.JScrollPane.VERTICAL_SCROLLBAR_ALWAYS );
 
        deslizablePalabras.setHorizontalScrollBarPolicy( javax.swing.JScrollPane.HORIZONTAL_SCROLLBAR_NEVER );
 
        listaPalabras.setModel( new DefaultListModel<String>( ) );
 

 
        btnAgregaPalabra = new JButton( "Agregar" );
 
        btnAgregaPalabra.setActionCommand( AGREGAR_PALABRA );
 
        btnAgregaPalabra.addActionListener( this );
 

 
        btnEliminaPalabra = new JButton( "Eliminar" );
 
        btnEliminaPalabra.setActionCommand( ELIMINAR_PALABRA );
 
        btnEliminaPalabra.addActionListener( this );
 

 
        JPanel panBotPalabras = new JPanel( new GridLayout( 3, 1 ) );
 
        panBotPalabras.add( btnAgregaPalabra );
 
        panBotPalabras.add( new JLabel( ) );
 
        panBotPalabras.add( btnEliminaPalabra );
 

 
        panelPalabras.add( deslizablePalabras, BorderLayout.CENTER );
 
        panelPalabras.add( panBotPalabras, BorderLayout.EAST );
 

 
        JPanel panelListas = new JPanel( new GridLayout( 2, 1 ) );
 
        panelListas.add( panelTelefonos );
 
        panelListas.add( panelPalabras );
 

 
        add( panelListas, BorderLayout.EAST );
 
    }
 

 
    /**
 
     * Retorna el nombre del formulario.
 
     * @return Nombre.
 
     */
 
    public String darNombre( )
 
    {
 
        return txtNombre.getText( ).trim( );
 
    }
 
    /**
 
     * Retorna el apellido del formulario.
 
     * @return Apellido.
 
     */
 
    public String darApellido( )
 
    {
 
        return txtApellido.getText( ).trim( );
 
    }
 
    /**
 
     * Retorna la dirección del formulario.
 
     * @return Dirección.
 
     */
 
    public String darDirección( )
 
    {
 
        return txtDireccion.getText( ).trim( );
 
    }
 
    /**
 
     * Retorna el correo del formulario.
 
     * @return Correo.
 
     */
 
    public String darCorreo( )
 
    {
 
        return txtCorreo.getText( ).trim( );
 
    }
 
    /**
 
     * Retorna la lista de palabras del contacto.
 
     * @return La lista de palabras.
 
     */
 
    public ArrayList<String> darPalabras( )
 
    {
 
        int contador = 0;
 
        ArrayList<String> palabras = new ArrayList<String>( );
 
        while( contador < listaPalabras.getModel( ).getSize( ) )
 
        {
 
            palabras.add( listaPalabras.getModel( ).getElementAt( contador ) );
 
            contador++;
 
        }
 
        return palabras;
 
    }
 

 
    /**
 
     * Retorna la lista de teléfonos del contacto.
 
     * @return La lista de teléfonos.
 
     */
 
    public ArrayList<String> darTelefonos( )
 
    {
 
        int contador = 0;
 
        ArrayList<String> telfs = new ArrayList<String>( );
 
        while( contador < listaTelefonos.getModel( ).getSize( ) )
 
        {
 
            telfs.add( listaTelefonos.getModel( ).getElementAt( contador ) );
 
            contador++;
 
        }
 
        return telfs;
 
    }
 

 
    /**
 
     * Limpia los campos del panel.
 
     */
 
    public void limpiarCampos( )
 
    {
 
        listaTelefonos.setModel( new DefaultListModel<String>( ) );
 
        listaPalabras.setModel( new DefaultListModel<String>( ) );
 
        txtNombre.setText( "" );
 
        txtApellido.setText( "" );
 
        txtDireccion.setText( "" );
 
        txtCorreo.setText( "" );
 
    }
 

 
    /**
 
     * Agrega un teléfono a la lista.
 
     */
 
    private void agregarTelefono( )
 
    {
 
        String telefono = JOptionPane.showInputDialog( this, "Escriba el nuevo teléfono", "Nuevo Teléfono", JOptionPane.PLAIN_MESSAGE );
 

 
        DefaultListModel<String> dlf = new DefaultListModel<String>( );
 
        int contador = 0;
 
        while( contador < listaTelefonos.getModel( ).getSize( ) )
 
        {
 
            dlf.addElement( listaTelefonos.getModel( ).getElementAt( contador ) );
 
            contador++;
 
        }
 
        dlf.addElement( telefono );
 
        listaTelefonos.setModel( dlf );
 

 
    }
 

 
    /**
 
     * Agrega una nueva palabra a la lista.
 
     */
 
    private void agregarPalabra( )
 
    {
 
        String palabra = JOptionPane.showInputDialog( this, "Escriba la nueva palabra clave", "Nueva Palabra", JOptionPane.PLAIN_MESSAGE );
 
        DefaultListModel<String> dlf = new DefaultListModel<String>( );
 
        int contador = 0;
 
        while( contador < listaPalabras.getModel( ).getSize( ) )
 
        {
 
            dlf.addElement( listaPalabras.getModel( ).getElementAt( contador ) );
 
            contador++;
 
        }
 
        dlf.addElement( palabra );
 
        listaPalabras.setModel( dlf );
 
    }
 

 
    /**
 
     * Elimina un teléfono de la lista.
 
     */
 
    private void eliminarTelefono( )
 
    {
 
        String telefono = ( String )listaTelefonos.getSelectedValue( );
 
        if( telefono == null )
 
        {
 
            JOptionPane.showMessageDialog( this, "Debe seleccionar un teléfono", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
        }
 
        else
 
        {
 
            DefaultListModel<String> dlf = new DefaultListModel<String>( );
 
            int contador = 0;
 
            while( contador < listaTelefonos.getModel( ).getSize( ) )
 
            {
 
                String elemento = ( String )listaTelefonos.getModel( ).getElementAt( contador );
 
                if( !elemento.equals( telefono ) )
 
                {
 
                    dlf.addElement( listaTelefonos.getModel( ).getElementAt( contador ) );
 
                }
 
                contador++;
 
            }
 
            listaTelefonos.setModel( dlf );
 
        }
 
    }
 

 
    /**
 
     * Elimina una palabra de la lista.
 
     */
 
    private void eliminarPalabra( )
 
    {
 
        String palabra = ( String )listaPalabras.getSelectedValue( );
 
        if( palabra == null )
 
        {
 
            JOptionPane.showMessageDialog( this, "Debe seleccionar una palabra", "Lista de Contactos", JOptionPane.ERROR_MESSAGE );
 
        }
 
        else
 
        {
 
            DefaultListModel<String> dlf = new DefaultListModel<String>( );
 
            int contador = 0;
 
            while( contador < listaPalabras.getModel( ).getSize( ) )
 
            {
 
                String elemento = ( String )listaPalabras.getModel( ).getElementAt( contador );
 
                if( !elemento.equals( palabra ) )
 
                {
 
                    dlf.addElement( listaPalabras.getModel( ).getElementAt( contador ) );
 
                }
 
                contador++;
 
            }
 
            listaPalabras.setModel( dlf );
 
        }
 
    }
 

 
    /**
 
     * Actualiza la lista de teléfonos con los elementos del arrayList.
 
     * @param lista La nueva lista de teléfonos para mostrar.
 
     */
 
    private void actualizarListaTelefonos( ArrayList<String> pLista )
 
    {
 
        DefaultListModel<String> dlf = new DefaultListModel<String>( );
 

 
        int contador = 0;
 
        while( contador < pLista.size( ) )
 
        {
 
            String tel = ( String )pLista.get( contador );
 
            dlf.addElement( tel );
 
            contador++;
 
        }
 

 
        listaTelefonos.setModel( dlf );
 

 
    }
 

 
    /**
 
     * Actualiza la lista de palabras con los elementos del arrayList.
 
     * @param lista La nueva lista de palabras para mostrar.
 
     */
 
    private void actualizarListaPalabras( ArrayList<String> pLista )
 
    {
 
        DefaultListModel<String> dlf = new DefaultListModel<String>( );
 

 
        int contador = 0;
 
        while( contador < pLista.size( ) )
 
        {
 
            dlf.addElement( pLista.get( contador ) );
 
            contador++;
 
        }
 

 
        listaPalabras.setModel( dlf );
 
    }
 

 
    /**
 
     * Muestra la información del contacto dado.
 
     * @param pContacto Contacto a mostrar.
 
     */
 
    public void mostrarContacto( Contacto pContacto )
 
    {
 
        txtNombre.setText( pContacto.darNombre( ) );
 
        txtApellido.setText( pContacto.darApellido( ) );
 
        txtDireccion.setText( pContacto.darDireccion( ) );
 
        txtCorreo.setText( pContacto.darCorreo( ) );
 
        actualizarListaPalabras( pContacto.darPalabras( ) );
 
        actualizarListaTelefonos( pContacto.darTelefonos( ) );
 
    }
 

 
    /**
 
     * Recibe los eventos realizados en los elementos de la interfaz y realiza acciones.
 
     * @param pEvento El evento realizado por el usuario. pEvento != null.
 
     */
 
    public void actionPerformed( ActionEvent pEvento )
 
    {
 
        String comando = pEvento.getActionCommand( );
 
        if( comando.equals( AGREGAR ) )
 
        {
 
            principal.agregarContacto( );
 
        }
 
        else if( comando.equals( MODIFICAR ) )
 
        {
 
            principal.modificarContacto( );
 
        }
 
        else if( comando.equals( LIMPIAR ) )
 
        {
 
            limpiarCampos( );
 
        }
 
        else if( comando.equals( AGREGAR_TELEFONO ) )
 
        {
 
            agregarTelefono( );
 
        }
 
        else if( comando.equals( AGREGAR_PALABRA ) )
 
        {
 
            agregarPalabra( );
 
        }
 
        else if( comando.equals( ELIMINAR_TELEFONO ) )
 
        {
 
            eliminarTelefono( );
 
        }
 
        else if( comando.equals( ELIMINAR_PALABRA ) )
 
        {
 
            eliminarPalabra( );
 
        }
 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n3_listaDeContactos
 
 * Autor: Equipo Cupi2 2017
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.listaContactos.interfaz;
 

 
import java.awt.BorderLayout;
 
import java.awt.GridLayout;
 
import java.awt.event.ActionEvent;
 
import java.awt.event.ActionListener;
 
import java.util.ArrayList;
 

 
import javax.swing.BorderFactory;
 
import javax.swing.DefaultListModel;
 
import javax.swing.JButton;
 
import javax.swing.JList;
 
import javax.swing.JPanel;
 
import javax.swing.JScrollPane;
 
import javax.swing.border.TitledBorder;
 

 
/**
 
 * Panel que muestra la lista de contactos.
 
 */
 
@SuppressWarnings("serial")
 
public class PanelLista extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Constante usada para indicar que se quieren ver todos los contactos.
 
     */
 
    private final static String TODOS = "TODOS";
 

 
    /**
 
     * Constante usada para indicar que se quieren ver los contactos que cumplan con algún criterio de búsqueda.
 
     */
 
    private final static String PALABRA = "PALABRA";
 

 
    /**
 
     * Constante usada para indicar que se quieren ver los datos de un contacto.
 
     */
 
    private final static String VER = "VER";
 

 
    /**
 
     * Constante usada para indicar que se quiere eliminar un contacto.
 
     */
 
    private final static String ELIMINAR = "ELIMINAR";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * La ventana principal de la aplicación.
 
     */
 
    private InterfazListaDeContactos principal;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de Interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Panel de desplazamiento de la lista de contactos.
 
     */
 
    private JScrollPane panelLista;
 

 
    /**
 
     * Lista para los contactos.
 
     */
 
    private JList listaContactos;
 

 
    /**
 
     * Botón al que se le asignara la acción para mostrar los datos de un contacto.
 
     */
 
    private JButton btnVer;
 

 
    /**
 
     * Botón al que se le asignara la acción para eliminar un contacto.
 
     */
 
    private JButton btnEliminar;
 

 
    /**
 
     * Botón para la acción de ver todos los contactos.
 
     */
 
    private JButton btnTodos;
 

 
    /**
 
     * Botón para hacer búsqueda de contactos por palabras clave.
 
     */
 
    private JButton btnPalabra;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Crea el panel de visualización de la lista de contactos.
 
     * @param pPrincipal Ventana principal de la aplicación. pPrincipal != null.
 
     */
 
    public PanelLista( InterfazListaDeContactos pPrincipal )
 
    {
 
        principal = pPrincipal;
 
        setLayout( new BorderLayout( ) );
 
        setBorder( new TitledBorder( "Lista de Contactos" ) );
 

 
        // Inicializa la lista
 
        listaContactos = new JList( );
 
        panelLista = new JScrollPane( );
 
        panelLista.setViewportView( listaContactos );
 
        panelLista.setVerticalScrollBarPolicy( JScrollPane.VERTICAL_SCROLLBAR_ALWAYS );
 
        panelLista.setHorizontalScrollBarPolicy( JScrollPane.HORIZONTAL_SCROLLBAR_NEVER );
 

 
        listaContactos.setModel( new DefaultListModel( ) );
 

 
        // Inicializa los botones
 
        btnVer = new JButton( );
 
        btnVer.setText( "Ver" );
 
        btnVer.setActionCommand( VER );
 
        btnVer.addActionListener( this );
 

 
        btnEliminar = new JButton( );
 
        btnEliminar.setText( "Eliminar" );
 
        btnEliminar.setActionCommand( ELIMINAR );
 
        btnEliminar.addActionListener( this );
 

 
        btnTodos = new JButton( );
 
        btnTodos.setText( "Ver Todos los contactos" );
 
        btnTodos.setActionCommand( TODOS );
 
        btnTodos.addActionListener( this );
 

 
        btnPalabra = new JButton( );
 
        btnPalabra.setText( "Buscar por palabra clave" );
 
        btnPalabra.setActionCommand( PALABRA );
 
        btnPalabra.addActionListener( this );
 

 
        // Ubica los elementos inicializados anteriormente
 
        add( panelLista, BorderLayout.CENTER );
 

 
        JPanel panelBotones = new JPanel( );
 
        panelBotones.setBorder( BorderFactory.createEmptyBorder( 5, 5, 5, 5 ) );
 
        panelBotones.setLayout( new GridLayout( 4, 1, 5, 5 ) );
 
        panelBotones.add( btnTodos );
 
        panelBotones.add( btnPalabra );
 
        panelBotones.add( btnVer );
 
        panelBotones.add( btnEliminar );
 

 
        add( panelBotones, BorderLayout.EAST );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Actualiza la lista con los elementos del arrayList.
 
     * @param pLista La nueva lista de nombres para mostrar.
 
     */
 
    public void actualizarLista( ArrayList pLista )
 
    {
 
        listaContactos.setListData( pLista.toArray( ) );
 
    }
 

 
    /**
 
     * Retorna el nombre del contacto seleccionado.
 
     * @return Nombre del contacto seleccionado. Si no hay un contacto seleccionado retorna null.
 
     */
 
    public String darNombreSeleccionado( )
 
    {
 
        String nombreCompleto = ( ( String )listaContactos.getSelectedValue( ) );
 
        if( nombreCompleto != null )
 
        {
 
            nombreCompleto = nombreCompleto.substring( 0, nombreCompleto.indexOf( " " ) );
 
        }
 

 
        return nombreCompleto;
 
    }
 

 
    /**
 
     * Retorna el apellido del contacto seleccionado.
 
     * @return Apellido del contacto seleccionado. Si no hay un contacto seleccionado retorna null.
 
     */
 
    public String darApellidoSeleccionado( )
 
    {
 
        String nombreCompleto = ( ( String )listaContactos.getSelectedValue( ) );
 
        if( nombreCompleto != null )
 
        {
 
            nombreCompleto = nombreCompleto.substring( nombreCompleto.indexOf( " " ) + 1, nombreCompleto.length( ) );
 
        }
 

 
        return nombreCompleto;
 
    }
 

 
    /**
 
     * Recibe los eventos realizados en los elementos de la interfaz y realiza acciones.
 
     * @param pEvento El evento realizado por el usuario. pEvento != null.
 
     */
 
    public void actionPerformed( ActionEvent pEvento )
 
    {
 
        String comando = pEvento.getActionCommand( );
 
        if( comando.equals( VER ) )
 
        {
 
            principal.visualizarContacto( );
 
        }
 
        else if( comando.equals( TODOS ) )
 
        {
 
            actualizarLista( principal.darContactos( ) );
 
        }
 
        else if( comando.equals( PALABRA ) )
 
        {
 
            principal.buscarContactosPalabra( );
 
        }
 
        else if( comando.equals( ELIMINAR ) )
 
        {
 
            principal.eliminarContacto( );
 
        }
 

 
    }
 

 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n3_listaDeContactos
 
 * Autor: Equipo Cupi2 2017
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.listaContactos.interfaz;
 

 
import java.awt.event.ActionEvent;
 
import java.awt.event.ActionListener;
 

 
import javax.swing.JButton;
 
import javax.swing.JPanel;
 
import javax.swing.border.TitledBorder;
 

 
/**
 
 * Panel para los botones de extensión del ejercicio.
 
 */
 
@SuppressWarnings("serial")
 
public class PanelOpciones extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Constante OPCION_1, Usada para realizar la opción de la extensión 1.
 
     */
 
    private final static String OPCION_1 = "OPCION_1";
 

 
    /**
 
     * Constante OPCION_2, Usada para realizar la opción de la extensión 2.
 
     */
 
    private final static String OPCION_2 = "OPCION_2";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Ventana principal de la aplicación.
 
     */
 
    private InterfazListaDeContactos principal;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de Interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Botón Para hacer la extensión 1.
 
     */
 
    private JButton opcion1;
 

 
    /**
 
     * Botón Para hacer la extensión 2.
 
     */
 
    private JButton opcion2;
 

 
    // -----------------------------------------------------------------
 
    // Constructor
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Crea un nuevo panel con los botones para realizar las extensiones.
 
     * @param pPrincipal La ventana principal de la aplicación. pPrincipal != null.
 
     */
 
    public PanelOpciones( InterfazListaDeContactos pPrincipal )
 
    {
 
        principal = pPrincipal;
 

 
        setBorder( new TitledBorder( "Extensiones" ) );
 

 
        opcion1 = new JButton( );
 
        opcion1.setText( "Opción1" );
 
        opcion1.setActionCommand( OPCION_1 );
 
        opcion1.addActionListener( this );
 

 
        opcion2 = new JButton( );
 
        opcion2.setText( "Opción2" );
 
        opcion2.setActionCommand( OPCION_2 );
 
        opcion2.addActionListener( this );
 

 
        add( opcion1 );
 
        add( opcion2 );
 
    }
 

 
    /**
 
     * Realiza las acciones respectivas dependiendo del evento ocurrido. <br>
 
     * <b>post: </b> Se realiza alguno de los 2 puntos de extensión.
 
     * @param pEvento Evento generado. pEvento != null.
 
     */
 
    public void actionPerformed( ActionEvent pEvento )
 
    {
 
        String command = pEvento.getActionCommand( );
 
        if( command.equals( OPCION_1 ) )
 
        {
 
            principal.reqFuncOpcion1( );
 
        }
 
        else if( command.equals( OPCION_2 ) )
 
        {
 
            principal.reqFuncOpcion2( );
 
        }
 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n3_listaDeContactos
 
 * Autor: Equipo Cupi2 2017
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.listaContactos.mundo;
 

 
import java.util.ArrayList;
 

 
/**
 
 * Clase que representa un contacto.
 
 */
 
public class Contacto
 
{
 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Nombre del contacto.
 
     */
 
    private String nombre;
 

 
    /**
 
     * Apellido del contacto.
 
     */
 
    private String apellido;
 

 
    /**
 
     * Dirección del contacto.
 
     */
 
    private String direccion;
 

 
    /**
 
     * Correo electrónico del contacto.
 
     */
 
    private String correo;
 

 
    /**
 
     * Lista de teléfonos del contacto.
 
     */
 
    private ArrayList<String> telefonos;
 

 
    /**
 
     * Lista de palabras clave del contacto. Esta lista incluye el nombre y el apellido del contacto.
 
     */
 
    private ArrayList<String> palabras;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Crea un nuevo contacto sin teléfonos ni palabras claves. <br>
 
     * <b>post: </b> El contacto tiene los datos dados y las listas de teléfonos y palabras claves vacías.
 
     * @param pNombre Nombre del nuevo contacto. pNombre != null && pNombre != "".
 
     * @param pApellido Apellido del nuevo contacto. pApellido != null && pApellido != "".
 
     * @param pDireccion Dirección del nuevo contacto. pDireccion != null && pDireccion != "".
 
     * @param pCorreo El correo electrónico del contacto. pCorreo != null && pCorreo != "".
 
     */
 
    public Contacto( String pNombre, String pApellido, String pDireccion, String pCorreo )
 
    {
 
        nombre = pNombre;
 
        apellido = pApellido;
 
        direccion = pDireccion;
 
        correo = pCorreo;
 
        telefonos = new ArrayList<String>( );
 
        palabras = new ArrayList<String>( );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Retorna el nombre del contacto.
 
     * @return Nombre del contacto.
 
     */
 
    public String darNombre( )
 
    {
 
        return nombre;
 
    }
 

 
    /**
 
     * Retorna el apellido del contacto.
 
     * @return Apellido del contacto.
 
     */
 
    public String darApellido( )
 
    {
 
        return apellido;
 
    }
 

 
    /**
 
     * Retorna la dirección del contacto.
 
     * @return Dirección del contacto.
 
     */
 
    public String darDireccion( )
 
    {
 
        return direccion;
 
    }
 

 
    /**
 
     * Retorna el correo electrónico del contacto.
 
     * @return Correo electrónico del contacto.
 
     */
 
    public String darCorreo( )
 
    {
 
        return correo;
 
    }
 

 
    /**
 
     * Retorna la lista de teléfonos del contacto.
 
     * @return Lista de teléfonos del contacto.
 
     */
 
    public ArrayList<String> darTelefonos( )
 
    {
 
        return telefonos;
 
    }
 

 
    /**
 
     * Retorna la lista de palabras clave del contacto.
 
     * @return Lista de palabras clave del contacto
 
     */
 
    public ArrayList<String> darPalabras( )
 
    {
 
        return palabras;
 
    }
 

 
    /**
 
     * Cambia la dirección del contacto.
 
     * @param pDireccion La nueva dirección. pDireccion != null && pDireccion != "".
 
     */
 
    public void cambiarDireccion( String pDireccion )
 
    {
 
        direccion = pDireccion;
 
    }
 

 
    /**
 
     * Cambia el correo electrónico del contacto.
 
     * @param pCorreo Nuevo correo electrónico. pCorreo != null && pCorreo != "".
 
     */
 
    public void cambiarCorreo( String pCorreo )
 
    {
 
        correo = pCorreo;
 
    }
 

 
    /**
 
     * Agrega un nuevo teléfono a la lista de teléfonos del contacto si no existe. <br>
 
     * <b>post: </b> Si el número no existía se ha agregado a la lista de teléfonos.
 
     * @param pTelefono Número de teléfono a agregar en la lista. pTelefono != null && pTelefono != "".
 
     */
 
    public void agregarTelefono( String pTelefono )
 
    {
 
        // Ciclo para verificar si el teléfono existe en la lista
 
        int contador = 0;
 
        boolean encontrado = false;
 
        while( contador < telefonos.size( ) && !encontrado )
 
        {
 
            String telefono = telefonos.get( contador );
 
            if( telefono.equals( pTelefono ) )
 
            {
 
                encontrado = true;
 
            }
 
            else
 
                contador++;
 
        }
 

 
        // Si no encuentra el teléfono lo agrega
 
        if( encontrado == false )
 
        {
 
            telefonos.add( pTelefono );
 
        }
 
    }
 

 
    /**
 
     * Elimina un teléfono de la lista de teléfonos del contacto. <br>
 
     * <b>post: </b> Si el teléfono estaba en la lista de contactos queda eliminado.
 
     * @param pTelefonoEliminar Número de teléfono a eliminar de la lista. pTelefonoEliminar != null.
 
     */
 
    public void eliminarTelefono( String pTelefonoEliminar )
 
    {
 
        // Ciclo para buscar el teléfono a eliminar de la lista
 
        int contador = 0;
 
        boolean encontrado = false;
 
        while( contador < telefonos.size( ) && !encontrado )
 
        {
 
            String telefono = telefonos.get( contador );
 
            if( telefono.equals( pTelefonoEliminar ) )
 
            {
 
                encontrado = true;
 
            }
 
            else
 
            {
 
                contador++;
 
            }
 
        }
 

 
        // Si el teléfono existe lo elimina
 
        if( encontrado )
 
        {
 
            telefonos.remove( contador );
 
        }
 
    }
 

 
    /**
 
     * Agrega una nueva palabra clave a la lista de palabras del contacto. <br>
 
     * <b>post: </b> Se agrega la nueva palabra a la lista de contactos, si la palabra no existe ya en la lista.
 
     * @param pPalabra La palabra a agregar en la lista. pPalabra != null && pPalabra != "".
 
     */
 
    public void agregarPalabra( String pPalabra )
 
    {
 
        // Verifica si la palabra ya existe en la lista para agregarla
 
        if( !contienePalabraClave( pPalabra ) )
 
        {
 
            palabras.add( pPalabra );
 
        }
 
    }
 

 
    /**
 
     * Elimina una palabra clave a la lista de palabras del contacto. <br>
 
     * <b>post: </b> Si la palabra existe en la lista de palabras, queda eliminada.
 
     * @param pPalabraEliminar Palabra a eliminar de la lista de palabras claves. pPalabraEliminar != null.
 
     */
 
    public void eliminarPalabra( String pPalabraEliminar )
 
    {
 
        // Verificar si la palabra ya existe en la lista para eliminarla
 
        if( contienePalabraClave( pPalabraEliminar ) )
 
        {
 
            palabras.remove( pPalabraEliminar );
 
        }
 
    }
 

 
    /**
 
     * Determina si el contacto tiene la palabra clave indicada.
 
     * @param pPalabra Palabra clave a buscar. pPalabra != null.
 
     * @return Retorna true si el contacto contiene la palabra, false en caso contrario.
 
     */
 
    public boolean contienePalabraClave( String pPalabra )
 
    {
 
        boolean encontrado = false;
 
        int contador = 0;
 
        while( contador < palabras.size( ) && !encontrado )
 
        {
 
            String palabraC = palabras.get( contador );
 
            if( pPalabra.equals( palabraC ) )
 
            {
 
                encontrado = true;
 
            }
 
            contador++;
 
        }
 
        return encontrado;
 
    }
 

 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n3_listaDeContactos
 
 * Autor: Equipo Cupi2 2017
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.listaContactos.mundo;
 

 
import java.util.ArrayList;
 

 
/**
 
 * Clase que representa una lista de contactos personales.
 
 */
 
public class ListaDeContactos
 
{
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 
    /**
 
     * Lista de contactos.
 
     */
 
    private ArrayList<Contacto> contactos;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Crea una nueva lista de contactos vacía. <br>
 
     * <b>post: </b> Se inicializa la lista de contactos.
 
     */
 
    public ListaDeContactos( )
 
    {
 
        contactos = new ArrayList<Contacto>( );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Retorna una lista con el nombre de los contactos. <br>
 
     * <b>pre: </b> La lista de contactos está inicializada.
 
     * @return La lista de contactos. Si no hay contactos la lista se retorna vacía.
 
     */
 
    public ArrayList<String> darTodosLosContactos( )
 
    {
 
        ArrayList<String> lista = new ArrayList<String>( );
 
        for( int i = 0; i < contactos.size( ); i++ )
 
        {
 
            Contacto c = contactos.get( i );
 
            lista.add( c.darNombre( ) + " " + c.darApellido( ) );
 
        }
 
        return lista;
 
    }
 

 
    /**
 
     * Retorna una lista con todos los contactos que tienen la palabra dada entre sus palabras claves. <br>
 
     * <b>pre: </b> La lista de contactos está inicializada.
 
     * @param pPalabra Palabra clave para buscar contactos. pPalabra != null.
 
     * @return La lista de contactos. Si no encuentra contactos con la palabra clave, la lista se retorna vacía.
 
     */
 
    public ArrayList<String> buscarContactosPalabraClave( String pPalabra )
 
    {
 
        ArrayList<String> nombres = new ArrayList<String>( );
 

 
        for( int i = 0; i < contactos.size( ); i++ )
 
        {
 
            // Para cada contacto verifica si tiene la palabra en su lista de
 
            // palabras clave para agregarlo a la lista
 
            Contacto c = contactos.get( i );
 
            if( c.contienePalabraClave( pPalabra ) )
 
            {
 
                nombres.add( c.darNombre( ) + " " + c.darApellido( ) );
 
            }
 
        }
 
        return nombres;
 
    }
 

 
    /**
 
     * Agrega un nuevo contacto a la lista, si todavía no hay ningún contacto con el nombre y el apellido dado. <br>
 
     * <b>pre: </b> La lista de contactos está inicializada. <br>
 
     * <b>post: </b> Se agrega un nuevo contacto a la lista si éste no exista aún en ella.
 
     * @param pNombre Nombre del nuevo contacto. pNombre != null.
 
     * @param pApellido Apellido del nuevo contacto. pApellido != null.
 
     * @param pDireccion Dirección del nuevo contacto. pDireccion != null.
 
     * @param pCorreo Correo electrónico del nuevo contacto. pCorreo != null.
 
     * @param pTelefonos Lista de teléfonos del nuevo contacto. pTelefonos != null.
 
     * @param pPalabras Lista de palabras clave del nuevo contacto. pPalabras != null.
 
     * @return Retorna true si se pudo agregar el contacto, false de lo contrario.
 
     */
 
    public boolean agregarContacto( String pNombre, String pApellido, String pDireccion, String pCorreo, ArrayList<String> pTelefonos, ArrayList<String> pPalabras )
 
    {
 
        Contacto con = buscarContacto( pNombre, pApellido );
 
        boolean exito = false;
 
        if( con == null ) // se puede agregar el contacto
 
        {
 
            pPalabras.add( pNombre );
 
            pPalabras.add( pApellido );
 
            Contacto nuevo = new Contacto( pNombre, pApellido, pDireccion, pCorreo );
 
            // Agrega los teléfonos
 
            for( int i = 0; i < pTelefonos.size( ); i++ )
 
            {
 
                nuevo.agregarTelefono( pTelefonos.get( i ) );
 
            }
 
            // Agrega las palabras
 
            for( int i = 0; i < pPalabras.size( ); i++ )
 
            {
 
                nuevo.agregarPalabra( pPalabras.get( i ) );
 
            }
 
            contactos.add( nuevo );
 
            exito = true;
 
        }
 

 
        return exito;
 
    }
 

 
    /**
 
     * Elimina un contacto dado su nombre y su apellido. <br>
 
     * <b>pre: </b> La lista de contactos está inicializada. <br>
 
     * <b>post: </b> Si el usuario existe en la lista se elimina.
 
     * @param pNombre Nombre del contacto a eliminar. pNombre != null.
 
     * @param pApellido Apellido del contacto a eliminar. pApellido != null.
 
     * @return Retorna true si se pudo eliminar el contacto, false de lo contrario.
 
     */
 
    public boolean eliminarContacto( String pNombre, String pApellido )
 
    {
 
        Contacto con = buscarContacto( pNombre, pApellido );
 
        boolean exito = false;
 
        if( con != null )
 
        {
 
            contactos.remove( con );
 
            exito = true;
 
        }
 

 
        return exito;
 

 
    }
 

 
    /**
 
     * Modifica los datos de un contacto dados su nombre y apellido. <br>
 
     * <b>post: </b> Si el usuario existe se modifican sus datos.
 
     * @param pNombre Nombre del contacto. pNombre != null.
 
     * @param pApellido Apellido del contacto. pApellido != null.
 
     * @param pDireccion Nueva dirección del contacto. pDirección != null.
 
     * @param pCorreo Nuevo correo electrónico del contacto. pCorreo !=null.
 
     * @param pTelefonos Nueva lista de teléfonos del contacto.
 
     * @param pPalabras Nueva lista de palabras clave del contacto.
 
     * @return Retorna true si se pudo modificar el contacto, false de lo contrario.
 
     */
 
    public boolean modificarContacto( String pNombre, String pApellido, String pDireccion, String pCorreo, ArrayList<String> pTelefonos, ArrayList<String> pPalabras )
 
    {
 
        // Verifica si el contacto existe
 
        Contacto con = buscarContacto( pNombre, pApellido );
 
        boolean exito = true;
 
        if( con == null )
 
        {
 
            exito = false;
 
        }
 
        else
 
        {
 
            // Modifica el contacto con los nuevos datos
 
            con.cambiarDireccion( pDireccion );
 
            con.cambiarCorreo( pCorreo );
 
            actualizarPalabras( pPalabras, con );
 
            actualizarTelefonos( pTelefonos, con );
 
        }
 
        return exito;
 
    }
 

 
    /**
 
     * Actualiza la lista de teléfonos del contacto dado.
 
     * @param pTelefonos Lista actual de teléfonos. pTelefonos != null.
 
     * @param pContacto Contacto al que se le modificará la lista de teléfonos.
 
     */
 
    private void actualizarTelefonos( ArrayList<String> pTelefonos, Contacto pContacto )
 
    {
 
        ArrayList<String> listaVieja = pContacto.darTelefonos( );
 
        ArrayList<String> eliminar = new ArrayList<String>( );
 

 
        // Elige los teléfonos para eliminar de la lista vieja que ya no están
 
        // en la nueva lista
 
        for( int i = 0; i < listaVieja.size( ); i++ )
 
        {
 
            String telefonoViejo = listaVieja.get( i );
 
            boolean encontrado = false;
 
            for( int j = 0; j < pTelefonos.size( ) && !encontrado; j++ )
 
            {
 
                String telefonoNuevo = pTelefonos.get( j );
 
                if( telefonoViejo.equals( telefonoNuevo ) )
 
                {
 
                    encontrado = true;
 
                }
 
            }
 
            if( !encontrado )
 
            {
 
                eliminar.add( telefonoViejo );
 
            }
 

 
        }
 
        // Elimina los teléfonos
 
        for( int i = 0; i < eliminar.size( ); i++ )
 
        {
 
            pContacto.eliminarTelefono( eliminar.get( i ) );
 
        }
 

 
        // Intenta agregar todos los teléfonos de la lista nueva. El método
 
        // controla que no estén incluidos
 
        for( int i = 0; i < pTelefonos.size( ); i++ )
 
        {
 
            String telefono = pTelefonos.get( i );
 
            pContacto.agregarTelefono( telefono );
 
        }
 
    }
 

 
    /**
 
     * Actualiza la lista de palabras clave del contacto. <br>
 
     * <b>post: </b> Las palabras que no existan en la nueva lista se eliminan y las palabras nuevas se agregan a la lista del contacto.
 
     * @param pPalabras Lista con las palabras finales.
 
     * @param pContacto Contacto a quien se le modificará la lista de palabras.
 
     */
 
    private void actualizarPalabras( ArrayList<String> pPalabras, Contacto pContacto )
 
    {
 
        ArrayList<String> listaVieja = pContacto.darPalabras( );
 
        ArrayList<String> eliminar = new ArrayList<String>( );
 

 
        // Elige las palabras para eliminar de la lista vieja que ya no están en
 
        // la nueva lista
 
        int tamListaVieja = listaVieja.size( );
 
        for( int i = 0; i < tamListaVieja; i++ )
 
        {
 
            String palabraVieja = listaVieja.get( i );
 
            boolean encontrado = false;
 
            for( int j = 0; j < pPalabras.size( ) && !encontrado; j++ )
 
            {
 
                String palabraNueva = pPalabras.get( j );
 
                if( palabraVieja.equals( palabraNueva ) )
 
                {
 
                    encontrado = true;
 
                }
 
            }
 
            if( !encontrado )
 
            {
 
                eliminar.add( palabraVieja );
 
            }
 
        }
 
        // Elimina las palabras
 
        for( int i = 0; i < eliminar.size( ); i++ )
 
        {
 
            pContacto.eliminarPalabra( eliminar.get( i ) );
 
        }
 

 
        // Intenta agregar todas las palabras de la lista nueva. El método
 
        // controla que no estén incluidas
 
        for( int i = 0; i < pPalabras.size( ); i++ )
 
        {
 
            String palabra = pPalabras.get( i );
 
            pContacto.agregarPalabra( palabra );
 
        }
 

 
    }
 

 
    /**
 
     * Busca un contacto dado su nombre y su apellido. <br>
 
     * <b>pre: </b> La lista de contactos está inicializada.
 
     * @param pNombre Nombre del contacto a buscar. pNombre != null.
 
     * @param pApellido Apellido del contacto a buscar. pApellido != null.
 
     * @return Retorna el contacto si se encuentra, null en caso contrario.
 
     */
 
    public Contacto buscarContacto( String pNombre, String pApellido )
 
    {
 
        int contador = 0;
 
        Contacto con = null;
 
        boolean encontrado = false;
 
        while( contador < contactos.size( ) && !encontrado )
 
        {
 
            con = contactos.get( contador );
 
            if( pNombre.equals( con.darNombre( ) ) && pApellido.equals( con.darApellido( ) ) )
 
            {
 
                encontrado = true;
 
            }
 
            contador++;
 
        }
 
        if( !encontrado )
 
        {
 
            con = null;
 
        }
 
        return con;
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Puntos de Extensión
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Método para la extensión 1.
 
     * @return Respuesta 1.
 
     */
 
    public String metodo1( )
 
    {
 
        return "Respuesta 1";
 
    }
 

 
    /**
 
     * Método para la extensión 2.
 
     * @return Respuesta 2.
 
     */
 
    public String metodo2( )
 
    {
 
        return "Respuesta 2";
 
    }
 
}