fundamentos de programación con java
TRANSCRIPT
Fundamentos de Programación con
Java.Autor/compilador: ISC Raúl Oramas Bustillos, 2012.
[email protected], www.profesorjava.com
Este obra está bajo una licencia Creative Commons Atribución-NoComercial 2.5 México.
Tabla de Contenidos
1.Introducción a Java.............................................................................................................................................. 5
Un programa simple en Java............................................................................................................................. 6
Otro programa simple en Java........................................................................................................................... 7
2.Programas simples.............................................................................................................................................. 8
Variables............................................................................................................................................................ 9
Operaciones matemáticas simples..................................................................................................................10
Precedencia de los operadores de Java..........................................................................................................13
Leer números desde el teclado........................................................................................................................ 14
Constantes con nombre................................................................................................................................... 16
División de números enteros...........................................................................................................................18
Overflow/underflow.......................................................................................................................................... 20
¿Qué es la precisión?...................................................................................................................................... 21
Las conversiones numéricas...........................................................................................................................22
La clase Math.................................................................................................................................................. 23
3.Instrucciones de selección................................................................................................................................. 26
Comparación de dos valores........................................................................................................................... 27
La instrucción if simple.................................................................................................................................... 28
Instrucciones simples y compuestas...............................................................................................................30
La instrucción if/else........................................................................................................................................ 31
Instrucciones if anidadas................................................................................................................................. 34
La instrucción if/else/if..................................................................................................................................... 36
Revisión de dos condiciones o más.................................................................................................................38
La instrucción switch........................................................................................................................................ 40
4.Instrucciones de repetición................................................................................................................................ 43
Ciclo while....................................................................................................................................................... 44
Ciclos infinitos.................................................................................................................................................. 48
Ciclos while con cero iteraciones.....................................................................................................................49
Ciclos controlados por centinelas....................................................................................................................50
Instrucción de repetición do...while.................................................................................................................. 51
El ciclo for........................................................................................................................................................ 52
Ciclo for compuesto......................................................................................................................................... 53
Ciclos anidados............................................................................................................................................... 54
Instrucción break............................................................................................................................................. 57
Instrucción continue......................................................................................................................................... 59
El ciclo while.................................................................................................................................................... 60
Ciclos controlador por contador....................................................................................................................... 60
El ciclo while controlado por un centinela........................................................................................................62
Ciclo do/while................................................................................................................................................... 63
5.Métodos............................................................................................................................................................. 64
Declaración de un método............................................................................................................................... 65
Declaración de un método con un parámetro..................................................................................................68
Métodos void vs. return................................................................................................................................... 69
Declaración de métodos con múltiples parámetros.........................................................................................71
Orden en el paso de parámetros.....................................................................................................................72
Reutilización de código.................................................................................................................................... 73
Métodos sobrecargados (overload).................................................................................................................76
6.Arreglos de una dimensión................................................................................................................................ 77
Declaración de un arreglo................................................................................................................................ 78
Crear un arreglo............................................................................................................................................... 79
Asignar valores a un arreglo............................................................................................................................ 80
El tamaño del arreglo y valores por default.....................................................................................................81
Acceder a los elementos de un arreglo...........................................................................................................82
Inicialización de un arreglo al declararlo..........................................................................................................83
Inicializar un arreglo con valores desde el teclado..........................................................................................84
Inicializar un arreglo con valores aleatorios.....................................................................................................85
Imprimir el contenido de un arreglo.................................................................................................................86
Sumar todos los elementos del arreglo...........................................................................................................87
Encontrar el elemento mayor del arreglo.........................................................................................................88
Intercambio aleatorio de los elementos del arreglo.........................................................................................89
Desplazar elementos del arreglo.....................................................................................................................90
Instrucción for mejorada.................................................................................................................................. 91
Paso de arreglos a los métodos...................................................................................................................... 92
Regresar un arreglo desde un método............................................................................................................94
Listas de argumentos de longitud variable......................................................................................................95
Uso de argumentos de línea de comandos.....................................................................................................96
7.Arreglos bidimensionales................................................................................................................................... 97
Introducción..................................................................................................................................................... 98
Declaración de un arreglo................................................................................................................................ 99
Crear un arreglo............................................................................................................................................. 100
Asignar valores a un arreglo..........................................................................................................................101
El tamaño del arreglo y valores por default...................................................................................................102
Acceder a los elementos de un arreglo.........................................................................................................103
Inicialización de un arreglo al declararlo........................................................................................................104
Inicializar un arreglo bidimensional con valores desde el teclado..................................................................105
Inicializar un arreglo bidimensional con valores aleatorios............................................................................106
Imprimir el contenido de un arreglo bidimensional.........................................................................................107
Sumar todos los elementos de un arreglo bidimensional..............................................................................108
Suma los elementos de un arreglo bidimensional por columna....................................................................109
Suma por renglón y encuentra el mayor........................................................................................................110
Intercambio aleatorio de un arreglo bidimensional.........................................................................................111
1. Introducción a Java.
Contenido:
Un programa simple en Java.................................................................................................................................. 6
Otro programa simple en Java................................................................................................................................ 7
Fundamentos de Programación con Java → Introducción a Java. 6
Un programa simple en Java.
HolaMundo.java
public class HolaMundo{ public static void main( String[] args ) { System.out.println( "Hola Mundo." ); } }
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Introducción a Java. 7
Otro programa simple en Java.
Bienvenido.java
//Programa para imprimir texto.public class Bienvenido{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { System.out.print( "¡Bienvenido " ); System.out.println( "al Curso Java!" ); } //fin del método main} //fin de la clase Bienvenido
© Raúl Oramas Bustillos 2012.
2. Programas simples.
Contenido:
Variables............................................................................................................................................................... 10
Operaciones matemáticas simples....................................................................................................................... 11
Precedencia de los operadores de Java...............................................................................................................14
Leer números desde el teclado............................................................................................................................. 15
Constantes con nombre........................................................................................................................................ 17
División de números enteros................................................................................................................................ 19
Overflow/underflow............................................................................................................................................... 21
¿Qué es la precisión?........................................................................................................................................... 22
Las conversiones numéricas................................................................................................................................ 23
La clase Math....................................................................................................................................................... 24
Fundamentos de Programación con Java → Programas simples. 9
Variables.
DobleNumero.java
//Programa para calcular el doble de un número.public class DobleNumero { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { int numero; //declaración de una variable int doble; //mensaje de usuario System.out.println( "Calcular el doble de un número." ); System.out.println( "" ); numero = 5; //asignación del valor a la variable doble = numero * 2; //expresión aritmética System.out.println( "El doble de " + numero + " es " + doble ); } //fin del método main} //fin de la clase DobleNumero
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 10
Operaciones matemáticas simples.
AreaRectangulo.java
//Programa que calcula e imprime el área de un rectángulo.public class AreaRectangulo { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declaración e inicialización de las variables int largo = 10; //el largo del rectángulo int ancho = 4; //el ancho del rectángulo int area; //el área del rectángulo
//mensaje de usuario System.out.println( "Calcular el área de un rectángulo." ); System.out.println( "" ); //calcula el área area = largo * ancho; //expresión //imprime el área del rectángulo System.out.println( "El área del rectángulo es: " + area ); } //fin del método main} //fin de la clase AreaRectangulo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 11
PieMetro.java
//Programa que calcula el equivalente de pies a metros.public class PieMetro{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declara una variable de tipo double y la inicializa double nPies = 16; //mensaje de usuario System.out.println( "Convierte pies a metros." ); System.out.println( "" );
//proceso double metros = nPies * 0.305; //salida System.out.println( nPies + " son " + metros + " metros." ); } //fin del método main } //fin de la clase PieMetro
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 12
AreaTriangulo.java
//Programa que calcula el área de un triángulo. public class AreaTriangulo { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declaración de las variables int base, altura; double area; //inicialización de la base y la altura
base = 10; altura = 19; //calcula el área del triángulo area = ( base * altura ) / 2.0; //imprime el resultado System.out.println( "El area del triángulo es ", area ); } //fin del método main } //fin de la clase AreaTriangulo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 13
Precedencia de los operadores de Java.
Promedio.java
//Programa que calcula el promedio de tres calificaciones.public class Promedio { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declaración y asignación de los valores double calif1 = 10.0, calif2 = 10.0, calif3 = 10.0;
double promedio; //mensaje de usuario System.out.println( "Promedio de tres calificaciones." ); System.out.println( "" ); promedio = calif1 + calif2 + calif3 / 3; System.out.println( "El promedio incorrecto es: " + promedio );
promedio = ( calif1 + calif2 + calif3 ) / 3; System.out.println( "El promedio correcto es: " + promedio ); } //fin del método main} //fin de la clase Promedio
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 14
Leer números desde el teclado.
DobleNumero.java
//Programa para calcular el doble de un número.import java.util.Scanner; //para leer del tecladopublic class DobleNumero { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //Crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner( System.in ); int numero; int doble; //mensaje de usuario System.out.println( "Calcular el doble de un número." ); System.out.println( "" );
//lectura del número entero System.out.print( "Introduce un número: " ); numero = entrada.nextInt(); //asignación del valor a la variable //calcula el doble del número doble = numero * 2; //imprime el resultado System.out.println( "El doble de " + numero + " es " + doble ); } //fin del método main} //fin de la clase DobleNumero
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 15
AreaCirculo.java
//Calcula el área de un círculo.import java.util.Scanner; //para leer del tecladopublic class Circulo{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //Crea objeto para leer datos Scanner entrada = new Scanner( System.in );
//declaración de variables double radio, area;
//mensaje de usuario System.out.println( "Calcular el área de un círculo." ); System.out.println( "" ); //obtiene el radio del círculo System.out.print( "Radio? " ); radio = entrada.nextDouble(); //calcula el área area = radio * radio * 3.14159; //imprime el resultado System.out.println( "El área del círculo es: " + area ); } //fin del método main} //fin de la clase AreaCirculo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 16
Constantes con nombre.
AreaCirculo.java
//Calcula el área de un círculo.import java.util.Scanner; //para leer del tecladopublic class Circulo{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declara una constante con nombre final double PI = 3.14159;
//Crea objeto para leer datos Scanner entrada = new Scanner( System.in );
//declaración de variables double radio, area;
//mensaje de usuario System.out.println( "Calcular el área de un círculo." ); System.out.println( "" ); //obtiene el radio del círculo System.out.print( "Radio? " ); radio = entrada.nextDouble(); //calcula el área area = radio * radio * PI; //imprime el resultado System.out.println( "El área del círculo es: " + area ); } //fin del método main} //fin de la clase AreaCirculo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 17
Conversion.java
//Programa que convierte pies y pulgadas a centímetros.import java.util.Scanner; //para leer del tecladopublic class Conversion { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { final double CENTIMETRO_PULGADA = 2.54; final int PULGADA_PIE = 12; Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "Convertir pies y pulgadas a cms." ); System.out.println( "" ); //lectura de los datos System.out.print( "Pies? " ); int pie = entrada.nextInt(); System.out.println( "Pulgadas? " ); int pulgada = entrada.nextInt(); //procesa los datos de entrada int totalPulgadas = PULGADA_PIE * pie + pulgada; double cms = CENTIMETRO_PULGADA * totalPulgadas; //imprime el resultado System.out.println( "Total de pulgadas: " + totalPulgadas ); System.out.println( totalPulgadas + " = " + cms + " centímetros." ); } //fin del método main} //fin de la clase Conversion
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 18
División de números enteros.
Division.java
//Programa para calcular la división y módulo de dos números enteros. import java.util.Scanner; //para leer del teclado public class Division { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //entrada System.out.print( "Introduce un número? " ); int num1 = entrada.nextInt(); System.out.print( "Introduce otro número? " ); int num2 = entrada.nextInt();
//proceso int div1 = num1 / num2; int mod1 = num1 % num2; int div2 = num2 / num1; int mod2 = num2 % num1; //salida System.out.printf( div1 ); System.out.printf( mod1 ); System.out.printf( div2 ); System.out.printf( mod2 ); } //fin del método main } //fin de la clase Division
Notas:
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 19
MinutoSegundo.java
//Programa que obtiene los minutos y segundos de una cantidad de//segundos leída desde el teclado.import java.util.Scanner; //para leer del tecladopublic class MinutoSegundo { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //lectura de los datos System.out.print( "Cantidad de segundos: " ); int segundos = entrada.nextInt(); //procesa los datos int minutos = segundos / 60; //encuentra los minutos int restoSeg = segundos % 60; //obtiene los seg restantes //imprime el resultado System.out.println( segundos + " segundos equivalen a " + minutos + " minutos y " + restoSeg + " segundos." ); } //fin del método main} //fin de la clase MinutoSegundo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 20
Overflow/underflow.
Desbordamiento.java
//Programa con valores overflow/underflow.public class Desbordamiento { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { //declaración e inicialización de dos variables int valor1 = 2147483647 + 1; int valor2 = 2147483648 1;; //imprime los resultados System.out.println( valor1 ); //overflow System.out.println( valor1 ); //underflow } //fin del método main} //fin de la clase Desbordamiento
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 21
¿Qué es la precisión?.
PuntoFlotante.java
//Programa que ilustra el concepto de precisión.public class PuntoFlotante{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { System.out.println( 1.0 – 0.1 – 0.1 – 0.1 – 0.1 – 0.1 ); //no imprime 0.5 System.out.println( 1.0 – 0.9 ); //no imprime 0.1 System.out.println( 10.03 – 100 ); //perdida de precisión System.out.println( 2.0 – 1.1 ); //no imprime 0.9 System.out.println( 100 – 4.35 ); //no imprime 435.0 } //fin del método main} //fin de la clase PuntoFlotante
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 22
Las conversiones numéricas.
ConversionNumerica.java
//Programa que demuestra la conversión de tipos.public class ConversionNumerica { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { System.out.println( 3 * 4.5 ); //es lo mismo que 3.0 * 4.5 System.out.println( ( int )40.7 ); System.out.println( ( double ) 1 / 2 ); } //fin del método main} //fin de la clase ConversionNumerica
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 23
La clase Math.
VolumenCilindro.java
//Programa que calcula el volumen de un cilindro.import java.util.Scanner; //para leer del tecladopublic class VolumenCilindro { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "Calcula el volumen de un cilindro." ); System.out.println( "" ); //lectura de los datos System.out.print( "Radio? " ); double radio = entrada.nextDouble(); System.out.print( "Altura? " ); double altura = entrada.nextDouble(); //proceso de los datos double area = Math.pow( radio, 2 ) * Math.PI; double volumen = area * altura; //impresión de los resultados System.out.println( "Área cilindro: " + area ); System.out.println( "Volumen cilindro: " + volumen ); } //fin del método main} //fin de la clase VolumenCilindro
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 24
Hipotenusa.java
//Programa para calcular la hipotenusa de un triángulo rectángulo.import java.util.Scanner;public class Hipotenusa { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "Hipotenusa de un triángulo rectángulo." ); System.out.println( "" ); //lectura de los datos System.out.print( "Ingresa los valores para el cateto a y b: " ); int catetoA = entrada.nextInt(); int catetoB = entrada.nextInt(); //procesa los datos int hipotenusa = ( int ) Math.sqrt( catetoA * catetoA + catetoB * catetoB ); //imprime el resultado System.out.println( "La hipotenusa es: " + hipotenusa ); } //fin del método main} //fin de la clase Hipotenusa
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Programas simples. 25
Distancia.java
//Programa para calcular la distancia entre dos puntos.import java.util.Scanner; //para leer del tecladopublic class Distancia { //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "Calcula la distancia entre dos puntos" ); System.out.println( "(x1,y1) y (x2,y2)." ); System.out.println( "" ); //lectura de los datos System.out.print( "Introduce la coordenada (x1,y1): "); int x1 = entrada.nextInt(); int y1 = entrada.nextInt(); System.out.print( "Introduce la coordenada (x2,y2): "); int x2 = entrada.nextInt(); int y2 = entrada.nextInt(); //procesa los datos double distancia = Math.sqrt( Math.pow( x2x1 , 2 ) + Math.pow( y2 y1 , 2 ) ); //imprime el resultado System.out.println( "La distancia entre los dos puntos es: " + distancia ); } //fin del método main} //fin de la clase Distancia
© Raúl Oramas Bustillos 2012.
3. Instrucciones de selección.
Contenido:
Comparación de dos valores................................................................................................................................ 28
La instrucción if simple.......................................................................................................................................... 29
Instrucciones simples y compuestas.................................................................................................................... 31
La instrucción if/else............................................................................................................................................. 32
Instrucciones if anidadas...................................................................................................................................... 35
La instrucción if/else/if.......................................................................................................................................... 37
Revisión de dos condiciones o más...................................................................................................................... 39
La instrucción switch............................................................................................................................................. 41
Fundamentos de Programación con Java → Instrucciones de selección. 27
Comparación de dos valores.
ExpresionRelacional.java
//Operadores de igualdad y relacionales public class ExpresionRelacional { public static void main( String[] args ) { System.out.println( "10 > 3 es " + ( 10 > 3 ) ); System.out.println( "10 < 3 es " + (10 < 3 ) ); System.out.println( "10 >= 3 es " + ( 10 >= 3 ) ); System.out.println( "10 <= 3 es " + ( 10 <= 3 ) ); System.out.println( "10 == 3 es " + ( 10 == 3 ) ); System.out.println( "10 != 3 es " + ( 10 != 3 ) ); } //fin del método main } //fin de la clase ExpresionRelacional
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 28
La instrucción if simple.
Comparacion.java
//If simple.public class Comparacion{ public static void main(String args[]) { int x = 10000; if( x > 5000 ) //¿ x es mayor que 5000? x = 1000; //cambia el valor x si la condición es true System.out.println( x ); } //fin del método main} //fin de la clase Comparacion
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 29
Multiplos.java
//If simple.import java.util.Scanner; //para leer del tecladopublic class Multiplos { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //lee un número System.out.print( "Ingresa un número entero: " ); int numero = entrada.nextInt(); if( numero % 5 == 0 ) System.out.println( "El número es múltiplo de 5." ); if( numero % 2 == 0 ) System.out.println( "El número es par." ); } //fin del método main} //fin de la clase Multiplos
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 30
Instrucciones simples y compuestas.
ValorAbsoluto.java
//Programa que determina el valor absoluto de un número.import java.util.Scanner; //para leer del tecladopublic class ValorAbsoluto { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //operación de lectura System.out.print( "Introduce un número: " ); int numero = entrada.nextInt(); if( numero < 0 ) //¿Es número menor que cero? { numero = numero; //le cambiamos el signo } //fin if
//imprime el valor absoluto System.out.println( "El valor absoluto es " + numero ); } //fin del método main} //fin de la clase ValorAbsoluto
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 31
La instrucción if/else.
ParImpar.java
//Instrucción if/else.import java.util.Scanner; //para leer del tecladopublic class ParImpar { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //operación de lectura System.out.print( "Introduce un número: " ); int num = entrada.nextInt(); if( numero % 2 == 0 ) System.out.println( num + " es par." ); else
System.out.println( num + " es impar." ); } //fin del método main} //fin de la clase ParImpar
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 32
Suma.java
//Programa para practicar sumasimport java.util.Scanner; //para leer del tecladopublic class Suma { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in );
//genera dos números aleatorios con el método random int numero1 = ( int )( Math.random() * 10 ); int numero2 = ( int )( Math.random() * 10 ); //muestra la pregunta al usuario System.out.print( "¿Cuánto es " + numero1 + " + " + numero2 + " ? " ); int respuesta = entrada.nextInt(); //compara la respuesta if( numero1 + numero2 == respuesta ) { System.out.println( "La respuesta es correcta." ); } //fin if else { System.out.println( "La respuesta es incorrecta." ); } //fin else } //fin del método main} //fin de la clase Suma
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 33
Resta.java
//Programa para practicar restas.import java.util.Scanner; //para leer del tecladopublic class Resta { public static void main( String[] args ) { //genera los números aleatorios int numero1 = ( int )( Math.random() * 10 ); int numero2 = ( int )( Math.random() * 10 ); //si numero1 < numero2 intercambia los valores if( numero1 < numero2 ) { int temp = numero1; //variable local a if numero1 = numero2; numero2 = temp; } //fin if //pregunta al usuario System.out.print( "Cuanto es " + numero1 + " " + numero2 + "? " );
//lee la respuesta Scanner entrada = new Scanner( System.in ); int respuesta = entrada.nextInt(); //compara la respuesta if( numero1 numero2 == respuesta ) System.out.println( "La respuesta es correcta." ); else System.out.println( "La respuesta es incorrecta." ); } //fin del método main} //fin de la clase Resta
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 34
Instrucciones if anidadas.
Adivinanza.java
//Programa para jugar adivinanzas.import java.util.Scanner; //para leer del tecladopublic class Adivinanza { public static void main( String[] args ) { //genera el número secreto int numeroSecreto = ( int )( Math.random() * 10 ); Scanner entrada = new Scanner( System.in ); //pide un número al usuario System.out.print( "Piensa un número entre 0 y 9: " ); int numero = entrada.nextInt(); //evalúa if( numero == numeroSecreto ) System.out.println( "¡Adivinaste!" ); else { if( numero < numeroSecreto ) System.out.println( "¡Frío!" ); else System.out.println( "¡Caliente!" ); } //fin else } //fin del método main} //fin de la clase Adivinanza
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 35
Calificacion.java
//Utiliza if/else anidados para evaluar una calificación.import java.util.Scanner; //para leer del tecladopublic class Calificacion{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); System.out.print( "Calificación (110)? " ); //indicador //lee calificación del teclado int calif = entrada.nextInt(); if( calif >= 9 ) System.out.println( "La calificación es excelente." ); else if( calif >= 8 ) System.out.println( "La calificación es buena." ); else if( calif >= 7 ) System.out.println( "La calificación es regular." ); else System.out.println( "!Reprobado¡." ); System.out.println( "El estudio es la base del triunfo." ); } //fin del método main} //fin de la clase Calificacion
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 36
La instrucción if/else/if.
Adivinanza.java
//Programa para jugar adivinanzas.import java.util.Scanner; //para leer del tecladopublic class Adivinanza { public static void main( String[] args ) { //genera el número aleatorio int numeroSecreto = ( int )( Math.random() * 10 );
Scanner entrada = new Scanner( System.in );
//solicita un número al usuario System.out.print( "Piensa un número entre 0 y 9: " ); int numero = entrada.nextInt(); //evalúa if( numero == numeroSecreto ) System.out.println( "¡Adivinaste!" ); else if( numero < numeroSecreto ) System.out.println( "¡Frío!" ); else System.out.println( "¡Caliente!" ); } //fin del método main} //fin de la clase Adivinanza
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 37
Calificacion.java
//Utiliza if/else/if para evaluar una calificación.import java.util.Scanner; //para leer del tecladopublic class Calificacion{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); System.out.print( "Calificación (110)? " ); //indicador //lee calificación del teclado int calif = entrada.nextInt(); if( calif >= 9 ) System.out.println( "La calificación es excelente." ); else if( calif >= 8 ) System.out.println( "La calificación es buena." ); else if( calif >= 7 ) System.out.println( "La calificación es regular." ); else System.out.println( "!Reprobado¡." ); System.out.println( "El estudio es la base del triunfo." ); } //fin del método main} //fin de la clase Calificacion
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 38
Revisión de dos condiciones o más.
OperadoresLogicos.java
//Operadores lógicos && y ||public class OperadoresLogicos{ public static void main( String[] args ) { if( true && true ) System.out.println( "true true = verdadero." ); if( ( true && false ) || ( false && true ) || ( false && false ) ) System.out.println( "Nunca entra." ); if( ( true || false ) && ( false || true ) && ( true || true ) ) System.out.println( "Verdadero." ); if( false || false ) System.out.println( "Nunca entra." ); } //fin del metodo main } //fin de la clase OperadoresLogicos
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 39
Loteria.java
//Programa para jugar a la lotería.import java.util.Scanner; //para leer del tecladopublic class Loteria { public static void main( String[] args ) { //genera el número de la lotería int loto = ( int )( Math.random() * 100 ); Scanner entrada = new Scanner( System.in ); System.out.print( "Ingresa un número de dos dígitos: " ); int numGanador = entrada.nextInt(); //obtiene los dígitos de la lotería int digitoLoto1 = loto / 10; int digitoLoto2 = loto % 10; //obtiene los dígitos del usuario int digito1 = numGanador / 10; int digito2 = numGanador % 10; System.out.println( "El número de la lotería es: " + loto ); //Revisa por los premios if( loto == numGanador ) System.out.println( "Ganaste $10,000.00" ); else if( digito2 == digitoLoto1 && digito1 == digitoLoto2 ) System.out.println( "Ganaste $3,000.00" ); else if( digito1 == digitoLoto1 || digito1 == digitoLoto2 || digito2 == digitoLoto1 || digito2 == digitoLoto2 ) System.out.println( "Ganaste $1,000.00" ); else System.out.println( "Sigue participando." ); } //fin del método main} //fin de la clase Loteria
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 40
La instrucción switch.
SwitchDemo.java
//Instrucción switch.import java.util.Scanner; //para leer del tecladopublic class SwitchDemo { public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); System.out.println( "Introduce un número del 1 al 7: " ); int diaSemana = entrada.nextInt(); switch( diaSemana ) { case 1: System.out.println( "Lunes." );break; case 2: System.out.println( "Martes." );break; case 3: System.out.println( "Miércoles." );break; case 4: System.out.println( "Jueves." );break; case 5: System.out.println( "Viernes." );break; case 6: System.out.println( "Sábado." );break; case 7: System.out.println( "Domingo." );break; default: System.out.println( "Error." );break; } //fin switch } //fin del método main} //fin de la clase SwitchDemo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 41
PiedraPapelTijera.java
//Programa para jugar al piedrapapeltijera.import java.util.Scanner;public class PiedraPapelTijera { public static void main( String[] args ) { final int PIEDRA = 1, PAPEL = 2, TIJERA = 3; int jugador, computadora; Scanner entrada = new Scanner( System.in );
//solicita la jugada del usuario System.out.print( "Tu jugada? 1 = Piedra, 2 = Papel, 3 = Tijera" ); jugador = entrada.nextInt(); //genera la jugada de la computadora computadora = ( int )( Math.random() * 3 + 1 ); //muestra la jugada del usuario System.out.print( "La jugada del usuario: " ); switch( jugador ) { case PIEDRA: System.out.println( "PIEDRA." );break; case PAPEL: System.out.println( "PAPEL." );break; case TIJERA: System.out.println( "TIJERA." );break; } //fin switch //muestra la jugada de la computadora System.out.print( "La jugada de la computadora: " ); switch( computadora ) { case PIEDRA: System.out.println( "PIEDRA." );break; case PAPEL: System.out.println( "PAPEL." );break; case TIJERA: System.out.println( "TIJERA." );break; } //fin switch //determina el ganador if( jugador == PIEDRA && computadora == PIEDRA ) System.out.println( "Empate." ); else if( jugador == PIEDRA && computadora == PAPEL ) System.out.println( "La computadora gana." ); else if( jugador == PIEDRA && computadora == TIJERA ) System.out.println( "¡El jugador gana!" ); if( jugador == PAPEL && computadora == PIEDRA ) System.out.println( "¡El jugador gana!" ); else if( jugador == PAPEL && computadora == PAPEL ) System.out.println( "Empate." ); else if( jugador == PAPEL && computadora == TIJERA )
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de selección. 42
System.out.println( "La computadora gana." ); if( jugador == TIJERA && computadora == PIEDRA ) System.out.println( "La computadora gana." ); else if( jugador == TIJERA && computadora == PAPEL ) System.out.println( "¡El jugador gana!" ); else if( jugador == TIJERA && computadora == TIJERA ) System.out.println( "Empate." ); } //fin del método main} //fin de la clase PiedraPapelTijera
© Raúl Oramas Bustillos 2012.
4. Instrucciones de repetición.
Contenido:
Ciclo while............................................................................................................................................................. 44
Ciclos controlados por centinelas......................................................................................................................... 48
Instrucción de repetición do...while.......................................................................................................................49
El ciclo for............................................................................................................................................................. 50
Instrucción break.................................................................................................................................................. 51
Instrucción continue.............................................................................................................................................. 53
Fundamentos de Programación con Java → Instrucciones de repetición. 44
Ciclo while.
ContadorWhile.java
//Instrucción while.public class ContadorWhile{ public static void main( String[] args ) { int contador = 1; //declara e inicializa //la variable de control while( contador <= 10 ) //condición de continuación de ciclo { System.out.println( contador ); contador++; //incrementa la variable de control en 1 } //fin de while } //fin del método main} //fin de la clase ContadorWhile
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 45
WhileDemo.java
//Instrucción while.import java.util.Scanner;public class WhileDemo{ public static void main( String[] args ) { int contador = 1; //variable de control int numero; Scanner entrada = new Scanner( System.in ); System.out.print( "Ingresa un número entero: " ); numero = entrada.nextInt(); while( contador <= numero ) //condición de //continuación de ciclo { System.out.println( contador ); contador++; //incrementa la variable de control en 1 } //fin de while System.out.println(); System.out.println( "Fin del programa." ); } //fin del método main} //fin de la clase WhileDemo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 46
RaizCuadrada.java
//Raíz cuadrada de un cuadrado perfecto.import java.util.Scanner;public class RaizCuadrada{ public static void main( String[] args ) { int raiz = 0; Scanner entrada = new Scanner( System.in ); //lectura System.out.print( "Dame un número entero? " ); int numero = entrada.nextInt(); //proceso y salida if( numero >= 0 ) { //proceso while( raiz * raiz < numero ) raiz = raiz + 1; if( raiz * raiz != numero ) System.out.println( numero + " no es cuadrado perfecto" ); else System.out.println( "La raíz cuadrada de " + numero + " es " + raiz ); } else System.out.println( numero + " es un número negativo" ); } //fin del método main} //fin de la clase RaizCuadrada
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 47
Adivinanza.java
//Programa para jugar adivinanzas.import java.util.Scanner; //para leer del tecladopublic class Adivinanza { public static void main( String[] args ) { //genera el número aleatorio entre 0 y 100 int numeroSecreto = ( int )( Math.random() * 101 );
Scanner entrada = new Scanner( System.in );
//mensaje de usuario System.out.println( "Piensa un número entre 0 y 100." ); System.out.println( "" ); int numero = 1; while( numero != numeroSecreto ) { //solicita un número al usuario System.out.print( "Número? " ); numero = entrada.nextInt(); //evalúa if( numero == numeroSecreto ) System.out.println( "¡Adivinaste!" ); else if( numero < numeroSecreto ) System.out.println( "¡Frío!" ); else System.out.println( "¡Caliente!" ); } //fin while } //fin del método main} //fin de la clase Adivinanza
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 48
Ciclos controlados por centinelas.
Promedio.java
//Lee una serie de números enteros y calcula su promedio. import java.util.Scanner; //para leer del tecladopublic class Promedio { public static void main(String[] args) { Scanner entrada = new Scanner( System.in );
//mensaje de usuario System.out.println( "Ingresa una lista de números enteros positivos." ); System.out.println( "Marca el final de la lista con un cero." ); System.out.println( "");
int contador = 0; int suma = 0; System.out.print( "Ingresa un número (0 para terminar): " ); int numero = entrada.nextInt();
while( numero != 0 ) { suma = suma + numero; contador = contador + 1;
System.out.print( "Ingresa un número (0 para terminar): " ); numero = entrada.nextInt(); } //fin while
if( contador == 0 ) System.out.println( "No ingresaste ningún número." ); else { double promedio = ( double )suma / contador; System.out.println( "Números leídos: " + contador ); System.out.println( "El promedio es: " + promedio ); } //fin else } //fin del método main } //fin de la clase Promedio
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 49
Instrucción de repetición do...while.
PruebaDoWhile.java
//La instrucción de repetición do...while. public class PruebaDoWhile{ public static void main( String[] args ) { int contador = 1; //inicializa contador do { System.out.println( contador ); contador++; } while( contador <= 10 ); //fin de do...while } //fin del método main} //fin de la clase PruebaDoWhile
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 50
El ciclo for.
ContadorFor.java
//Repetición controlada con contador.public class ContadorFor{ public static void main( String[] args ) { //el encabezado de la instrucción for //incluye la iniacialización //la condición de continuación del ciclo y el incremento for( int contador = 1; contador <= 10; contador++ ) System.out.println( contador ); } //fin del método main} //fin de la clase ContadorFor
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 51
Instrucción break.
ForBreak.java
//La instrucción break para salir de un ciclo for.public class ForBreak{ //el método main empieza la ejecución de la aplicación en Java public static void main( String[] args ) { int cuenta; //la variable de control también se usa //cuando termina el ciclo for( cuenta = 1; cuenta <= 10; cuenta++ ) //itera 10 veces { if( cuenta == 5 ) //si cuenta es 5 break; //termina el ciclo System.out.println( cuenta ); } //fin de for System.out.println( "Salio del ciclo en cuenta = " + cuenta ); } //fin del método main } //fin de la clase ForBreak
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 52
WhileBreak.java
//La instrucción break para salir de un ciclo while.public class WhileBreak{ public static void main( String[] args ) { int suma = 0; int numero = 0; while( numero < 20 ) { numero++; suma += numero; if( suma >= 100 ) break; } //fin while System.out.printf( "Valor final de número = " + numero ); System.out.printf( "La suma = " + suma ); } //fin del método main } //fin de la clase WhileBreak
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Instrucciones de repetición. 53
Instrucción continue.
PruebaContinue.java
//Instrucción continue.public class PruebaContinue{ public static void main( String[] args ) { for( int cuenta = 1; cuenta <= 10; cuenta++ ) { if( cuenta == 5 ) //si cuenta es 5, continue; //omite el resto del código en el ciclo System.out.println( cuenta ); } //fin de for System.out.println( "Se uso continue para omitir imprimir 5" ); } //fin del método main } //fin de la clase PruebaContinue
© Raúl Oramas Bustillos 2012.
5. Métodos.
Contenido:
Declaración de un método.................................................................................................................................... 55
Declaración de un método con un parámetro.......................................................................................................58
Métodos void vs. return......................................................................................................................................... 59
Declaración de métodos con múltiples parámetros..............................................................................................61
Orden en el paso de parámetros.......................................................................................................................... 62
Reutilización de código......................................................................................................................................... 63
Métodos sobrecargados (overload)...................................................................................................................... 66
Fundamentos de Programación con Java → Métodos. 55
Declaración de un método.
Curso.java
//Declaración de un método.public class Curso{ //muestra un mensaje de bienvenida public static void mostrarMensaje() { System.out.println( "Bienvenido al curso de Java." ); } //fin del método mostrarMensaje public static void main( String[] args ) { mostrarMensaje(); //llamada al método } //fin del método main} //fin de la clase Curso
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 56
Temperatura.java
//Utiliza dos métodos para convertir de celsius //a fahrenheit y viceversa.import java.util.Scanner; //para leer del tecladopublic class Temperatura{ //convierte de fahrenheit a celsius public static void fahrenheitCelsius() { //variables locales double fahrenheit; double celsius; Scanner entrada = new Scanner( System.in ); //lee la temperatura System.out.print( "Ingresa una temperatura en fahrenheit: " ); fahrenheit = entrada.nextDouble(); //realiza la conversión celsius = 5.0 / 9.0 * fahrenheit 32; //imprime el resultado System.out.println( "La temperatura en celsius es " + celsius ); } //fin del método fahrenheitCelsius //convierte de celsius a fahrenheit public static void celsiusFahrenheit() { //variables locales double fahrenheit; double celsius; Scanner entrada = new Scanner( System.in ); //lee la temperatura System.out.print( "Ingresa una temperatura en celsius: " ); celsius = entrada.nextDouble(); //realiza la conversión fahrenheit = 9.0 / 5.0 * celsius + 32; //imprime el resultado System.out.println( "La temperatura en fahrenheit es " + fahrenheit ); } //fin del método celsiusFahrenheit
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 57
public static void main( String[] args ) { int opcion; //variable local Scanner entrada = new Scanner( System.in ); //mensaje de usuario System.out.println( "1. Convertir de Fahrenheit a Celsius." ); System.out.println( "2. Convertir de Celsius a Fahrenheit." );
//lee la opción del usuario System.out.print( "Opción: " ); opcion = entrada.nextInt(); if( opcion == 1 ) fahrenheitCelsius(); else celsiusFahrenheit(); } //fin del método main} //fin de la clase Temperatura
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 58
Declaración de un método con un parámetro.
Curso.java
//Declaración de un método con un parámetro.public class Curso{ //muestra un mensaje de bienvenida public static void mostrarMensaje( String nombreCurso ) { System.out.println( "Bienvenido al curso de " + nombreCurso + "." ); } //fin del método mostrarMensaje public static void main( String[] args ) { mostrarMensaje( "Java" ); //llamada al método mostrarMensaje( "C Sharp" ); //llamada al método } //fin del método main} //fin de la clase Curso
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 59
Métodos void vs. return.
TestMetodoVoid.java
//Define un método void.public class TestMetodoVoid{ public static void calificar( double calificacion ) { if( calificacion >= 90.0 ) System.out.println( 'A' ); else if( calificacion >= 80.0 ) System.out.println( 'B' ); else if( calificacion >= 70.0 ) System.out.println( 'C' ); else if( calificacion >= 60.0 ) System.out.println( 'D' ); else System.out.println( 'E' ); } //fin del método calificar public static void main( String[] args ) { System.out.print( "Obtuviste una " ); calificar( 78.5 ); System.out.print( "Obtuviste una " ); calificar( 59.5 ); } //fin del método main} //fin de la clase TestMetodoVoid
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 60
TestMetodoReturn.java
//Define un método returnpublic class TestMetodoReturn{ public static char calificar( double calificacion ) { if( calificacion >= 90.0 ) return 'A'; else if( calificacion >= 80.0 ) return 'B'; else if( calificacion >= 70.0 ) return 'C'; else if( calificacion >= 60.0 ) return 'D'; else return 'E'; } //fin del método calificar public static void main( String[] args ) { System.out.print( "Obtuviste una " + calificar( 78.5 ) ); System.out.print( "Obtuviste una " + calificar( 59.5 )); } //fin del método main} //fin de la clase TestMetodoReturn
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 61
Declaración de métodos con múltiples parámetros.
Mayor.java
//Método con múltiples parámetros.public class Mayor{ //devuelve el máximo de sus tres parámetros double public static double maximo( double x, double y, double z ) { double valorMaximo = x; //asume que x es el mayor para empezar //determina si y es el mayor que valorMaximo if( y > valorMaximo ) valorMaximo = y; //determina si z es mayor que valorMaximo if( z > valorMaximo ) valorMaximo = z; return valorMaximo; } //fin del método máximo public static void main( String[] args ) { double z = maximo( 9.35, 2.75, 5.1 ); System.out.println( "El mayor es " + z ); } //fin del método main} //fin de la clase Mayor
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 62
Orden en el paso de parámetros.
PasoParametros.java
//Paso de parámetros.public class PasoParametros{ public static void nPrint( String mensaje, int n ) { for( int i = 0; i < n; i++ ) System.out.println( mensaje ); } //fin del método nPrint public static void main( String[] args ) { nPrint( "Hola", 3 ); //El orden de los parámetros es correcto nPrint( 3, "Hola" ); //El orden de los parámetros es incorrecto nPrint( "Hola", 3.5 ); //El tipo es incorrecto nPrint(); //faltan argumentos nPrint( "Hola" ); //faltan argumentos } //fin del método main} //fin de la clase PasoParametros
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 63
Reutilización de código.
Mayor.java
//Reutilización de código.public class Mayor{ //devuelve el máximo de sus tres parámetros double public static double maximo( double x, double y, double z ) { return Math.max( x, Math.max( y, z ) ); } //fin del método máximo public static void main( String[] args ) { double z = maximo( 9.35, 2.75, 5.1 ); System.out.println( "El mayor es " + z ); } //fin del método main} //fin de la clase Mayor
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 64
MaximoComunDivisor.java
//Programa para obtener el máximo común divisor de dos números.import java.util.Scanner; //para leer del tecladopublic class MaximoComunDivisor{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); //solicita los dos números enteros System.out.print( "Ingresa el primer número: " ); int n1 = entrada.nextInt(); System.out.print( "Ingresa el segundo número: " ); int n2 = entrada.nextInt(); System.out.println( "El máximo común divisor para " + n1 + " y " + n2 + " es " + gcd( n1, n2 ) ); } //fin del método main
//regresa el máximo común divisor public static int gcd( int n1, int n2 ) { int gcd = 1; //el gcd inicial es 1 int k = 2; //posible gcd while( k <= n1 && n2 % k <= n2 ) { if( n1 % k == 0 && n2 % k == 0 ) gcd = k; //actualiza gcd k++; } //fin while return gcd; //regresa el gcd } //fin del método gcd} //fin de la clase MaximoComunDivisor
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 65
NumeroPrimo.java
//Programa que imprime los primeros 50 números primos.public class NumeroPrimo{ public static void main( String[] args ) { System.out.println( "Los primeros 50 números primos son: " ); imprimirNumerosPrimos( 50 ); } //fin del método main public static void imprimirNumerosPrimos( int nPrimos ) { final int PRIMO_POR_LINEA = 10; //despliega 10 por línea int contador = 0; //cuenta el número de primos int numero = 2; //número a probar si es primo //encuentra los números primos while( contador < nPrimos ) { //imprime el número primo e incrementa el contador if( esPrimo( numero ) ) { contador = contador + 1; if( contador % PRIMO_POR_LINEA == 0 ) { //imprime el número y avanza una línea System.out.println( numero ); } //fin if else System.out.print( numero + " " ); } //fin if //busca si el siguiente es número primo numero = numero + 1; } //fin while } //fin del método imprimirNumerosPrimos //verifica si un número es primo public static boolean esPrimo( int numero ) { for( int divisor = 2; divisor <= numero / 2; divisor++ ) if( numero % divisor == 0 ) return false; //el número no es primo return true; //el número es primo } //fin del método esPrimo } //fin de la clase NumeroPrimo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Métodos. 66
Métodos sobrecargados (overload).
Calculadora.java
//Métodos overload.public class Calculadora { //suma dos números enteros public static int suma( int operandoUno, int operandoDos ) { return operandoUno + operandoDos; } //fin del método suma
//suma dos números double public static double suma( double operandoUno, double operandoDos ) { return operandoUno + operandoDos; } //fin del método suma
public static void main( String[] args ) { System.out.println( suma( 10, 2 ) ); System.out.println( suma( 10, 2.0 ) ); //promoción del argumento System.out.println( suma( 10.0, 2.0 ) ); } //fin del método main} //fin de la clase Calculadora
© Raúl Oramas Bustillos 2012.
6. Arreglos de una dimensión.
Contenido:
Declaración de un arreglo..................................................................................................................................... 81
Crear un arreglo.................................................................................................................................................... 82
Asignar valores a un arreglo................................................................................................................................. 83
El tamaño del arreglo y valores por default...........................................................................................................84
Acceder a los elementos de un arreglo................................................................................................................85
Inicialización de un arreglo al declararlo...............................................................................................................86
Inicializar un arreglo con valores desde el teclado...............................................................................................87
Inicializar un arreglo con valores aleatorios..........................................................................................................88
Imprimir el contenido de un arreglo......................................................................................................................89
Sumar todos los elementos del arreglo................................................................................................................90
Encontrar el elemento mayor del arreglo..............................................................................................................91
Intercambio aleatorio de los elementos del arreglo..............................................................................................92
Desplazar elementos del arreglo.......................................................................................................................... 93
Instrucción for mejorada....................................................................................................................................... 94
Paso de arreglos a los métodos...........................................................................................................................95
Regresar un arreglo desde un método.................................................................................................................97
Listas de argumentos de longitud variable............................................................................................................98
Uso de argumentos de línea de comandos..........................................................................................................99
Fundamentos de Programación con Java → Arreglos de una dimensión. 68
Declaración de un arreglo.
DeclararArreglo.java
//Declara un arreglo de una sola dimensión.public class DeclararArreglo{ public static void main( String[] args ) { double[] miArreglo; //double miArreglo[]; } //fin del método main } //fin de la clase DeclaraArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 69
Crear un arreglo.
CrearArreglo.java
//Declara y crea un arreglo.public class CrearArreglo{ public static void main( String[] args ) { //double[] miArreglo; //miArreglo = new Arreglo[10]; double[] miArreglo = new double[10]; } //fin del método main } //fin de la clase CrearArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 70
Asignar valores a un arreglo.
ValoresArreglo.java
//Declara un arreglo de una sola dimensión.public class ValoresArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10]; //inicializa los valores del arreglo miArreglo[0] = 5.6; //el arreglo inicia en la posición 0 miArreglo[1] = 4.5; miArreglo[2] = 3.3; miArreglo[3] = 13.2; miArreglo[4] = 4.0; miArreglo[5] = 34.33; miArreglo[6] = 34.0; miArreglo[7] = 45.45; miArreglo[8] = 99.93; miArreglo[9] = 999; //el arreglo termina en la posición: n 1 } //fin del método main } //fin de la clase ValoresArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 71
El tamaño del arreglo y valores por default.
DefaultArreglo.java
//Tamaño del arreglo y valores por default.public class DefaultArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10];
//accede la primera posición del arreglo System.out.println( "miArreglo[0] = " + miArreglo[0] ); //utiliza la propiedad length para obtener el tamaño del arreglo System.out.println( "Tamaño del arreglo = " + miArreglo.length ); } //fin del método main } //fin de la clase DefaultArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 72
Acceder a los elementos de un arreglo.
ElementosArreglo.java
//Acceder a los elementos de un arreglo.public class ElementosArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10];
//inicializa los valores del arreglo miArreglo[0] = 5.6; miArreglo[1] = 4.5; miArreglo[2] = 3.3; System.out.println( "Los tres primeros elementos del arreglo:" ); System.out.println( "miArreglo[0] = " + miArreglo[0] ); System.out.println( "miArreglo[1] = " + miArreglo[1] ); System.out.println( "miArreglo[2] = " + miArreglo[2] ); } //fin del método main } //fin de la clase ElementosArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 73
Inicialización de un arreglo al declararlo.
DatosArreglo.java
//Declara e inicializa un arreglo.public class DatosArreglo{ public static void main( String[] args ) { double[] miArreglo = {1.9, 2.9, 3.4, 3.5}; System.out.println( "Contenido del arreglo:" ); System.out.println( "miArreglo[0] = " + miArreglo[0] ); System.out.println( "miArreglo[1] = " + miArreglo[1] ); System.out.println( "miArreglo[2] = " + miArreglo[2] ); System.out.println( "miArreglo[3] = " + miArreglo[3] ); } //fin del método main } //fin de la clase DatosArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 74
Inicializar un arreglo con valores desde el teclado.
LecturaArreglo.java
//Inicializar los valores de un arreglo.import java.util.Scanner;public class LecturaArreglo{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); double[] miArreglo; System.out.print( "Introduce el tamaño del arreglo? " ); int tamaño = entrada.nextInt(); //crea el arreglo miArreglo = new double[tamaño]; //lee los valores del teclado System.out.println( "Lectura de los datos del arreglo." );
for( int i = 0; i < miArreglo.length; i++ ) { System.out.print( "Valor? " ); miArreglo[i] = entrada.nextDouble(); } //fin for } //fin del método main } //fin de la clase LecturaArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 75
Inicializar un arreglo con valores aleatorios.
ArregloAleatorio.java
//Inicializar los valores de un arreglo.public class ArregloAleatorio{ public static void main( String[] args ) { double[] miArreglo = new double[10]; //inicializa el arreglo con valores aleatorios for( int i = 0; i < miArreglo.length; i++ ) { //0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random()*100; } //fin for } //fin del método main } //fin de la clase ArregloAleatorio
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 76
Imprimir el contenido de un arreglo.
ImprimirArreglo.java
//Imprime los valores de un arreglo.public class ImprimirArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10]; //inicializa el arreglo con valores aleatorios for( int i = 0; i < miArreglo.length; i++ ) { //0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random()*100; } //fin for //imprime los valores del arreglo System.out.println( "Los valores del arreglo:" ); for( int i = 0; i < miArreglo.length; i++ ) { System.out.println( miArreglo[i] ); } //fin for } //fin del método main } //fin de la clase ImprimirArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 77
Sumar todos los elementos del arreglo.
SumaArreglo.java
//Sumar los valores de un arreglo.public class SumaArreglo{ public static void main( String[] args ) { double[] miArreglo = new double[10]; double suma = 0;
//inicializa el arreglo con valores aleatorios for( int i = 0; i < miArreglo.length; i++ ) { //0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random()*100; //va sumando los valores del arreglo suma = suma + miArreglo[i]; } //fin for //imprime la suma del arreglo System.out.println( "La suma de los valores del arreglo es " + suma ); } //fin del método main } //fin de la clase SumaArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 78
Encontrar el elemento mayor del arreglo.
MayorArreglo.java
//Encuentra el elemento mayor de un arreglo.public class MayorArreglo{ public static void main( String[] args ) { double[] miArreglo = {1.9, 2.9, 1.8, 3.4, 2.2}; double mayor = miArreglo[0]; //asume que es el mayor //procesa el arreglo, iniciando en el indice 1 for( int i = 1; i < miArreglo.length; i++ ) { if( miArreglo[i] > mayor ) mayor = miArreglo[i]; } //fin for //imprime la suma del arreglo System.out.println( "El elemento mayor es " + mayor ); } //fin del método main } //fin de la clase MayorArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 79
Intercambio aleatorio de los elementos del arreglo.
Shuffling.java
//Intercambia aleatoriamente los valores del arreglo.public class Shuffling{ public static void main( String[] args ) { double[] miArreglo = { 1, 5, 3, 4, 7, 9 }; //procesa el arreglo for( int i = 0; i < miArreglo.length; i++ ) { //genera el indice j aleatoriamente int j = ( int )( Math.random() * miArreglo.length ); //intercambia miArreglo[i] con miArreglo[j]; double temporal = miArreglo[i]; miArreglo[i] = miArreglo[j]; miArreglo[j] = temporal; } //fin for
//imprime los valores del arreglo System.out.println( "Los valores del arreglo:" ); for( int i = 0; i < miArreglo.length; i++ ) { System.out.print( miArreglo[i] + " " ); } //fin for } //fin del método main } //fin de la clase Shuffling
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 80
Desplazar elementos del arreglo.
RotarArreglo.java
//Rotar los elementos de un arreglo.public class RotarArreglo{ public static void main( String[] args ) { double[] miArreglo = { 1, 5, 3, 4, 7, 9 }; double temporal = miArreglo[0]; //guarda el primer elemento //procesa el arreglo for( int i = 1; i < miArreglo.length; i++ ) { miArreglo[i1] = miArreglo[i]; } //fin for
//mueve el primer elemento al último miArreglo[ miArreglo.length 1 ] = temporal; //imprime los valores del arreglo System.out.println( "Los valores del arreglo:" ); for( int i = 0; i < miArreglo.length; i++ ) { System.out.print( miArreglo[i] + " " ); } //fin for } //fin del método main } //fin de la clase RotarArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 81
Instrucción for mejorada.
ForEach.java
//Ciclo foreach.public class ForEach{ public static void main( String[] args ) { double[] miArreglo = {1, 5, 3, 4, 7, 9}; //procesa el arreglo for( double elemento : miArreglo ) System.out.println( elemento ); } //fin del método main } //fin de la clase ForEach
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 82
Paso de arreglos a los métodos.
PasoParametros.java
//Paso de arreglos a los métodos.public class PasoParametros{ public static void main( String[] args ) { double[] x = { 12.0, 34.0, 43.4, 12.0, 23.4 }; double[] y = { 11.4, 31.7, 13.4, 12.8, 21.8 };
imprimir( x ); imprimir( y );
//usando un arreglo anónimo imprimir( new double[]{ 11.0, 12.0, 13.0, 14.0, 15.0 } ); } //fin del método main
public static void imprimir( double[] arreglo ) { for( int i = 0; i < arreglo.length; i++ ) System.out.print( arreglo[i] + " " ); System.out.println(); } //fin del método imprimir} //fin de la clase PasoParametros
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 83
PasoArreglo.java
//Paso de arreglos y elementos individuales de un arreglo a los métodos.public class PasoArreglo{ //main crea el arreglo y llama a modificarArreglo y modificarElemento public static void main( String[] args ) { int arreglo[] = { 1, 2, 3, 4, 5 }; System.out.println( "Efectos de pasar una referencia a un arreglo completo:\n" + "Los valores del arreglo original son:" ); //imprime los elementos originales del arreglo for( int valor : arreglo ) System.out.print( " " + valor ); modificarArreglo( arreglo ); //pasa la referencia al arreglo System.out.println( "\n\nLos valores del arreglo modificado son:" ); //imprime los elementos modificados del arreglo for( int valor : arreglo ) System.out.printf( " " + valor ); System.out.println( "\n\nEfectos de pasar el valor de un elemento del arreglo;\n" + "arreglo[3] antes de modificarElemento: " + arreglo[ 3 ] ); modificarElemento( arreglo[ 3 ] ); //intento por modificar arreglo[3] System.out.println( "\narreglo[3] despues de modificarElemento: " + arreglo[ 3 ] ); } //fin del método main //multiplica cada elemento de un arreglo por 2 public static void modificarArreglo( int arreglo2[] ) { for( int contador = 0; contador < arreglo2.length; contador++ ) arreglo2[ contador ] = arreglo2[contador] * 2; } //fin del método modificarArreglo //multiplica el argumento por dos public static void modificarElemento( int elemento ) { elemento = elemento * 2; System.out.println( "Valor del elemento en modificarElemento: " + elemento ); } //fin del método modificarElemento} //fin de la clase PasoArreglo
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 84
Regresar un arreglo desde un método.
ProductoVectores.java
//Calcula el producto de dos arreglos A y B.import java.util.Scanner; //para leer del tecladopublic class ProductoVectores{ private static final int MAX = 10; //tamaño del arreglo public static void main( String[] args ) { //entrada System.out.println( "Arreglo 1." ); int[] a = leerArreglo(); System.out.println( "Arreglo 2." ); int[] b = leerArreglo(); //proceso int producto = productoVectores( a, b ); //salida System.out.println( "El producto de AxB = " + producto ); } //fin del método main private static int[] leerArreglo() { //crea el objeto de lectura Scanner entrada = new Scanner( System.in ); int[] temp = new int[MAX]; for( int i = 0; i < temp.length; i++ ) { System.out.print( "Valor? " ); temp[i] = entrada.nextInt(); } //fin for return temp; } //fin del método leerArreglo private static int productoVectores( int[] a, int[] b ) { int producto = 0; for( int i = 0; i < MAX; i++ ) producto = producto + ( a[i] * b[i] ); return producto; } //fin del método productoVectores } //fin de la clase ProductoVectores
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 85
Listas de argumentos de longitud variable.
PruebaVarargs.java
//Uso de listas de argumentos de longitud variable.public class PruebaVarargs{ //calcula el promedio public static double promedio( double...numeros ) { double total = 0.0; //inicializa el total //calcula el total usando la instrucción for mejorada for( double d : numeros ) total = total + d; return total / numeros.length; } //fin del método promedio public static void main( String args[] ) { double d1 = 10.0; double d2 = 20.0; double d3 = 30.0; double d4 = 40.0; System.out.println( "Valores iniciales." ); System.out.println( "" ); System.out.println( "d1 = " + d1 ); System.out.println( "d2 = " + d2 ); System.out.println( "d3 = " + d3 ); System.out.println( "d4 = " + d4 ); System.out.println( "El promedio de d1 y d2 es " + promedio( d1, d2 ) ); System.out.println( "El promedio de d1, d2, d3 y d4 es " + promedio( d1, d2, d3, d4 ) ); } //fin del método main } //fin de la clase PruebaVarargs
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos de una dimensión. 86
Uso de argumentos de línea de comandos.
Suma.java
//Uso de los argumentos args.public class Suma { public static void main ( String[] args ) { //comprueba el número de argumentos de línea de comandos if( args.length != 2 ) System.out.println( "Se necesitan dos argumentos." ); else { //obtiene los valores de la línea de comandos int numUno = Integer.parseInt( args[0] ); int numDos = Integer.parseInt( args[1] );
//obtiene la suma int suma = numUno + numDos;
//muestra la suma System.out.println( args[0] + " + " + args[1] + " es " + suma ); } //fin del método main} //fin de la clase Suma
© Raúl Oramas Bustillos 2012.
7. Arreglos bidimensionales.
Contenido:
Introducción.......................................................................................................................................................... 15
Trabajando con números................................................................................................................................ 15
Dificultades numéricas.................................................................................................................................... 16
Cálculos simples............................................................................................................................................. 16
Imprimir texto, versión 1.1..................................................................................................................................... 17
Imprimir texto, versión 1.2..................................................................................................................................... 18
Imprimir texto, versión 1.3..................................................................................................................................... 18
Variables............................................................................................................................................................... 18
Programa para sumar dos números...............................................................................................................18
Calculadora simple......................................................................................................................................... 19
Precedencia de los operadores............................................................................................................................ 20
Circulo Versión 1.0................................................................................................................................................ 20
Circulo Versión 1.1................................................................................................................................................ 21
Circulo Versión 1.2................................................................................................................................................ 22
Operadores de igualdad y relacionales................................................................................................................22
Instrucción if simple.............................................................................................................................................. 24
Fundamentos de Programación con Java → Arreglos bidimensionales. 88
Introducción.
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 89
Declaración de un arreglo.
DeclararArreglo.java
//Declara un arreglo de dos dimensiones.public class DeclararArreglo2D{ public static void main( String[] args ) { double[][] matriz; //double matriz[][]; } //fin del método main } //fin de la clase DeclararArreglo2D
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 90
Crear un arreglo.
CrearArreglo.java
//Declara y crea un arreglo de dos dimensiones.public class CrearArreglo2D{ public static void main( String[] args ) { //double[][] matriz; //matriz = new Arreglo[10][10]; double[][] matriz = new double[10][10]; } //fin del método main } //fin de la clase CrearArreglo2D
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 91
Asignar valores a un arreglo.
ValoresArreglo.java
//Declara un arreglo de dos dimensiones.public class ValoresArreglo2D{ public static void main( String[] args ) { double[][] matriz = new double[10][10]; //inicializa los valores del arreglo2D miArreglo[0][0] = 5.6; miArreglo[0][1] = 4.5; miArreglo[0][2] = 3.3; miArreglo[0][3] = 13.2; miArreglo[0][4] = 4.0; miArreglo[0][5] = 34.33; miArreglo[0][6] = 34.0; miArreglo[0][7] = 45.45; miArreglo[0][8] = 99.93; miArreglo[0][9] = 99.54; } //fin del método main } //fin de la clase ValoresArreglo2D
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 92
El tamaño del arreglo y valores por default.
DefaultArreglo.java
//Tamaño del arreglo y valores por default.public class DefaultArreglo2D{ public static void main( String[] args ) { double[][] matriz = new double[10][10];
//accede la primera posición de la matriz System.out.println( "matriz[0][0] = " + matriz[0][0] ); //utiliza la propiedad length para obtener el tamaño del arreglo System.out.println( "Tamaño del arreglo = " + matriz.length ); System.out.println( "Tamaño del renglón = " + matriz[0].length ); } //fin del método main } //fin de la clase DefaultArreglo2D
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 93
Acceder a los elementos de un arreglo.
ElementosArreglo2D.java
//Acceder a los elementos de una matriz.public class ElementosArreglo2D{ public static void main( String[] args ) { double[][] matriz = new double[10][10];
//inicializa los valores de la matriz matriz[0][0] = 5.6; matriz[1][0] = 4.5; matriz[2][0] = 3.3; System.out.println( "matriz[0][0] = " + miArreglo[0][0] ); System.out.println( "matriz[1][0] = " + miArreglo[1][0] ); System.out.println( "matriz[2][0] = " + miArreglo[2][0] ); } //fin del método main } //fin de la clase ElementosArreglo2D
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 94
Inicialización de un arreglo al declararlo.
DatosArreglo.java
//Declara e inicializa un arreglo de dos dimensiones.public class DatosArreglo2D{ public static void main( String[] args ) { double[] matriz = { { 1.9, 2.9, 3.4, 3.5 }, { 5.5, 7.2, 3.3, 1,9 }, { 8.7, 3.4, 8.6, 9.9 } };
} //fin del método main } //fin de la clase DatosArreglo2D
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 95
Inicializar un arreglo bidimensional con valores desde el teclado.
LecturaArreglo2D.java
//Inicializa los datos de un arreglo 2D desde el teclado.import java.util.Scanner;public class LecturaArreglo2D{ public static void main( String[] args ) { Scanner entrada = new Scanner( System.in ); int[][] tabla = new int[2][3];
System.out.println( "Arreglo con " + tabla.length + " renglones y " + tabla[0].length + " columnas." ); System.out.println( "Introduce números enteros:" ); //lectura del arreglo for( int ren = 0; ren < tabla.length; ren++ ) { for( int col = 0; col < tabla[ren].length; col++ ) { System.out.print( "Valor[" + ren + "][" + col + "]? " ); tabla[ren][col] = entrada.nextInt(); } //fin for } //fin for //imprime el primer renglón System.out.print( "El renglón 1 = [" ); System.out.print( tabla[0][0] + " " ); System.out.print( tabla[0][1] + " " ); System.out.print( tabla[0][2] + "]" ); } //fin del método main } //fin de la clase LecturaArreglo2D
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 96
Inicializar un arreglo bidimensional con valores aleatorios.
Arreglo2DAleatorio.java
//Inicializa un arreglo 2D con valores aleatorios.public class Arreglo2DAleatorio{ public static void main( String[] args ) { int[][] tabla = new int[2][3];
System.out.println( "Arreglo con " + tabla.length + " renglones y " + tabla[0].length + " columnas."); System.out.println( "El arreglo 2D tiene valores random." ); //inicializa el arreglo 2D for( int ren = 0; ren < tabla.length; ren++ ) for( int col = 0; col < tabla[ren].length; col++ ) tabla[ren][col] = ( int )( Math.random() * 100 ); //imprime el primer renglón System.out.print( "El renglón 1 = [" ); System.out.print( tabla[0][0] + " " ); System.out.print( tabla[0][1] + " " ); System.out.print( tabla[0][2] + "]" ); } //fin del método main} //fin de la clase Arreglo2DAleatorio
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 97
Imprimir el contenido de un arreglo bidimensional.
ImprimirArreglo2D.java
//Imprime el contenido de un arreglo2D.public class ImprimirArreglo2D{ public static void main( String[] args ) { //Declara e inicializa un arreglo 2D de 3 renglones, 3 columnas int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} }; System.out.println( "Valores del arreglo." ); System.out.println( "" );
//imprime el contenido del arreglo for( int ren = 0; ren < tabla.length; ren++ ) { System.out.print( "Renglon " + ren + " = [ " ); for( int col = 0; col < tabla[ren].length; col++ ) System.out.print( tabla[ren][col] + " " ); System.out.println( "]" ); } //fin for } //fin del método main} //fin de la clase ImprimirArreglo2D
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 98
Sumar todos los elementos de un arreglo bidimensional.
SumaArreglo2D.java
//Suma todos los elementos del arreglo 2D.public class SumaArreglo2D{ public static void main( String[] args ) { //declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60,00, 70.00, 80.00, 99.99 } }; System.out.println( "Suma los datos del tabulador." ); System.out.println( "" );
double suma = 0.0; for( int ren = 0; ren < tabulador.length; ren++ ) for( int col = 0; col < tabulador[ren].length; col++ ) suma = suma + tabulador[ren][col]; System.out.println( "Suma = " + suma ); } //fin del método main} //fin de la clase SumaArreglo2D.
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 99
Suma los elementos de un arreglo bidimensional por columna.
SumaColumna.java
//Suma las columnas de un arreglo 2D.public class SumaColumna{ public static void main( String[] args ) { //declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60,00, 70.00, 80.00, 99.99 } }; System.out.println( "Suma los datos x columna." ); System.out.println( "" );
for( int col = 0; col < tabulador[0].length; col++ ) { double sumaCol = 0.0; for( int ren = 0; ren < tabulador.length; ren++ ) sumaCol = sumaCol + tabulador[ren][col]; System.out.println( "Columna " + col + " = " + sumaCol ); } //fin for } //fin del método main} //fin de la clase SumaColumna
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 100
Suma por renglón y encuentra el mayor.
SumaRenglon.java
//Suma los renglones de un arreglo 2D y encuentra el mayor.public class SumaRenglon{ public static void main( String[] args ) { //declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60,00, 70.00, 80.00, 99.99 } }; System.out.println( "Suma los datos x renglón." ); System.out.println( "" );
double max = 0.0; //el renglón mayor //obtiene la suma del primer renglón y lo asigna a max for( int col = 0; col < tabulador[0].length; col++ ) max = max + tabulador[0][col]; //procesa el arreglo2D, imprime la suma por cada renglón //y muestra el renglón con la suma más grande for( int ren = 0; ren < tabulador.length; ren++ ) { double sumaRen = 0.0; for( int col = 0; col < tabulador[ren].length; col++ ) sumaRen = sumaRen + tabulador[ren][col]; if( sumaRen > max ) //Busca la suma más grande max = sumaRen; //actualiza el renglón mayor System.out.println( "Renglón " + ren + " = " + sumaRen ); } //fin for System.out.println( "El renglón de mayor suma = " + max ); } //fin del método main} //fin de la clase SumaRenglon
© Raúl Oramas Bustillos 2012.
Fundamentos de Programación con Java → Arreglos bidimensionales. 101
Intercambio aleatorio de un arreglo bidimensional.
Shuffling2D.java
//Intercambio aleatorio de los elementos de un arreglo 2D.public class Shuffling2D{ public static void main( String[] args ) { //declara e inicializa un arreglo de 3x3 int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} }; //procesa el arreglo intercambiando los valores for( int ren = 0; ren < tabla.length; ren++ ) { for( int col = 0; col < tabla[ren].length; col++ ) { //genera indices aleatorios para ren, col int renAux = ( int )( Math.random() * tabla.length ); int colAux = ( int )( Math.random() * tabla[col].length ); //intercambia tabla[ren][col] por tabla[renAux][colAux] int temp = tabla[ren][col]; tabla[ren][col] = tabla[renAux][colAux]; tabla[renAux][colAux] = temp; } //fin for } //fin for
System.out.println( "El arreglo después del shuffling." ); //imprime el contenido del arreglo for( int ren = 0; ren < tabla.length; ren++ ) { System.out.print( "Renglón " + ren + " = [ " ); for( int col = 0; col < tabla[ren].length; col++ ) System.out.print( tabla[ren][col] + " " ); System.out.println( "]" ); } //fin for } //fin del método main} //fin de la clase Shuffling2D
© Raúl Oramas Bustillos 2012.