API tools faq
paste
Advertisement
JF_Jaramillo

Taller 1 - Java

JF_Jaramillo
Feb 1st, 2021
331
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 24.16 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * To change this license header, choose License Headers in Project Properties.
  3.  * To change this template file, choose Tools | Templates
  4.  * and open the template in the editor.
  5.  */
  6. package taller.pkg1.ciclos.arrays.y.matrices;
  7.  
  8. import java.time.temporal.ChronoUnit;
  9. import java.util.Arrays;
  10. import java.util.Random;
  11. import java.util.Timer;
  12. import javax.swing.JOptionPane;
  13.  
  14. /**
  15.  *
  16.  * @author juanf
  17.  */
  18. public class Taller1CiclosArraysYMatrices {
  19.  
  20.     private String[][] camionesBascula;
  21.     private String[][] listaViajes;
  22.     private char[][] letras;
  23.     private int[] arreglo10;
  24.     private int[] arreglo50;
  25.     private int[] arreglo100;
  26.     private int[] arreglo500;
  27.     private int[] arreglo1000;
  28.    
  29.     public void inicializarMatrizBascula(){
  30.         camionesBascula = new String[50][6];
  31.         listaViajes = new String[50][6];
  32.     }
  33.    
  34.     public void inicializarArreglosOrdenamiento(){
  35.         arreglo10 = new int[10000];
  36.         arreglo50 = new int[50000];
  37.         arreglo100 = new int[100000];
  38.         arreglo500 = new int[500000];
  39.         arreglo1000 = new int[1000000];
  40.         Random generador = new Random();
  41.        
  42.        
  43.         for (int i = 0; i < arreglo10.length; i++) {
  44.             int numeroRandom = generador.nextInt();
  45.             arreglo10[i] = numeroRandom;
  46.            
  47.         }
  48.         for (int i = 0; i < arreglo50.length; i++) {
  49.             int numeroRandom = generador.nextInt();
  50.             arreglo50[i] = numeroRandom;
  51.            
  52.         }
  53.         for (int i = 0; i < arreglo100.length; i++) {
  54.             int numeroRandom = generador.nextInt();
  55.             arreglo100[i] = numeroRandom;
  56.            
  57.         }
  58.         for (int i = 0; i < arreglo500.length; i++) {
  59.             int numeroRandom = generador.nextInt();
  60.             arreglo500[i] = numeroRandom;
  61.            
  62.         }
  63.         for (int i = 0; i < arreglo1000.length; i++) {
  64.             int numeroRandom = generador.nextInt();
  65.             arreglo1000[i] = numeroRandom;
  66.            
  67.         }
  68.     }
  69.    
  70.     public void ingresarPesaje(String placaVehiculo, String peso, String destino, String dia, String mes, String anio){
  71.         for (int i = 0; i < camionesBascula.length; i++) {
  72.             if (camionesBascula[i][0] == null){
  73.                 camionesBascula[i][0] = placaVehiculo;
  74.                 camionesBascula[i][1] = peso;
  75.                 camionesBascula[i][2] = destino;
  76.                 camionesBascula[i][3] = dia;
  77.                 camionesBascula[i][4] = mes;
  78.                 camionesBascula[i][5] = anio;
  79.                 break;
  80.             }
  81.         }
  82.         if (camionesBascula[49][0] != null){
  83.             JOptionPane.showMessageDialog(null, "La matriz está llena. No se pueden almacenar más datos.", "Base de datos llena", JOptionPane.ERROR_MESSAGE);
  84.         }
  85.     }
  86.    
  87.     public String mostrarCantidadViajesYPeso(){
  88.         String resultado = "";
  89.         int contadorViajes = 0;
  90.         double contadorPeso = 0;
  91.         for (int i = 0; i < camionesBascula.length; i++) {
  92.             if (camionesBascula[i][0] != null){
  93.                 contadorViajes++;
  94.                 contadorPeso += Double.parseDouble(camionesBascula[i][1]);
  95.             }else{
  96.                 break;
  97.             }
  98.         }
  99.         resultado += "La cantidad de viajes total es: " + contadorViajes +"\n El peso total de los viajes es: " + contadorPeso;
  100.         return resultado;
  101.     }
  102.    
  103.     public void mostrarCantidadViajesYPesoPorDestino(){
  104.         int contadorBuenaventura = 0;
  105.         double promedioBuenaventura = 0.0;
  106.         int contadorBogota = 0;
  107.         double promedioBogota = 0.0;
  108.         int contadorBarranquilla = 0;
  109.         double promedioBarranquilla = 0.0;
  110.        
  111.         for (int i = 0; i < camionesBascula.length; i++) {
  112.             if (camionesBascula[i][0] != null){
  113.                 if( camionesBascula[i][2].equals("1")){
  114.                 contadorBuenaventura++;
  115.                 promedioBuenaventura += Double.parseDouble(camionesBascula[i][1]);
  116.             }else if( camionesBascula[i][2].equals("2")){
  117.                 contadorBogota++;
  118.                 promedioBogota += Double.parseDouble(camionesBascula[i][1]);
  119.             }else if( camionesBascula[i][2].equals("3")){
  120.                 contadorBarranquilla++;
  121.                 promedioBarranquilla += Double.parseDouble(camionesBascula[i][1]);
  122.             }
  123.             }
  124.         }
  125.        
  126.         JOptionPane.showMessageDialog(null, "Total de viajes a Buenaventura: " + contadorBuenaventura +
  127.                 "\n Promedio de peso de viajes a Buenaventura: " + (promedioBuenaventura/contadorBuenaventura) +
  128.                 "\n Total de viajes a Bogotá: " + contadorBogota +
  129.                 "\n Promedio de peso de viajes a Bogotá: " + (promedioBogota/contadorBogota) +
  130.                 "\n Total de viajes a Barranquilla: " + contadorBarranquilla +
  131.                 "\n Promedio de peso de viajes a Barranquilla: " + (promedioBarranquilla/contadorBarranquilla)
  132.         );
  133.     }
  134.    
  135.     public String[][] ingresarViajeConsulta(String placaDestino, String peso,String destino, String dia, String mes, String anio){
  136.        
  137.         for (int i = 0; i < listaViajes.length; i++) {
  138.             if ( listaViajes[i][0] == null){
  139.                 listaViajes[i][0] = placaDestino;
  140.                 listaViajes[i][1] = peso;
  141.                 listaViajes[i][2] = destino;
  142.                 listaViajes[i][3] = dia;
  143.                 listaViajes[i][4] = mes;
  144.                 listaViajes[i][5] = anio;
  145.                 break;
  146.             }
  147.            
  148.         }
  149.         return listaViajes;
  150.     }
  151.    
  152.     public String calcularDestino(String destino){
  153.         String destinoString = "";
  154.         if (destino.equals("1")){
  155.             destinoString = "Buenaventura.";
  156.         }else if (destino.equals("2")){
  157.             destinoString = "Bogotá.";
  158.         }else if (destino.equals("3") ){
  159.             destinoString = "Barranquilla.";
  160.         }else {
  161.             destinoString = "No válido.";
  162.         }
  163.         return destinoString;
  164.     }
  165.    
  166.     public String imprimirMatrizViajes(String[][] matrizViajes){
  167.         String texto ="";
  168.         for (int i = 0; i < matrizViajes.length; i++) {
  169.             if(matrizViajes[i][0] != null){
  170.                 texto += "Placa del vehículo: " + matrizViajes[i][0] +
  171.                     "\n Peso del vehículo: " + matrizViajes[i][1] +
  172.                     "\n Destino del vehículo:" + calcularDestino(matrizViajes[i][2]) +
  173.                     "\n Fecha del viaje del vehículo: " + matrizViajes[i][3] + "/" + matrizViajes[i][4] + "/" + matrizViajes[i][5] +
  174.                     "\n _____________________________________________________\n";
  175.             }else{
  176.                 break;
  177.             }
  178.            
  179.            
  180.         }
  181.         return texto;
  182.     }
  183.    
  184.     public void consultarViajesPorFechaYDestino(String diaConsulta, String mesConsulta, String anioConsulta, String destinoConsulta){
  185.        
  186.         int contadorConsulta = 0;
  187.         if( camionesBascula[0][0] != null){
  188.             for (int i = 0; i < camionesBascula.length; i++) {
  189.             if ( diaConsulta.equals(camionesBascula[i][3]) &&
  190.                     mesConsulta.equals(camionesBascula[i][4]) &&
  191.                     anioConsulta.equals(camionesBascula[i][5]) &&
  192.                     destinoConsulta.equals(camionesBascula[i][2])){
  193.                 ingresarViajeConsulta(camionesBascula[i][0], camionesBascula[i][1], camionesBascula[i][2], camionesBascula[i][3], camionesBascula[i][4], camionesBascula[i][5]);
  194.             }
  195.         }
  196.         }else{
  197.             JOptionPane.showMessageDialog(null, "No hay viajes registrados en la base de datos.", "Viajes no encontrados", JOptionPane.ERROR_MESSAGE);
  198.    
  199.         }
  200.        
  201.        
  202.         if (listaViajes[0] != null){
  203.            
  204.             JOptionPane.showMessageDialog(null, imprimirMatrizViajes(listaViajes));
  205.  
  206.         }else{
  207.             JOptionPane.showMessageDialog(null, "No hay viajes que coincidan con los términos ingresados.", "Viajes no encontrados", JOptionPane.ERROR_MESSAGE);
  208.         }
  209.        
  210.         limpiarArreglo();
  211.                
  212.     }
  213.    
  214.     public void inicializarMatrizAbecedario (int i , int j){
  215.         if ( i*j != 28){
  216.             JOptionPane.showMessageDialog(null, "Dimensión incorrecta. Por favor asegurese de que la combinación de filas*columnas sea igual a 28", "Error de dimensión de matriz", JOptionPane.ERROR_MESSAGE);
  217.         }else{
  218.             letras = new char[i][j];
  219.         }
  220.     }
  221.    
  222.     public void llenarMatrizAbecedarioMinusculas(){
  223.         Random generador = new Random();
  224.         for(int i = 0; i < letras.length; i++){
  225.             for (int j = 0; j < letras[i].length; j++) {
  226.                 int numeroRandom =  (generador.nextInt(26) +98);
  227.                 if (numeroRandom == 122){
  228.                     letras[i][j] = 'ñ';
  229.                 }else if (numeroRandom == 123){
  230.                     letras[i][j] = ' ';
  231.                 }else if(numeroRandom == 124){
  232.                     break;
  233.                 }else{
  234.                     letras[i][j] = (char)numeroRandom;
  235.                 }
  236.                
  237.             }
  238.         }
  239.     }
  240.    
  241.     public void llenarMatrizAbecedarioMayusculas(){
  242.         Random generador = new Random();
  243.         for(int i = 0; i < letras.length; i++){
  244.             for (int j = 0; j < letras[i].length; j++) {
  245.                 int numeroRandom = (generador.nextInt(26) + 67);
  246.                 if (numeroRandom == 91){
  247.                     letras[i][j] = 'Ñ';
  248.                 }else if (numeroRandom == 92){
  249.                     letras[i][j] = ' ';
  250.                 }else{
  251.                     letras[i][j] = (char)numeroRandom;
  252.                 }
  253.                
  254.             }
  255.         }
  256.     }
  257.    
  258.     public String imprimirMatrizLetras(){
  259.         String matriz = "";
  260.             for (int i = 0; i < letras.length; i++){
  261.                 matriz += Arrays.toString(letras[i]);            
  262.             }
  263.             return matriz;
  264.     }
  265.    
  266.     public String insertionSort (int[] arreglo){
  267.        
  268.         String conclusion = "";
  269.         int arregloTemporal[] = new int[arreglo.length];
  270.         arregloTemporal = arreglo.clone();
  271.        
  272.         long tiempoInicial = System.currentTimeMillis();
  273.         long contadorComparaciones = 0;
  274.         long contadorAsignaciones = 0;
  275.         long cantidadIntercambios = 0;
  276.        
  277.         contadorAsignaciones++;
  278.         contadorComparaciones++;
  279.         for (int i = 1; i < arregloTemporal.length; ++i) {
  280.        
  281.             int llave = arregloTemporal[i];
  282.             int j = i - 1;
  283.             contadorAsignaciones += 2;
  284.             contadorComparaciones++;
  285.             while (j >= 0 && arregloTemporal[j] > llave) {
  286.                
  287.                 arregloTemporal[j + 1] = arregloTemporal[j];
  288.                 j = j - 1;
  289.                 cantidadIntercambios++;
  290.                 contadorAsignaciones+=3;
  291.                
  292.             }
  293.             arregloTemporal[j + 1] = llave;
  294.             contadorAsignaciones+= 2;
  295.         }
  296.         contadorAsignaciones++;
  297.         long tiempoFinal = System.currentTimeMillis();
  298.         long tiempoEjecucion = tiempoFinal - tiempoInicial;
  299.        
  300.         conclusion += "El arreglo ha sido ordenado satisfactoriamente con el método de Inserción. \n"
  301.                 + "El algoritmo tardó " + tiempoEjecucion + " milisegundos en ejecutarse.\n"
  302.                         + "Realizó: \n" + contadorComparaciones + " comparaciones.\n"
  303.                                 + contadorAsignaciones + " asignaciones. \n"
  304.                                     + cantidadIntercambios + " intercambios. \n";
  305.        
  306.         return conclusion;
  307.        
  308.     }
  309.    
  310.     public String quicksort(int[] arreglo, int izquierda, int derecha) {
  311.        
  312.         String conclusion = "";
  313.         int arregloTemporal[] = new int[arreglo.length];
  314.         arregloTemporal = arreglo.clone();
  315.         long tiempoInicial = System.currentTimeMillis();
  316.         long contadorComparaciones = 0;
  317.         long contadorAsignaciones = 0;
  318.         long cantidadIntercambios = 0;
  319.         int pivote=arregloTemporal[izquierda];
  320.         contadorAsignaciones++;
  321.         int i=izquierda;      
  322.         int j=derecha;
  323.         contadorAsignaciones += 2;
  324.         int aux;
  325.        
  326.         while(i < j){
  327.             contadorComparaciones++;
  328.            while(arregloTemporal[i] <= pivote && i < j) {
  329.                i++;
  330.                contadorComparaciones++;
  331.            }
  332.            while(arregloTemporal[j] > pivote) {
  333.                j--;
  334.                contadorComparaciones++;
  335.            }          
  336.            if (i < j) {  
  337.                contadorComparaciones++;
  338.                contadorAsignaciones += 2;
  339.                aux= arreglo[i];                    
  340.                arregloTemporal[i]=arregloTemporal[j];
  341.                arregloTemporal[j]=aux;
  342.                cantidadIntercambios += 1;
  343.            }
  344.    }
  345.         long tiempoFinal = System.currentTimeMillis();
  346.         long tiempoDeEjecucion = tiempoFinal - tiempoInicial;
  347.        
  348.         conclusion += "El arreglo ha sido ordenado satisfactoriamente con el método de Quick Sort. \n"
  349.                 + "El algoritmo tardó " + tiempoDeEjecucion + " milisegundos en ejecutarse.\n"
  350.                         + "Realizó: \n" + contadorComparaciones + " comparaciones.\n"
  351.                                 + contadorAsignaciones + " asignaciones. \n"
  352.                                         + cantidadIntercambios + " intercambios. \n";
  353.        
  354.         return conclusion;
  355.     }
  356.    
  357.     public String selectionSort(int arreglo[]) {
  358.        
  359.         String conclusion = "";
  360.         int arregloTemporal[] = new int[arreglo.length];
  361.         arregloTemporal = arreglo.clone();
  362.         long tiempoInicial = System.currentTimeMillis();
  363.         long contadorComparaciones = 0;
  364.         long contadorAsignaciones = 0;
  365.         long cantidadIntercambios = 0;
  366.         int n = arregloTemporal.length;
  367.         contadorAsignaciones++;
  368.  
  369.  
  370.         for (int i = 0; i < n-1; i++) {
  371.             contadorComparaciones++;
  372.             int minimo = i;
  373.             contadorAsignaciones++;
  374.             for (int j = i+1; j < n; j++) {
  375.                 contadorComparaciones++;
  376.                if (arregloTemporal[j] < arregloTemporal[minimo]){
  377.                    contadorComparaciones++;
  378.                    minimo = j;  
  379.                    contadorAsignaciones++;
  380.                }
  381.             }
  382.             int temporal = arregloTemporal[minimo];
  383.             contadorAsignaciones++;
  384.             arregloTemporal[minimo] = arregloTemporal[i];
  385.             cantidadIntercambios++;
  386.             arregloTemporal[i] = temporal;
  387.             contadorAsignaciones++;
  388.         }
  389.         long tiempoFinal = System.currentTimeMillis();
  390.         long tiempoEjecucion = tiempoFinal - tiempoInicial;
  391.        
  392.         conclusion += "El arreglo ha sido ordenado satisfactoriamente con el método de Selección. \n"
  393.                 + "El algoritmo tardó " + tiempoEjecucion  + " milisegundos en ejecutarse.\n"
  394.                         + "Realizó: \n" + contadorComparaciones + " comparaciones.\n"
  395.                                 + contadorAsignaciones + " asignaciones. \n"
  396.                                         + cantidadIntercambios + " intercambios. \n";
  397.        
  398.         return conclusion;
  399.     }
  400.    
  401.     public void menu(){
  402.        
  403.         inicializarMatrizBascula();
  404.         int opcion;
  405.         do{
  406.             String menu = JOptionPane.showInputDialog("Bienvenido al taller No.1 Por favor seleccione una opción."
  407.                     + "\n1. Aplicación de registro de báscula." +
  408.                     "\n2. Matriz NxM con letras aleatorias." +
  409.                     "\n3. Pruebas de ordenamiento y desempeño en arreglos." +
  410.                     "\n0. Cerrar la aplicación."
  411.             );
  412.             menu = menu.trim();
  413.             opcion = Integer.parseInt(menu);
  414.             switch(opcion){
  415.                 case 1:
  416.                     char opcionSubMenu;
  417.                     do{
  418.                        
  419.                      String subMenu = JOptionPane.showInputDialog("Bienvenido al registro de báscula. Por favor seleccione una opción" +
  420.                             "\na. Ingresar datos de un pesaje." +
  421.                             "\nb. Mostrar la cantidad de viajes realizados en total y el peso." +
  422.                             "\nc. Mostrar la cantidad a los 3 destinos y el peso promedio de los 3 destinos." +
  423.                             "\nd. Consultar los viajes por fecha y destino." +
  424.                             "\ne. Salir del submenú de báscula.");
  425.                     subMenu = subMenu.trim();
  426.                     opcionSubMenu = subMenu.charAt(0);
  427.                     switch(opcionSubMenu){
  428.                         case 'a':
  429.                             String placaVehiculo = JOptionPane.showInputDialog("Ingrese la placa del vehículo.");
  430.                             String peso = JOptionPane.showInputDialog("Ingrese el peso del vehículo.");
  431.                             String destino = JOptionPane.showInputDialog("Ingrese el destino del vehículo( 1 para Buenaventura, 2 para Bogotá y 3 para Barranquilla).");
  432.                             String dia = JOptionPane.showInputDialog("Ingrese el día del viaje.");
  433.                             String mes = JOptionPane.showInputDialog("Ingrese el més en el cual se realiza el viaje(como número).");
  434.                             String anio = JOptionPane.showInputDialog("Ingrese el año en el cual se realiza el viaje.");
  435.                             ingresarPesaje(placaVehiculo, peso, destino, dia, mes, anio);
  436.                             break;
  437.                         case 'b':
  438.                             JOptionPane.showMessageDialog(null, mostrarCantidadViajesYPeso());
  439.                             break;
  440.                         case 'c': mostrarCantidadViajesYPesoPorDestino() ; break;
  441.                         case 'd':
  442.                             String diaConsulta = JOptionPane.showInputDialog("Ingrese el día del cual quiere consultar los viajes");
  443.                             String mesConsulta = JOptionPane.showInputDialog("Ingrese el mes (en número) del cual quiere consultar los viajes");
  444.                             String anioConsulta = JOptionPane.showInputDialog("Ingrese el año del cual quiere consultar los viajes");
  445.                             String destinoConsulta = JOptionPane.showInputDialog("Ingrese el destino (en número) del cual quiere consultar los viajes");
  446.                             consultarViajesPorFechaYDestino(diaConsulta, mesConsulta, anioConsulta, destinoConsulta);
  447.                             break;
  448.                         case 'e':
  449.                             JOptionPane.showMessageDialog(null, "Está saliendo del submenú de báscula. Gracias por utilizar nuestros servicios.");
  450.                             break;
  451.                         default: JOptionPane.showMessageDialog(null, "Opción incorrecta. Por favor intente de nuevo.", "Opción Incorrecta", JOptionPane.ERROR_MESSAGE);
  452.                     }  
  453.                     }while ( opcionSubMenu != 'e');
  454.                    
  455.                     break;
  456.                 case 2:
  457.                     int i = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de filas."));
  458.                     int j = Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de columnas."));
  459.                     inicializarMatrizAbecedario(i, j);
  460.                     char opcionSubMenuLetras = JOptionPane.showInputDialog("¿Desea llenar la matriz con letras mayúsculas o minúsculas?" +
  461.                             "\n a. Minúsculas. " +
  462.                             "\n b. Mayúsculas.").charAt(0);
  463.                     switch(opcionSubMenuLetras){
  464.                         case 'a':
  465.                             llenarMatrizAbecedarioMinusculas();
  466.                             JOptionPane.showMessageDialog(null, imprimirMatrizLetras());
  467.                             break;
  468.                         case 'b':
  469.                             llenarMatrizAbecedarioMayusculas();
  470.                             JOptionPane.showMessageDialog(null, imprimirMatrizLetras());
  471.                         break;
  472.                         default: JOptionPane.showConfirmDialog(null, "Opción Incorrecta. Por favor intente de nuevo.", "Opción Incorrecta", JOptionPane.ERROR_MESSAGE);
  473.                     }
  474.                     break;
  475.                 case 3:
  476.                     inicializarArreglosOrdenamiento();
  477.                     char ordenamiento = ' ';
  478.                     do{
  479.                       String subMenuOrdenamiento = JOptionPane.showInputDialog("Bienvenido al submenú de ordenamiento. Aquí haremos pruebas de rendimiento sobre arreglos de distinos tamaños con 3 métodos diferentes de ordenamiento (Inserción, Selección y Quick Sort).\n"
  480.                             + "Por favor que tamaño de arreglo desea probar bajo los 3 métodos anteriormente seleccionados:\n"
  481.                             + "a. Arreglo de 10.000 posiciones.\n"
  482.                             + "b. Arreglo de 50.000 posiciones. \n"
  483.                             + "c. Arreglo de 100.000 posiciones. \n"
  484.                             + "d. Arreglo de 500.000 posiciones. \n"
  485.                             + "e. Arreglo de 1'000.000 posiciones. \n"
  486.                             + "f. Salir del submenú de ordenamiento." );
  487.                     subMenuOrdenamiento = subMenuOrdenamiento.trim();
  488.                     ordenamiento = subMenuOrdenamiento.charAt(0);
  489.                     switch(ordenamiento){
  490.                         case 'a': JOptionPane.showMessageDialog(null, insertionSort(arreglo10) +
  491.                                 selectionSort(arreglo10) +
  492.                                 quicksort(arreglo10, 0, arreglo10.length - 1));
  493.                         break;
  494.                         case 'b':
  495.                             JOptionPane.showMessageDialog(null, insertionSort(arreglo50) +
  496.                                 selectionSort(arreglo50) +
  497.                                 quicksort(arreglo50, 0, arreglo50.length - 1));
  498.                             break;
  499.                         case 'c':
  500.                             JOptionPane.showMessageDialog(null, insertionSort(arreglo100) +
  501.                                 selectionSort(arreglo100) +
  502.                                 quicksort(arreglo100, 0, arreglo100.length - 1));
  503.                             break;
  504.                         case 'd':
  505.                             JOptionPane.showMessageDialog(null, insertionSort(arreglo500) +
  506.                                 selectionSort(arreglo500) +
  507.                                 quicksort(arreglo500, 0, arreglo500.length - 1));
  508.                             break;
  509.                         case 'e':
  510.                             JOptionPane.showMessageDialog(null, insertionSort(arreglo1000) +
  511.                                 selectionSort(arreglo1000) +
  512.                                 quicksort(arreglo1000, 0, arreglo1000.length - 1));
  513.                             break;
  514.                         case 'f':
  515.                             JOptionPane.showMessageDialog(null, "Está saliendo del submenú de ordenamiento. Gracias por utilizar nuestros servicios.");
  516.                             break;
  517.                         default: JOptionPane.showConfirmDialog(null, "Opción Incorrecta. Por favor intente de nuevo.", "Opción Incorrecta", JOptionPane.ERROR_MESSAGE);
  518.                        
  519.                     }  
  520.                     }while (ordenamiento != 'f');
  521.                    
  522.                            
  523.                     break;
  524.                 case 0: JOptionPane.showMessageDialog(null, "Gracias por utilizar nuestra aplicación!");
  525.                 break;
  526.                 default: JOptionPane.showMessageDialog(null, "Opción incorrecta. Por favor intente de nuevo.");
  527.             }
  528.         }while (opcion != 0);
  529.     }
  530.    
  531.     public static void main(String[] args) {
  532.         Taller1CiclosArraysYMatrices taller = new Taller1CiclosArraysYMatrices();
  533.         taller.menu();
  534.     }
  535.  
  536.     private void limpiarArreglo() {
  537.         for (int i = 0; i < listaViajes.length; i++) {
  538.             listaViajes[i] = null;
  539.            
  540.         }
  541.     }
  542.  
  543.  
  544.  
  545.    
  546. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!