Está en la página 1de 23

LABORATORIO NRO.

01
1. OBJETIVOS DE LABORATORIO
● Crear programas que implementen variables y constantes de diferentes tipos de
datos, expresiones y estructuras de control de flujo.
● Construir arreglos de una dimensión
● Guardar datos dentro de un arreglo de una dimensión
● Leer información de un arreglo de una dimensión
● Efectuar cálculos con los elementos de un arreglo de una dimensión

2. REVISIÓN TEÓRICA
2.1. Tipos primitivos en Java

En la siguiente tabla, en la columna de la izquierda, pueden verse los tipos


primitivos. Una forma fácil de diferenciarlos con las clases es que comienzan con
minúscula. Estos tipos son similares a los del lenguaje C u otros lenguajes no orientados
a objetos.

A un dato de tipo primitivo no es necesario crearlo con new, como a un objeto.


Tampoco es posible acceder a ningún campo o método asociado. No tienen.

Los datos de tipos primitivos se guardan en memoria, en la Pila o Stack, en vez de en la


memoria Heap donde se guardan los objetos. Esto hace más simple y eficiente el
manejo de memoria.
2.2. Tipos no primitivos o por referencia

Las variables de tipo por referencia (que por lo general se llaman referencias)
para almacenar las ubicaciones de los objetos en la memoria de la computadora.

Por ejemplo, el tipo String es una variable de referencia. Pues hace “referencia” a un
arreglo definido del tipo char. Es por eso por lo que en Java el tipo String se define a
través de una clase.

Variables

Sirven para almacenar datos durante la ejecución del programa; el valor asociado
puede cambiar varias veces durante la ejecución del programa.

Constantes o variables finales

También sirven para almacenar datos, pero una vez asignado el valor, éste no puede
modificarse posteriormente.

Casting o “Moldes”

Con operadores que producen la conversión entre tipos. Admite las conversiones de
promoción y de contracción indicadas anteriormente. Por ejemplo: si se desea convertir
un valor de tipo Double a un valor de tipo int se utilizará el siguiente código:
int n;

double x = 82.4;

n = (int) x;

La variable n toma el valor 82 (valor en formato entero). El valor de x no se modifica.

2.3. Datos estructurados

Una estructura de datos es una forma de organizar un conjunto de datos


elementales (un dato elemental es la mínima información que se tiene en el sistema) con
el objetivo de facilitar la manipulación de estos datos como un todo y/o
individualmente.

Algunas estructuras de datos utilizadas en programación son:

∙ Arrays (Arreglos) ● Árboles


∙ Listas enlazadas ● Conjutno
s
∙ Clases ● Grafos
∙ Pilas y colas ● Montícul
os

2.3. Arreglos
1.

Un arreglo es una secuencia de datos del mismo tipo:

● Los datos se llaman elementos del arreglo y se numeran 0, 1, 2, ...


● Estos números localizan al elemento dentro del arreglo y se denominan índices
● Los índices del arreglo empiezan con 0 y terminan con el tamaño del arreglo -1
● Si el arreglo tiene n elementos, se denotan como a[0], a[1], ... a[n-1]

0 1 2 3 n
-
1
Valor Valor Valor Valor … … Valor
1 2 3 4 n
Sintaxis para definir arreglo de un número determinado de elementos:

● tipo nombreArreglo [ ] = new tipo [numeroDeElementos]

Ejemplo:

float notas = new float [26];

int [ ] a;

a = new int[10];

Tamaño del arreglo

Java considera cada arreglo como un objeto:

● El número de elementos de un arreglo se conoce accediendo al campo length

double [ ] v = new double [15]

System.out.print(v.length); // escribe 15

El campo length está protegido, no se puede modificar

3. DESARROLLO DE LABORATORIO
3.1. Ejercicios resueltos de tipos de datos

Cree un nuevo proyecto llamado laboratorio1, y también cree un paquete llamado


TiposDeDatos.

A. Cree la Clase Ejemplo1 y pruebe el siguiente código

package TiposDeDatos;

public class Ejemplo1 {

public static void main(String[] args) {


int
n=100; byte
m=1; char l='a'
;
System.out.println(n+m+l);
}
}
Copie la salida:

Explique el Resultado:

La salida es 198 por que el valor de a lo toma como su valor ascii que es 97 , entonces
100 +1 +97 =198

B. Cree la Clase Ejemplo2 y pruebe el siguiente código

public class Ejemplo2 {


public static void main(String[] args) {
for(int i=97; i<123; ++i) {
char letra=(char)i;
System.out.println(letra);
}
}
}

Copie la salida:

Explique el Resultado:

Aquí hay un for que va desde 97 a 123 y en su cuerpo se crea la variable letra de tipo char
que toma los valores del primer i entero hasta el ultimo i entero, pero convirtiéndolo a char
mediante el casteo y por ultimo imprime cada letra (todo el abecedario)
C. Cree la Clase Ejemplo3 y pruebe el siguiente código

package TiposDeDatos;
public class Ejemplo3 {
// Conversiones

public static void main(String[] args) {

int a=2;
double b=3.0;
float c= (float)(2000*a/b +5);

System.out.println("Valor en formato float: "+c); System.out.println("Valor en


formato double: "+ (double)c); System.out.println("Valor en formato byte: "+(byte)c);
System.out.println("Valor en formato short: "+ (short)c); System.out.println("Valor en
formato int: "+ (int)c); System.out.println("Valor en formato long: "+(long)c);

}
}

Copie la salida:

Explique el Resultado:

Primero saber que el resultado original en decimal es 1338.33333 periodico puro, entonces
para el caso de casting del resultado a float toma solo 3334 por la cantidad de 32bits máximo
que puede ocupar en la memoria .En el caso de doublé la capacidad de memoria se duplica a
64 bits gracias a esto le permite representar mayor cantidad de espacios decimales.En el caso
de byte solamente le permite almacenar solo 8 bits es decir 8 espacios de derecha a izquierda
00111010.En los casos short long e int estos son todos enteros es decir solo reciben la parte
entera del resultado y la mantienen su este no supera el espacio de memoria permitido por
cada una de estas variables.
D. Cree la Clase Ejemplo3 y pruebe el siguiente código

package TiposDeDatos;

public class Ejemplo4 {

public static void main(String[] args) {

int i=9,k;
float j= 47.9F;

System.out.println("i: " +i+ " j: "+j); k=


(int)j; // empleo de un cast
System.out.println("j: " +j+ " k: "+k); j=k; //
no necesita cast System.out.println("j: " +j+ "
k: "+k);
float m=2.3F; // float m=2.3; daria error al compilar System.out.println("m: "
+m);
}

Copie la salida:

Explique la importancia de un cast:

La primera fila imprime los valores tal cual como fueron declarados. La segunda fila
imprime el valor k como la conversión a entero de j. La tercera fila imprime iguala j con k
pero como j sigue siendo float lo almacena como 47.0 y no como 47.La cuarta fila nos
muestra que apra declarar una varible tipo float es necesario poner una F al final de la
declaración para q no nos salga algún tipo de error.

3.2. Ejercicios propuestos


1. Implemente un programa para imprimir en forma inversa el abecedario en
mayúsculas utilizando do while.
Codificación
public class EjerciciosPropuesto1 {
public static void main(String []args){
int i=91;
do{

i=i-1;
char letra=(char) i;

System.out.print(letra+" ,");
}
while(i>=66);

}
}

SALIDA

Explicación

Al igual que las minúsculas las mayúsculas también tienen un valor ascii , encontré a ‘A’ como 65 y
‘Z’ como 90, entonces como pide “do while”, el do siempre va funcionar hasta que llegue a la parte
de while , es por eso que tuve que poner en iteración una posición más o extra , porque mi contador i
al comienzo iva a realizar la operación de restar 1 sin ningún tipo de restricción hasta que llegue al
while y verifique que si cumple con la condición . En cuanto al cuerpo del “do”
Hay un contador que va reducirse en 1 por cada iteración, un casting (char) a el valor de “i” por cada
iteración y finalmente la impresión de todos los valores que tomara i mientras cumpla con la
condición del “while”
2. Implemente un programa que imprima el abecedario en minúscula y mayúscula.
Codificación

import java.util.Scanner;
import javax.swing.JOptionPane;
public class EjerciciosPropuesto1 {
public static void main(String []args){
Scanner sc= new Scanner (System.in);
System.out.println("Desea \n 1:Mayusculas "
+ " \n 2:minusculas"
+ "\n Por favor escriba 1 si desea Mayusculas,2 si desea minusculas");
int respuesta =sc.nextInt();
if(respuesta == 1){
for(int i=65;i<=90;i++){
char letra=(char) i;

System.out.print(letra+" ,");
}
System.out.println("\n VUELVA A CORRER EL PROGRAMA SI DESEA OTRA MUESTRA");
}

else if(respuesta == 2){


for(int j=97;j<=120;j++){
char letra1=(char)j;
System.out.print(letra1+" ,");
}
System.out.println("\n VUELVA A CORRER EL PROGRAMA SI DESEA OTRA MUESTRA");
}

else{
}
}
}

Salida
Explicación

Utilizo un scanner para introducir las respuestas, con el objetivo de ingresar por teclado un numero
entero según las opciones disponibles, que en este caso la opción 1 es para Mayúsculas y la opción 2 es
para minúsculas, en caso de escribir cualquier otro número no hará nada el programa porque en el
último else no puse alguna sentencia que tenía que seguir solamente lo deje vacío.
Si escoge 1 entonces las mayúsculas empezaran a imprimirse haciendo casting desde el primer valor
ascii hasta el último que es 90, pero cuando escoge 2 procede a ejecutarse el cuerpo del segundo if del
mismo modo que el primero solo que la diferencia son los valores ascii distintos por que para este caso
queremos minúsculas. En cada condicional muestro un mensaje acabando el for que trata de
recomendar al usuario que vuelva a ejecutar el programa si desea otra muestra.

3. Desarrollar un programa de que resuelva la siguiente formula.

Codificación

import javax.swing.JOptionPane;
public class EjercicioPropuesto3 {
public static void main(String[] args) {
double f = Double.parseDouble(JOptionPane.showInputDialog("INGRESE EL
VALOR DE F "));
System.out.println(f);
double c = ((f-32)*5)/9;

JOptionPane.showMessageDialog(null,"EL RESULTADO DE LA FORMULA


((F-32)*5)/9 ES "
+ "\n" + c);
}
}
Salida

Explicación

Utilice el JOptionPane para este ejercicio por la simplicidad del método ,entonces
primeramente cree la variable f como tipo double ya que muchas veces el tamaño de las
variables a utilizar en las formulas es grande y también puede tener la necesidad de exactitud
(mayor capacidad de almacenamiento de decimales).
Después utilizo la impresión del valor almacenado como JOptionPane ,la f.
Desarrollo la definición de toda la formula y la almaceno en la variable c para después
mostrarla utilizando en JOptionPane.showMessageDialog.
4. Cree una clase triángulo y desarrolle sus operaciones básicas
Codificación
import javax.swing.JOptionPane;
public class EjercicioPropuesto04 {
public static void main(String[] args) {
double base = Double.parseDouble(JOptionPane.showInputDialog("INGRESE LA BASE DEL
TRIANGULO "));
double altura= Double.parseDouble(JOptionPane.showInputDialog("INGRESE LA ALTURA DEL
TRIANGULO "));
double hipotenusa;
hipotenusa = Math.sqrt(base*base+altura*altura);
int eleccion=Integer.parseInt(JOptionPane.showInputDialog("ESCRIBA 1 O 2 \n 1:PERIMETRO \n
2:AREA "));
System.out.println(base);
System.out.println(altura);
if(eleccion == 1){
double respPerimetro = base + altura + hipotenusa;
JOptionPane.showMessageDialog(null,respPerimetro);
}
else if(eleccion == 2){
double respArea = (base*altura)/2;
JOptionPane.showMessageDialog(null,respArea);
}
else{
JOptionPane.showMessageDialog(null,"PORFAVOR SOLO INGRESE 1 O 2");
}
}
}
Salida
Explicación

Para este caso también uso JOptionPane , declaro variables que contendrán los JOptionPane como
double por la cantidad de espacio que puede llegar a almacenar y además como las medidas
muchas veces contienen decimal ,también influyeron en mi decisión por el double.La base y la
altura son suficientes para determinar la hipotenusa mediante el establecimiento de una formula
en ella al momento de declarla.Luego le doy al usuario la opción de poder escoger que necesita
sabes mediante dos opciones,el área o el perímetro .Si es área se ejecuta el contenido del
condicional con valor tomado como 1 ,en caso del perímetro se debe escoger la opción 2 para
poder ejecutarse el cuerpo de la segunda condición y sino es ninguna de las opciones anteriores le
pido al usuario que solo escoja alguna de las dos opciones.

3.3. Ejercicios resueltos de arreglos

En el mismo proyecto laboratorio1 cree el paquete Arreglos.

A. Cree la Clase Arreglo1 y pruebe el siguiente código que lee 10 números


enteros, los guarda en un array y calcula la media de los números que estén
en las posiciones pares.

package Arreglos;

import java.util.*; public


class Arreglo1 {
public static void main(String[] args) {

Scanner sc = new
Scanner(System.in); int i;
int[] numeros = new int[10];
double media = 0;

//lectura de datos y llenar el array System.out.println("Lectura de los


elementos del array: "); for (i = 0; i < 10; i++) {
System.out.print("numeros[" + i + "]= ");
numeros[i] = sc.nextInt();
}

//Recorrer el array y calcular la media


for (i = 0; i < 10; i++) {
if (i % 2 == 0){ //si la posición actual es par
media = media + numeros[i]; //se suma el valor de esa posición
}
}
//Calcular y mostrar la media
System.out.println("Media de los valores que se encuentran en posiciones pares: "+
media/5);
}
}
Copie la salida:

Qué realiza la clase Scanner:

La clase scanner permite ingresar por teclado los valores ,los valores son números int de
rango 10 es decir de 0 a 9 y poder almacenarlos mediante el metodo .nextInt().

B. Cree la Clase Arreglo2 y pruebe el siguiente código que gestiona las notas
de un centro educativo. Cada grupo (o clase) está compuesto por 5 alumnos.

package Arreglos;

public class Arreglo2 {

public static void main(String[] args) {

Scanner entrada= new Scanner(System.in);


int primer[], segundo[], tercer[]; // notas del primer, segundo y tercer trimestre
int num,i;
int suma_primer, suma_segundo, suma_tercer; double
media_alumno;

// creamos las tablas necesarias primer =


new int [5];
segundo = new int [5];
tercer = new int [5];

// leemos las notas del primer trimestre System.out.println("Notas de primer


trimestre:");

for (i=0;i<5;i++){ System.out.print("Alumnos ("+i+"): ");


primer[i]=entrada. nextInt();
Se pide leer las notas del primer, segundo y tercer trimestre de un grupo.
Debemos mostrar al final: la nota media del grupo en cada trimestre, y la
media del alumno que se encuentra en la posición N (N se lee por teclado).
}

// leemos las notas del segundo trimestre


System.out.println("Notas del segundo trimestre:"); for
(i=0;i<5;i++){
System.out.print("Alumno ("+i+"): ");
segundo[i]= entrada. nextInt ();
}

// leemos las notas del tercer trimestre System.out.println("Notas


del tercer trimestre:");

for (i=0;i<5;i++){
System.out.print("Alumnos ("+i+"): ");
tercer[i]= entrada. nextInt ();
}

// calculamos las medias


suma_primer = 0; // ponemos a 0 los acumuladores
suma_segundo = 0;
suma_tercer = 0;

for (i =0; i < 5; i++){


suma_primer += primer[i];
suma_segundo += segundo[i];
suma_tercer += tercer[i];
}

// mostramos datos
System.out.println("Media primer trimestre: "+ suma_primer/5.0);
System.out.println("Media segundo trimestre: "+ suma_segundo/5.0);
System.out.println("Media tercer trimestre: "+ suma_tercer/5.0); System.out.println();

// leemos la posición del alumno que nos interesa


// una posible mejora es comprobar que el índice se encuentre
// entre 0 y 4

System.out.print ("Introduzca posición del alumno (de 0 a 4): "); num=


entrada. nextInt();
// la media del alumno es la suma de sus notas entre 3
media_alumno = (double) (primer[num]+segundo[num]+tercer[num])/3;

System.out.println("La media del alumno es: " + media_alumno);

}
Copie la salida:

Explique qué realiza la siguiente línea de código suma_primer += primer[i];

C. Cree la Clase ArregloNumeros y pruebe el siguiente código

package Arreglos;

public class ArregloNumeros {

public static void main(String[] args) {

int n,i;
double x [ ]= new double[50];

Scanner valor =new Scanner (System.in);


System.out.println("INGRESO DE LOS DATOS");
System.out.println("Cuantos datos va a ingresar?");

n=valor.nextInt(); // double x [ ]= new double[n];

for (i=0;i<=n-1;i++) {
System.out.println("Dato ["+(i+1)+"]:");
x[i]=valor.nextDouble();
}
System.out.println("IMPRESION DE LOS

DATOS"); for (i=0;i<=n;i++) { //for (i=0;i<=x.length;i++)

System.out.println("dato [" +(i+1)+"]: "+x[i]);


}

}
Copie la salida:

Explique el resultado:

D. Cree la Clase ArregloMetodos y pruebe el siguiente código. Programa que


permita ingresar datos numéricos de forma aleatoria, halla el mayor y la
suma de los datos.

package Arreglos;

import java.text.DecimalFormat;
import java.util.Scanner;

public class ArregloMetodos {

//PROGRAMA PRINCIPAL
public static void main(String[] args) {

int n,i;
double sum;

Scanner valor =new Scanner (System.in);


System.out.println("INGRESO DE LOS DATOS");
System.out.println("Cuantos datos va a ingresar?");

n=valor.nextInt();
double x []= new double[n];

leer (x, n); // función que se encarga de la lectura de datos visualizar (x,
n); //función que se encarga de la visualización de datos sum=sumaarreglo(x, n);
// función que realiza la suma de datos System.out.println("la suma de los
elementos es: "+sum);
mayor(x, n); //función que busca el mayor en un arreglo
}

//FUNCIONES
//////////////////////////////////////// static void
leer(double b[], int m){

double x;
DecimalFormat dosDigitos = new DecimalFormat( "0.00" );

for(int i=0;i<m;
i++){
x=Math.random()*100;
String
y=dosDigitos.format(x);
b[i]=Double.parseDouble(y);
}
}

/////////////////////////////////////// static void


visualizar(double b[], int m){

int i,j;
System.out.println("\n\t Matriz leida ");

for(i=0; i < m; i++){


System.out.println("dato [" +(i+1)+"]: "+b[i]);
System.out.println(" ");
}
}

/////////////////////////////////////// static double


sumaarreglo (double b[], int m){

double s=0;

for(int i=0; i < m; i+


+){ s +=b[i];
}
return s;
}

/////////////////////////////////////// static void mayor


(double b[], int m){
double ma=0, pos = 0;

for(int i=0; i < m; i++){

if (i==0){
ma=b[i]; pos=i;
} else {
if
(b[i]>ma){ ma
=b[i]; pos =i;
}
}
}
System.out.println("la posición del elemento mayor es : "+(pos+1));
}

}
}

Copie la salida:

Explique qué realiza el método Math.random():

Explique la ejecución de la siguiente línea de código DecimalFormat dosDigitos = new


DecimalFormat( "0.00" );

3.4. Ejercicios propuestos de arreglos


1. Crea un programa en el que se pida por consola el nombre de 2 alumnos y la
nota de cada uno de ellos como valor numérico. El resultado que debe mostrarse
es el nombre de cada alumno, su nota y su calificación como texto
(Sobresaliente, Notable, Bien o Suspenso). Para ello crea un array numérico y
otro de String (ambos unidimensionales). En el array numérico se insertarán las
calificaciones facilitadas por el alumno entre 0 y 10 (debemos controlar que
inserte una nota valida), pudiendo ser decimal. En el array de Strings se
insertarán los nombres de los alumnos. Crea también un array de String donde
insertaremos el resultado de
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA
DE SISTEMAS ESTRUCTURA DE DATOS (IS-241)

la nota con palabras admitiéndose estos valores: Sobresaliente, Notable, Bien o


Suspenso.

El programa debe comprobar la nota de cada alumno teniendo en cuenta esta


equivalencia:

● Si la nota está entre 0 y 10.49 será un Suspenso.


● Si la nota está entre 10.50 y 13.99 será un Bien.
● Si la nota está entre 14 y 17.99 será un Notable.
● Si la nota está entre 18 y 20 será un Sobresaliente.

Mostrar por pantalla, el alumno su nota y su resultado en palabras utilizando


bucles. Crea los métodos que creas convenientes.

2. Crea un array de números de un tamaño ingresado por teclado, el array


contendrá números aleatorios primos entre los números deseados, por último,
nos indica cual es el mayor de todos.
3. Crea un array de números de un tamaño ingresado por teclado, el array
contendrá números aleatorios entre 1 y 300 y mostrar aquellos números que
acaben en un dígito que nosotros le indiquemos por teclado (debes controlar que
se introduce un numero correcto), estos deben guardarse en un nuevo array. Por
ejemplo, en un array de 10 posiciones e indicamos mostrar los números
acabados en 5, podría salir 155, 25, etc.
4. Crear un programa que lea por teclado una tabla de 10 números enteros y la
desplace una posición hacia abajo: el primero pasa a ser el segundo, el segundo
pasa a ser el tercero y así sucesivamente. El último pasa a ser el primero.