Java Code Frank: Tipo de datos primitivos en java

TiposDatosPrimitivos.java

  1 /*
  2  * To change this template, choose Tools | Templates
  3  * and open the template in the editor.
  4  */
  5 
  6 package pruebas;
  7 
  8 import java.util.ArrayList;
  9 
 10 /**
 11  *
 12  * @author Igor
 13  */
 14 public class TiposDatosPrimitivos {
 15     /*
 16      * TIPOS PRIMITIVOS
 17      * En java hay 8 tipos de datos primitivos, lo que significa básicos
 18      * o fundamentales, a partir de los cuales se construyen todos los demás.
 19      * Su uso es especialmente para realizar operaciones aritmeticas,
 20      * representar caracteres y valores lógicos.
 21      */
 22 
 23     /*
 24      * Tipo byte;
 25      * Este tipo de dato permite declarar variables de tipo byte, ocupan
 26      * 1 byte en memoria y sus valores estan dentro del rango [-128 a 127]
 27      * ejemplo:
 28      */
 29     static class GeneradorCódigo{
 30         static String codigo = "";
 31         static byte n;
 32 
 33         //método que genera codigos aleatorios con numero de
 34         //digitos menores o iguales a 14 digitos
 35         public static String generaCodigoAleatorio(){
 36             String temp = "";
 37             int i = 0;
 38             while(i <= 6){
 39                 n = (byte) (Math.random()*100);
 40                 if(n != 0){
 41                     codigo += n%10;
 42                 }
 43                 i++;
 44             }
 45             temp = codigo;
 46             codigo = "";
 47             return temp;
 48 
 49         }
 50     }
 51 
 52     /*
 53      * Tipo short
 54      * Este tipo de dato trabaja con variables de tipo primitivo, ocupa en
 55      * memoria 2 bytes y sus valores se encuentran entre el rando de:
 56      * [-32768 a 32767].
 57      * ejemplos:
 58      */
 59     public static short contarVocales(String cadena, char vocal){
 60         short numVocal = 0;
 61         for(short i = 0; i < cadena.length(); i++){
 62             if(cadena.charAt(i) == vocal){
 63                 numVocal++;
 64             }
 65         }
 66         return numVocal;
 67     }
 68 
 69     /*
 70      * Tipo int
 71      * tipo de dato que se utiliza para declarar variables de 4 bytes,
 72      * los valores oscilan en el intevalor de [-2147483648 a 2147483647]
 73      * ejemplo:
 74      */
 75     public static int sumaDigitos(int num){
 76         if(num > 9){
 77             return num%10 + sumaDigitos(num / 10);
 78         }
 79         else{
 80             return num;
 81         }
 82     }
 83 
 84     /*
 85      * Tipo long
 86      * Tipo de dato para declarar enteros largos sus valores se encuentran
 87      * en el intervalo [-9223372036854775808 a 9223372036854775807].
 88      * Permite almacenar variables de 8 bytes.
 89      * ejemplo:
 90      */
 91     public static long factorial(long num){
 92         if(num == 0 || num == 1){
 93             return 1;
 94         }
 95         else{
 96             return num * factorial(num - 1);
 97         }
 98     }
 99 
100     /*
101      * Tipo float
102      * Este tipo de dato permite representar numeros reales de 32 bits, su
103      * rengo es [1.4E-45 a 3.4028235E38]. Si se quiere asignar un valor
104      * inicial a un numero de este tipo se coloca al final una 'f'
105      * ejemplo:
106      */
107     public static float calcularAreaCirculo(float radio){
108         final float PI = 3.1416f;
109         return PI * radio * radio;
110     }
111 
112     /*
113      * Tipo double
114      * Este tipo de dato permite representar numeros reales de 64 bits, son
115      * mas precisos su rango es [4.9E-324 a 1.7976931348623157E308]
116      * ejemplo:
117      */
118     public static double senoDe(double num){
119         return Math.sin(num);
120     }
121 
122     /*
123      * Tipo char
124      * Tipo de dato para representar caracteres, según la tabla de caracteres
125      * Unicode UTF
126      * ejmeplo:
127      */
128     public static ArrayList<String> tablaCaracteresUnicode(){
129         ArrayList<String> lista = new ArrayList<String>();
130         for(int i = 0; i <= 34168; i++){
131             char car = (char) i;
132             lista.add(car+"");
133         }
134         return lista;
135     }
136 
137     /*
138      * tipo boolean
139      * Tipo de dato que solo puede representar 2 estados true: verdadero,
140      * false: falso
141      * ejemplo:
142      */
143     public static boolean numeroPrimo(int num, int mitad){
144         if(mitad > 1){
145             if(num % mitad == 0){
146                 return false;
147             }
148             else{
149                 return numeroPrimo(num, mitad - 1);
150             }
151         }
152         return true;
153     }
154     
155 }
156 
157

-->

Probando la clase
PruebaTipoDatosPrimitivos.java

  1 /*
  2  * To change this template, choose Tools | Templates
  3  * and open the template in the editor.
  4  */
  5 
  6 //nombre del paquete
  7 package pruebas;
  8 
  9 //importando clase que se usarán
 10 import java.util.ArrayList;
 11 import javax.swing.JOptionPane;
 12 import javax.swing.JScrollPane;
 13 import javax.swing.JTable;
 14 import pruebas.TiposDatosPrimitivos.*;
 15 
 16 /**
 17  *
 18  * @author Igor
 19  */
 20 public class PruebaTipoDatosPrimitivos {
 21     //un método para el menu
 22     public static int menu(){
 23         //se declara la variable opcion para tomar los valores que ingrese
 24         //el usuaario
 25         int opcion = 0;
 26         //se crea la referencia menu de tipo String cargando el menú
 27         String menu = "\nMenu:"
 28                 + "\n1. Probar byte"
 29                 + "\n2. Probar short"
 30                 + "\n3. Probar int"
 31                 + "\n4. Probar long"
 32                 + "\n5. Probar float"
 33                 + "\n6. Probar double"
 34                 + "\n7. Probar char"
 35                 + "\n8. Probar boolean"
 36                 + "\n9. Salir"
 37                 + "\nopcion: ";
 38         //se crea un bloque try - cacth para capturar la excepcion:
 39         //no se pueden ingresar cadenas solo numeros enteros
 40         try{
 41             //aqui va la sentencia que puede generar la excepcion
 42             opcion = Integer.parseInt(JOptionPane.showInputDialog(menu));
 43         }catch(Exception ex){
 44             //aqui se trata la excepcion
 45             JOptionPane.showConfirmDialog(null, "Excepcion: "+ex.getMessage());
 46         }
 47         //retorna el valor ingresado por el usuario
 48         return opcion;
 49     }
 50 
 51     //se crea el metodo main, aqui va el programa principal
 52     public static void main(String[] args) {
 53         //declarar variable opcion para ver que opcion ingresa el usuario
 54         int opcion = 0;
 55         //se crea un bloque try - catch para capturar la excepcion
 56         //en este caso el usuario no puede ingresar otro caracter que no sean
 57         //los numeros permitidos en el menu
 58         try{
 59             //se crea el bucle do-while para poder repetir la opcion del menu
 60             do{
 61                 //la opcion llama al metodo menu que pide que ingrese un
 62                 //valor entero y se guarda en opcion
 63                 opcion = menu();
 64                 //según los valores ingresados de 1 - 8 se crea esta sentecia
 65                 //de seleccion multiple para tratar los casos
 66                 switch(opcion){
 67                         /*
 68                          * el primer caso Genera una tabla de 10000 codigos
 69                          * diferentes
 70                          */
 71                     case 1:
 72                         //Probando clase GenerarCodigo
 73                         ArrayList<String> list = new ArrayList<String>();
 74                         for(int k = 0; k<10000; k++){
 75                             list.add(GeneradorCódigo.generaCodigoAleatorio());
 76                         }
 77                         Object datos[][] = new Object[list.size()][3];
 78                         String[] nombreColumnas = {"n","Codigo","Cant. Digitos"};
 79                         for(int i = 0; i<list.size(); i++){
 80                             datos[i][0] = i + 1;
 81                             datos[i][1] = list.get(i);
 82                             datos[i][2] = list.get(i).length();
 83 
 84                         }
 85                         JTable tabla = new JTable(datos, nombreColumnas);
 86                         JScrollPane scroll = new JScrollPane(tabla);
 87                         JOptionPane.showConfirmDialog(null, scroll);
 88                         break;
 89                         /*
 90                          * el segundo caso cuenta las vocales que hay en una
 91                          * frase.
 92                          */
 93                     case 2:
 94                         //Probando método ContarVocales
 95                         String cadena = JOptionPane.showInputDialog(
 96                                 "Ingrese su frase");
 97                         JOptionPane.showMessageDialog(null,
 98                                 "\nFrase: "+cadena+
 99                                 "\nvocal a: "+TiposDatosPrimitivos.contarVocales(
100                                 cadena, 'a')+
101                                 "\nvocal e: "+TiposDatosPrimitivos.contarVocales(
102                                 cadena, 'e')+
103                                 "\nvocal i: "+TiposDatosPrimitivos.contarVocales(
104                                 cadena, 'i')+
105                                 "\nvocal o: "+TiposDatosPrimitivos.contarVocales(
106                                 cadena, 'o')+
107                                 "\nvocal u: "+TiposDatosPrimitivos.contarVocales(
108                                 cadena, 'u'));
109                         break;
110                         /*
111                          * este caso suma los digitos de un numero entero de 32
112                          * bits
113                          */
114                     case 3:
115                         //probando metodo sumaDigitos
116                         int num = Integer.parseInt(JOptionPane.showInputDialog(
117                                 "Ingrese numero entero:"));
118                         JOptionPane.showMessageDialog(null,"\nNumero: "+num+
119                                 "\nSumaDigitos: " +
120                                 TiposDatosPrimitivos.sumaDigitos(num));
121                         break;
122                         /*
123                          * este método calcula el factorial de un numero
124                          */
125                         //probando metodo de factorial
126                     case 4:
127                         long n = Long.parseLong(JOptionPane.showInputDialog(
128                                 "Ingrese numero entero:"));
129                         JOptionPane.showMessageDialog(null, "\nNumero: "+n+
130                                 "\nFactorial: "+TiposDatosPrimitivos.factorial(
131                                 n));
132                         break;
133                         /*
134                          * el quinto método calcula el área del círculo
135                          */
136                         //probando metodo calcularAreaCirculo
137                     case 5:
138                         float r = Float.parseFloat(JOptionPane.showInputDialog(
139                                 "Ingrese radio:"));
140                         JOptionPane.showMessageDialog(null, "\nNumero: "+r+
141                                 "\nArea Circulo: "+
142                                 TiposDatosPrimitivos.calcularAreaCirculo(
143                                 r));
144                         break;
145                         /*
146                          * este método calcula el seno de un angulo
147                          */
148                     case 6:
149                         double a = Double.parseDouble(
150                                 JOptionPane.showInputDialog("Ingrese ángulo:"));
151                         JOptionPane.showMessageDialog(null, "\na: "+a+
152                                 "\nSeno de a: "+
153                                 TiposDatosPrimitivos.senoDe(a));
154                         break;
155                         /*
156                          * este metodo genera la lista de caracteres unicode
157                          * y los muestra en una tabla
158                          */
159                     case 7:
160                         ArrayList<String> listCar = TiposDatosPrimitivos.
161                                 tablaCaracteresUnicode();
162                         Object dat[][] = new Object[listCar.size()][3];
163                         String[] nombreColumnas2 = {"n","HEX","Caracter"};
164                         for(int i = 0; i<listCar.size(); i++){
165                             dat[i][0] = i + 1;
166                             dat[i][1] = Long.toHexString((long)i).toUpperCase();
167                             dat[i][2] = listCar.get(i);
168 
169                         }
170                         JTable tabl = new JTable(dat, nombreColumnas2);
171                         JScrollPane scroll2 = new JScrollPane(tabl);
172                         JOptionPane.showMessageDialog(null, scroll2);
173                         break;
174                         /*
175                          * este método verifica si un numero es primo o no
176                          */
177                     case 8:
178                         int numero = Integer.parseInt(
179                                 JOptionPane.showInputDialog("Ingrese numero"));
180                         if(TiposDatosPrimitivos.numeroPrimo(numero, numero/2)){
181                             JOptionPane.showMessageDialog(null, "Si es Primo");
182                         }
183                         else{
184                             JOptionPane.showMessageDialog(null, "no es primo");
185                         }
186                 }
187                 //condicion para salir del bucle
188             }while(opcion != 9);
189             //se trata la excepcion
190         }catch(Exception ex){
191             JOptionPane.showConfirmDialog(null, "Excepcion: "+ex.getMessage());
192         }
193     }
194 }
195 
196