AppEjercicio2.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class AppEjercicio2
{
    /**
     * Arreglos para operaciones de conjuntos.
     */
    private int[] arregloA;
    private int[] arregloB;
    private int[] arregloC;

    /**
     * Cantidad de elementos a insertar en cada uno de los arreglos, además de la instanciación de los mismos.
     */
    public void numeroElementosInsertarEnABC()
    {
        int numeroElementos = 0;

        InputStreamReader isr = new InputStreamReader( System.in );
        BufferedReader br = new BufferedReader( isr );

        try
        {
            while( numeroElementos <= 0 )
            {
                System.out.print( "Dígite el número de elementos a insertar en A: " );
                numeroElementos = Integer.parseInt( br.readLine() );
            }

            // crea el arregloA
            arregloA = new int[ numeroElementos ];

            System.out.println();
            numeroElementos = 0;

            while ( numeroElementos <= 0 )
            {
                System.out.print("Dígite el número de elementos a insertar en B: ");
                numeroElementos = Integer.parseInt(br.readLine());
            }

            // crea el arregloB
            arregloB = new int[ numeroElementos ];

            // el tamaño para el arreglo C (arregloC) es la suma del tamaño de los arreglos arregloA, arregloB.
            arregloC = new int[ arregloA.length + arregloB.length ];
        }
        catch( NumberFormatException nfe )
        {
            nfe.printStackTrace();
        }
        catch( IOException ioe )
        {
            ioe.printStackTrace();
        }
    } // fin del método numeroElementosInsertarEnABC

    /**
     * Carga los arreglos de instancia con valores introducidos por el usuario.
     */
    public void cargarArreglos()
    {
        // crea el buffer para ingreso de datos desde la entrada estándar
        InputStreamReader isr = new InputStreamReader( System.in );
        BufferedReader br = new BufferedReader( isr );

        // carga el arreglo arregloA
        int dato = 0;

        System.out.println( "\n\nInsertando elementos en A: " );

        for (int i = 0; i < arregloA.length; ++i )
        {
            if( i == 0 )
            {
                System.out.print( "Dígite un número: " );
                try
                {
                    dato = Integer.parseInt( br.readLine() );
                    arregloA[ i ] = dato;
                }
                catch (NumberFormatException e)
                {
                    e.printStackTrace();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            else // sólo se comprueba la existencia de elementos a partir de la segunda inserción.
            {
                do
                {
                    System.out.print( "Dígite un número: " );
                    try
                    {
                        dato = Integer.parseInt( br.readLine() );
                        arregloA[ i ] = dato;
                    }
                    catch (NumberFormatException e)
                    {
                        e.printStackTrace();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                } while( existeDato( arregloA, dato, i ) ); // mientras que el dato insertado existe se repite este ciclo.
            } // fin de if
        } // fin de for

        // a partir de esta línea se empieza a cargar el segundo arreglo.
        dato = 0;

        System.out.println( "\n\nInsertando elementos en B: " );

        for (int i = 0; i < arregloB.length; ++i )
        {
            if( i == 0 )
            {
                System.out.print( "Dígite un número: " );
                try
                {
                    dato = Integer.parseInt( br.readLine() );
                    arregloB[ i ] = dato;
                }
                catch (NumberFormatException e)
                {
                    e.printStackTrace();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            else // sólo se comprueba la existencia de elementos a partir de la segunda inserción.
            {
                do
                {
                    System.out.print( "Dígite un número: " );
                    try
                    {
                        dato = Integer.parseInt( br.readLine() );
                        arregloB[ i ] = dato;
                    }
                    catch (NumberFormatException e)
                    {
                        e.printStackTrace();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                } while( existeDato( arregloB, dato, i ) ); // mientras que el dato insertado existe se repite este ciclo.
            } // fin de if
        } // fin de for
    } // fin del método cargarArreglos

    /**
     * Comprueba si un dato concreto ya ha sido insertado.
     * @param arreglo Arreglo de datos enteros
     * @param dato El dato actual a insertar
     * @param longitudActual La longitud hasta donde se debe explorar el arreglo.
     * @return Si el dato existe o no en el arreglo.
     */
    private boolean existeDato(int[]  arreglo, int dato, int longitudActual )
    {
        for (int i = 0; i < longitudActual; i++)
        {
            if( dato == arreglo[ i ] )
            {
                return true;
            }
            else
            {
                continue;
            }
        }

        return( false );
    } // fin del método existeDato

    /**
     * Crea el arreglo arregloC a partir de la unión entre los conjuntos A y B.
     */
    public void crearUnionConjuntoAB()
    {
        // copia el contenido del arreglo arregloA al arreglo arregloC.
        for (int i = 0; i < arregloA.length; i++)
        {
            arregloC[ i ] = arregloA[ i ];
        } // fin for

        for( int i = arregloA.length, j = 0; j < arregloB.length; ++i, ++j )
        {
            if( !existeDato( arregloC, arregloB[ j ], arregloA.length + j ) )
            {
                arregloC[ i ] = arregloB[ j ];
            }
        } // fin for
    } // fin del método crearUnionConjuntoAB

    /**
     * Imprime el contenido de los arreglos.
     */
    public void imprimirArreglos()
    {
        System.out.println();
        System.out.println();

        // imprime contenido de arregloA
        System.out.println( "Contenido de Arreglo A: \n" );
        for (int i = 0; i < arregloA.length; ++i )
        {
            if( i < ( arregloA.length - 1 ) )
            {
                System.out.print( arregloA[ i ] + ", ");
            }
            else
            {
                System.out.print( arregloA[ i ] );
            }
        }

        System.out.println();
        System.out.println();

        /// imprime el contenido de arregloB
        System.out.println( "Contenido de Arreglo B: \n" );
        for (int i = 0; i < arregloB.length; ++i )
        {
            if (i < ( arregloB.length - 1 ) )
            {
                System.out.print(arregloB[i] + ", ");
            }
            else
            {
                System.out.print( arregloB[ i ] );
            }
        }

        System.out.println();
        System.out.println();

        // imprime el contenido de arregloC
        System.out.println( "Contenido de Arreglo C: \n" );
        for (int i = 0; i < arregloC.length; ++i )
        {
            if ( i < ( arregloC.length - 1 ) )
            {
                System.out.print( arregloC[i] + ", " );
            }
            else
            {
                System.out.print( arregloC[ i ] );
            }
        }

        System.out.println();
        System.out.println();
    } // fin del método imprimirArreglos

    /**
     * Punto de entrada de la aplicación.
     * @param args Argumentos pasados desde la consola o la terminal.
     */
    public static void main( String[] args )
    {
        // Crea una instancia de la clase AppEjericio2
        AppEjercicio2 app2 = new AppEjercicio2();

        // determina la cantidad de elementos que se deben insertar
        app2.numeroElementosInsertarEnABC();

        app2.cargarArreglos();

        // muestra el contenido de los tres arreglos de instancia
        app2.imprimirArreglos();

        // realiza unión (operación de teoría de conjuntos)
        app2.crearUnionConjuntoAB();

        // se vuelve a imprimir los arreglos
        app2.imprimirArreglos();
    } // fin del método main
}