UNIVERSIDAD MAYOR DE SAN ANDRES

FACULTAD DE INGENIERIA
CARRERA DE MECANICA - ELECTROMECANICA
LABORATORIA DE METODOS NUMERICOS 3

INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

ESTUDIANTE: ZEBALLOS HUARACHI DANIEL ISAIAS

R.U.: 1780338 C.I.: 13116332 CARRERA: ING. MECATRONICA
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

OBJETIVOS. –
Crear programas usando Arreglos, así como utilerías y clases propias del lenguaje para realizar
alunas tareas comunes y recurrentes.
MARCO TEORICO. –
Nos introducimos a las estructuras de datos: que son colecciones de elementos de datos
relacionados. Los arreglos son estructuras de datos que consisten de elementos de datos
relacionados, del mismo tipo. Conservan la misma longitud una vez creados, aunque puede
reasignarse una variable tipo arreglo de tal forma que haga referencia a un nuevo arreglo de distinta
longitud.
Un arreglo es un grupo de variables (llamadas elementos o componentes) que contienen
valores, todos del mismo tipo. Los arreglos son objetos, por lo que se consideran como tipos de
referencia.
Para hacer referencia a un elemento específico en un arreglo, debemos especificar el nombre de la
referencia al arreglo y el número de la posición del elemento en el arreglo. El número de la posición
del elemento se conoce formalmente como el índice o subíndice del elemento.
En la figura se muestra una representación lógica de un arreglo de enteros, llamado c. Este arreglo
contiene 12 elementos. Un programa puede hacer referencia a cualquiera de estos elementos
mediante una expresión de acceso a un arreglo que contiene el nombre del arreglo, seguido por el
índice del elemento específico encerrado entre corchetes ([]). El primer elemento en cualquier arreglo
tiene el índice cero, y algunas veces se le denomina elemento cero. Por lo tanto, los elementos del
arreglo c son c[0], c[1], c[2], y así en lo sucesivo.

Se pueden hacer una gran variedad de operaciones con los valores contenidos en los elementos del
arreglo.
Para crear un objeto arreglo, debemos especificar el tipo de cada elemento y el número de
elementos que se requieren para el arreglo, como parte de una expresión para crear un arreglo
que utiliza la palabra clave new.
int c[]=new int[12];

2
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

Esta expresión puede usarse para crear el arreglo que se muestra en la primera figura. Al crear un
arreglo, cada uno de sus elementos recibe un valor predeterminado: cero para los elementos
numéricos de tipos primitivos, false para los elementos boolean y null para las referencias. Como
pronto veremos, podemos proporcionar valores iniciales para los elementos no predeterminados al
crear un arreglo.
En la declaración, los corchetes que van después del tipo indican que c es una variable que hará
referencia a un arreglo (es decir, la variable almacenará una referencia a un arreglo).
A continuación, unos ejemplos de arreglos de distintos tipos:
String [ ] p;
double[][] matrizP = new double[3][3];
Este ultimo es para declarar un arreglo para una matriz 3x3, lo cual, veremos más adelante.
Ejemplo. –
a) Programa Java que llene un array con 10 números enteros que se leen por teclado. A
continuación, calcula y muestra la media de los valores positivos y la de los valores negativos
del array.
1. package preinforme3;
2.
3. import java.util.*;
4.
5. public class ejercicio1 {
6. public static void main(String[] args) {
7. Scanner sc = new Scanner(System.in);
8. int[] numeros = new int[10];
9. int pos = 0, neg = 0;
10. int i;
11. double sumaPos = 0, sumaNeg = 0;
12.
13. System.out.println("Lectura de los elementos del array: ");
14. for (i = 0; i < numeros.length; i++) {
15. System.out.print("numeros[" + i + "]= ");
16. numeros[i]=sc.nextInt();
17. }
18. for (i = 0; i < numeros.length; i++) {
19. if (numeros[i] > 0){
20. sumaPos += numeros[i];
21. pos++;
22. } else if (numeros[i] < 0){
23. sumaNeg += numeros[i];
24. neg++;
25. }
26. }
27. if (pos != 0) {
28. System.out.println("Media de los valores positivos: " +
sumaPos / pos);
29. } else {
30. System.out.println("No ha introducido números positivos");
31. }
32. if (neg != 0) {

3
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

33. System.out.println("Media de los valores negativos: " +

sumaNeg / neg);
34. } else {
35. System.out.println("No ha introducido números negativos");
36. }
37. }
38. }

Ahora veremos la instrucción for mejorada de java, la cual permite que un programa acceda a los
datos en un arreglo con más facilidad que la instrucción for controlada por contador.
La instrucción for mejorada itera a través de los elementos de un arreglo sin utilizar un contador,
con lo cual evita la posibilidad de “salirse” del arreglo.

Donde parámetro tiene un tipo y un identificador (por ejemplo, int numero), y “nombreArreglo” es el
arreglo a través del cual se iterará. El tipo del parámetro debe coincidir con el de los elementos en el
arreglo.
La instrucción for mejorada simplifica el código para iterar a través de un arreglo. No obstante, algo
que tomar en cuenta es que la instrucción for mejorada sólo puede utilizarse para obtener elementos
del arreglo; no para modificar los elementos. Si su programa necesita modificar elementos, use la
instrucción for tradicional, controlada por contador.

En la figura anterior esta un ejemplo del uso de for mejorada.

4
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

Los arreglos multidimensionales de dos dimensiones se utilizan con frecuencia para representar
tablas de valores, las cuales consisten en información ordenada en filas y columnas. Para identificar
un elemento específico de una tabla, debemos especificar dos subíndices. Por convención, el
primero identifica la fila del elemento y el segundo su columna.

Los nombres de los elementos en la fila 0 tienen todos un primer subíndice de 0, y los nombres de
los elementos en la columna 3 tienen un segundo subíndice de 3.
Un arreglo bidimensional b con dos filas y dos columnas podría declararse e inicializarse con
inicializadores de arreglos anidados, como se muestra a continuación:
int[][] b = { { 1, 2 }, { 3, 4 } };

Un arreglo multidimensional con el mismo número de columnas en cada fila puede formarse
mediante una expresión de creación de arreglos. Por ejemplo, en las siguientes líneas se declara el
arreglo b y se le asigna una referencia a un arreglo de tres por cuatro:
int[][] b = new int[ 3 ][ 4 ];
Este tipo de arreglo lo veremos en los ejercicios de laboratorio, generando una matriz 3x3 y una
matriz nxm.
Ahora presentaremos algunas manipulaciones comunes de arreglos con métodos static de la clase
Arrays, del paquete java.util.
Estos métodos incluyen sort para ordenar un arreglo (acomodar los elementos en orden
ascendente), binarySearch para buscar en un arreglo (es decir, determinar si un arreglo contiene un
valor específico y, de ser así, en dónde se encuentra este valor), equals para comparar arreglos y fill
para colocar valores en un arreglo.
La API de Java provee varias estructuras de datos predefinidas, conocidas como colecciones, que se
utilizan para almacenar grupos de objetos relacionados. Estas clases proveen métodos eficientes
que organizan, almacenan y obtienen los datos sin necesidad de saber cómo se almacenan éstos.
Gracias a esto, se reduce el tiempo de desarrollo de aplicaciones.
Los arreglos no cambian de manera automática su tamaño en tiempo de ejecución para dar cabida a
elementos adicionales. La clase de colección ArrayList<T> (del paquete java.util) provee una

5
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

solución conveniente a este problema: puede cambiar su tamaño en forma dinámica para dar cabida
a más elementos.

En la anterior figura se muestra unos métodos y propiedades de la clase ArrayList<T>, este tipo de
arreglo lo veremos en los ejercicios de laboratorio.
ACTIVIDADES DE LABORATORIO. –
1. Cargar por teclado los elementos de una matriz n x m y obtener la matriz transpuesta de
dicha matriz.
2. package laboratorio3;
3.
4. import java.util.Scanner;
5.
6. public class MatrizTranspuesta {
7. public static void main(String[] args) {
8. Scanner sc = new Scanner(System.in);
9.
10. System.out.println("*********************************");
11. System.out.println("****** MATRIZ TRANSPUESTA *****");
12. System.out.println("****** Mnxm *****");
13. System.out.println("****** n=numero de filas *****");
14. System.out.println("****** m=numero de columnas *****");
15. System.out.println("*********************************");
16.
17. System.out.print("Ingrese n= ");
18. int n = sc.nextInt();
19. System.out.print("Ingrese m= ");
20. int m = sc.nextInt();
21.
22. // matrizT=matriz Transpuesta
23.
24. int[][] matriz = new int[n][m];

6
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

25. int[][] matrizT = new int[m][n];

26.
27. System.out.println("*********************************");
28. System.out.println("Ingrese los elementos de la matriz:");
29. for (int i = 0; i < n; i++) {
30. for (int j = 0; j < m; j++) {
31. System.out.print("Elemento [" + (i+1) + "][" + (j+1) + "]: ");
32. matriz[i][j] = sc.nextInt();
33. }
34. }
35. for (int i = 0; i < m; i++) {
36. for (int j = 0; j < n; j++) {
37. matrizT[i][j] = matriz[j][i];
38. }
39. }
40.
41. System.out.println("*********************************");
42. System.out.println("La matriz transpuesta es:");
43. for (int i = 0; i < m; i++) {
44. for (int j = 0; j < n; j++) {
45. System.out.print(matrizT[i][j] + " ");
46. }
47. System.out.println();
48. }
49. System.out.println("*********************************");
50. sc.close();
51. }
52. }
53.

A continuación, mostramos su salida, usamos una matriz de 2x4:

7
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

2. Introducir un texto en minúscula o mayúscula por teclado y cambiar todas las letras: A
por 4, E por 3, I por 1, O por 0, y mostrar en consola.
3. package laboratorio3;
4. import java.util.Scanner;
5.
6. public class ejercicio2 {
7.
8. public static void main(String[] args) {
9. Scanner scanner = new Scanner(System.in);
10.
11. System.out.print("Ingrese un texto en minusculas o mayusculas: ");
12. String texto = scanner.nextLine();
13.
14. texto = texto.replaceAll("[Aa]", "4");
15. texto = texto.replaceAll("[Ee]", "3");
16. texto = texto.replaceAll("[Ii]", "1");
17. texto = texto.replaceAll("[Oo]", "0");
18.
19. System.out.println("Texto modificado: " + texto);
20.
21. scanner.close();
22. }
23. }

A continuación, mostramos la salida, introduciendo un texto en minúsculas:

3. Realizar un programa usando arreglos donde:

a) Se pide al usuario que ingrese la cantidad de estudiantes en el curso.
b) Se utilizan arreglos para almacenar los nombres y las notas de los estudiantes. Se
asume que cada estudiante tiene tres notas.
c) Se solicitan los nombres y las notas de los estudiantes mediante un bucle.
d) Se muestra la lista de estudiantes y sus respectivas notas.
e) Se calcula y muestra el promedio de notas de cada estudiante.
4. package laboratorio3;
5.
6. import java.util.Scanner;
7.
8. public class ejercicio3 {
9.
10. public static void main(String[] args) {
11. int[][] b = new int[ 3 ][ 4 ];
12.
13. Scanner scanner = new Scanner(System.in);
14. System.out.print("introduce el numero de estudiantes: ");
15. int numeroestudiantes = scanner.nextInt();
16.
17. String[] nombre=new String[numeroestudiantes];
18. double[][] nota = new double[numeroestudiantes][3];
19. double suma = 0;

8
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

20.
21. for (int i = 0; i < numeroestudiantes; i++) {
22. System.out.print("Ingrese el nombre del estudiante: ");
23. scanner.nextLine();
24. nombre[i]=scanner.nextLine();
25. System.out.println("Ingrese calificaciónes del estudiante ");
26. for(int j=0; j<3; j++) {
27. System.out.print("nota "+(j+1)+": ");
28. nota[i][j] = scanner.nextDouble();
29. }
30. }
31.
32. System.out.println("lista de estudiantes: ");
33. for(int i = 0; i < numeroestudiantes; i++) {
34. System.out.println("estudiante "+nombre[i]);
35. System.out.println("notas: ");
36. for(int j=0; j<3; j++) {
37. System.out.println(nota[i][j]+" ");
38. }
39. }
40. for (int i = 0; i < numeroestudiantes; i++) {
41. for(int j=0; j<3; j++) {
42. suma+=nota[i][j];
43. }
44. double promedio=suma/3;
45. System.out.println("Estudiante: "+nombre[i]+", promedio:
"+promedio);
46. }
47. scanner.close();
48. }
49. }

A continuación, mostramos la salida, introduciendo un numero de 3 estudiantes, colocando

nombres a cada uno y sus tres respectivas notas de cada alumno:

9
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

4. Realizar un programa para hallar la matriz inversa de una matriz 3x3

5. package laboratorio3;
6. import java.util.Scanner;
7.
8. public class MatrizInversa {
9. public static void main(String[] args) {
10. Scanner sc = new Scanner(System.in);
11.
12. //matrizP=matrizPrincipal
13. //matrizIn=matrizInversa
14. double[][] matrizP = new double[3][3];
15. double[][] matrizIn = new double[3][3];
16.
17.
18. System.out.println("****************************************");
19. System.out.println("**** MATRIZ INVERSA *****");
20. System.out.println("**** M3x3 *****");
21. System.out.println("****************************************");
22. System.out.println("Ingrese los elementos de la matriz 3x3:");
23. for (int i = 0; i < 3; i++) {
24. for (int j = 0; j < 3; j++) {
25. System.out.print(" Elemento [" + (i+1) + "][" + (j+1) + "]:
");
26. matrizP[i][j] = sc.nextDouble();
27. }
28. }
29. matrizIn = invertirMatriz(matrizP);
30.
31. System.out.println("****************************************");
32. System.out.println("La matriz inversa es:");
33. for (int i = 0; i < 3; i++) {
34. for (int j = 0; j < 3; j++) {
35. System.out.print(String.format("%.4f",matrizIn[i][j] ) + " ");
36. }
37. System.out.println();
38. }
39.
40. sc.close();
41. }
42.
43. // Calculando la matriz inversa
44. public static double[][] invertirMatriz(double[][] matriz) {
45. double[][] inversa = new double[3][3];
46.
47. double a = matriz[0][0];
48. double b = matriz[0][1];
49. double c = matriz[0][2];
50. double d = matriz[1][0];
51. double e = matriz[1][1];
52. double f = matriz[1][2];
53. double g = matriz[2][0];
54. double h = matriz[2][1];
55. double i = matriz[2][2];
56.
57. //dt=determinante
58. double dt = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e
* g);

10
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

59.
60. if (dt == 0) {
61. System.out.println("La matriz no tiene inversa.");
62. System.exit(0);
63. }
64.
65. inversa[0][0] = (e * i - f * h) / dt;
66. inversa[0][1] = (c * h - b * i) / dt;
67. inversa[0][2] = (b * f - c * e) / dt;
68. inversa[1][0] = (f * g - d * i) / dt;
69. inversa[1][1] = (a * i - c * g) / dt;
70. inversa[1][2] = (c * d - a * f) / dt;
71. inversa[2][0] = (d * h - e * g) / dt;
72. inversa[2][1] = (b * g - a * h) / dt;
73. inversa[2][2] = (a * e - b * d) / dt;
74.
75. return inversa;
76.
77. }
78.
79. }

A continuación, mostramos la salida, ingresamos por teclado cada elemento de la matriz,

después por medio del método de la adjunta transpuesta haya la inversa, siempre teniendo en
cuenta que el determinante de dicha matriz no debe ser 0, sino la inversa no existirá:

OBSERVACIONES. –
En este laboratorio se empezó nuestra introducción a las estructuras de datos, con la exploración del
uso de los arreglos para almacenar datos y obtenerlos de listas y tablas de valores. Los ejemplos de
este capítulo demostraron cómo declarar un arreglo, inicializarlo y hacer referencia a los elementos
individuales del mismo.

11
 INFORME 3
ARREGLOS, UTILERIAS Y CLASES DE USO GENERAL

En este laboratorio se demostró cómo escribir métodos que utilizan listas de argumentos de longitud
variable, y cómo leer argumentos que se pasan a un programa desde la línea de comandos
BIBLIORAFIA. –
Miranda, William. (2024). Guía de Laboratorio de Métodos Numéricos 3.
Deitel, Paul & Deitel, Harvey. (2012). Cómo programar en Java.

12