JAVA

1 - Instalación de Java
2 - Instalación del editor Eclipse
3 - Pasos para crear un programa con Eclipse
4 - Ejercicio de Ejemplo
5 - Estructura de programación secuencial
6 - Estructuras condicionales simples y compuestas
7 - Estructuras condicionales anidadas
8 - Condiciones compuestas con operadores lógicos
9 - Estructura repetitiva while
10 - Estructura repetitiva for
11 - Estructura repetitiva do while
12 - Cadenas de caracteres en Java
13 - Declaración de una clase y definición de objetos.
14 - Declaración de métodos.
15 - Estructura de datos tipo vector
16 - Vector (Tamaño de un vector)
17 - Vectores paralelos
18 - Vectores (mayor y menor elemento)
19 - Vectores (ordenamiento)
20 - Vectores (ordenamiento con vectores paralelos)
21 - Estructura de datos tipo matriz
22 - Matrices (cantidad de filas y columnas)
23 - Matrices y vectores paralelos
24 - Matrices irregulares
25 - Constructor de la clase
26 - Clase String
 1 - Instalación de Java

Para poder hacer este curso debemos instalar el compilador de Java y la

máquina virtual de Java. Estas herramientas las podemos descargar de:

Java SE Development Kit 11.

Si disponemos como sistema operativo Windows debemos descargar

La versión a instalar conviene que sea la última (en este momento

disponemos la versión 11)
 Una vez que tenemos el JDK (Java Development Kit) procedemos a
instalarlo:

Presionamos el botón "next". Haremos la instalación por defecto por lo

que presionamos el botón next nuevamente (dejaremos el directorio por
defecto donde se almacenará Java):

Esperamos unos minutos mientras se procede a la instalación de Java:

 Una vez finalizado el proceso de instalación debe aparecer un diálogo
similar a este y presionamos el botón Close (por el momento no vamos a
instalar "Tutorials, Api documentation etc.):

Con esto ya tenemos instalado en nuestra computadora el compilador de

Java y la máquina virtual que nos permitirá ejecutar nuestro programas. En el
próximo concepto instalaremos un editor de texto para poder codificar
nuestros programas en Java.
 2 - Instalación del editor Eclipse

En el concepto anterior procedimos a instalar el lenguaje Java (con

dichas herramientas podemos ejecutar y compilar programas codificados en
java), pero ahora necesitamos instalar el Eclipse que es un editor para
codificar los programas (si bien podemos utilizar otros editores, nosotros
utilizaremos este para seguir el curso)

La versión a instalar es la 2018 o posterior:

Una vez que descargamos el instalador de Eclipse procedemos a

ejecutarlo y debemos elegir el entorno "Eclipse IDE for Java Developers":
 Seleccionamos la carpeta donde se instalará el Eclipse:

Una vez instalado en forma completo el "Eclipse IDE for Java

Developers" nos dirigimos a la carpeta donde se instalaron los archivos y
procedemos a ejecutar el programa eclipse.exe (podemos ingresar desde el
acceso directo que se crea en el escritorio)

Primero aparece un mensaje de inicio del Eclipse:

 Luego la primera vez que ejecutemos el editor Eclipse aparece un diálogo
para seleccionar la carpeta donde se almacenarán los programas que
desarrollaremos (podemos crear una carpeta donde almacenaremos todos
los proyectos que desarrollaremos en el curso, si indicamos una carpeta que
no existe el mismo Eclipse la crea):

Luego de configurar la carpeta donde se crearán los proyecto aparece el

editor con una pantalla de presentación (Welcome):

Esta ventana de bienvenida la podemos cerrar seleccionando el ícono:

"Workbench", con lo que aparece el entorno de trabajo del Eclipse (si
queremos nuevamente ver la ventana de bienvenida podemos activarla
desde el menú de opciones: Help -> Welcome)

El entorno de trabajo del Eclipse es:

3 - Pasos para crear un programa con Eclipse

El Eclipse es un entorno de trabajo profesional, por lo que en un principio

puede parecer complejo el desarrollo de nuestros primeros programas.

Todo programa en Eclipse requiere la creación de un "Proyecto", para

esto debemos seleccionar desde el menú de opciones:
 Ahora aparece el diálogo donde debemos definir el nombre de nuestro
proyecto:

En el campo de texto "Project Name" ingresamos como nombre:

Proyecto1 y dejamos todas las otras opciones del diálogo con los valores por
defecto. Presionamos el botón "Finish".

Aparece un nuevo diálogo que nos pide si queremos crear un módulo

para nuestro proyecto, elegimos la opción para que no lo crea:
 Ahora en la ventana de "Package Explorer" aparece el proyecto que
acabamos de crear:

Como segundo paso veremos que todo programa en Java requiere como
mínimo una clase. Para crear una clase debemos seleccionar desde el menú
de opciones:

O desde la barra de íconos del Eclipse:

 En el diálogo que aparece debemos definir el nombre de la clase (en
nuestro primer ejemplo la llamaremos Clase1 (con mayúscula la letra C),
luego veremos que es importante definir un nombre que represente al
objetivo de la misma), los otros datos del diálogo los dejamos con los valores
por defecto:

Luego de presionar el botón "Finish" tenemos el archivo donde podemos

codificar nuestro primer programa:
 Más adelante veremos los archivos que se crean en un proyecto, ahora
nos dedicaremos a codificar nuestro primer programa. En la ventana de
edición ya tenemos el esqueleto de una clase de Java que el entorno Eclipse
nos creó automáticamente.

public class Clase1 {

}

Todo programa en Java debe definir la función main. Esta función la

debemos codificar dentro de la clase: "Clase1".

Procedemos a tipear lo siguiente:

public class Clase1

{
public static void main(String[] parametro)
{
System.out.println("Hola Mundo Java");
}
}

Es decir tenemos codificado en el entorno del Eclipse nuestro primer

programa:
 Como último paso debemos compilar y ejecutar el programa, esto lo
podemos hacer desde el menú de opciones:

O desde la barra de íconos del Eclipse:

Si no hay errores de codificación debemos ver el resultado de la

ejecución en una ventana del Eclipse llamada "Console" que aparece en la
parte inferior (puede aparecer un diálogo pidiendo que grabemos el archivo,
el cual confirmamos):

Lo más importante es que quede claro los pasos que debemos dar para
crear un proyecto en Java. El objetivo de una clase, la función main etc. los
veremos a lo largo de este curso.

4 - Ejercicio de Ejemplo

import java.util.Scanner;
public class SueldoOperario {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int horasTrabajadas;
float costoHora;
float sueldo;
System.out.print("Ingrese la cantidad de horas trabajadas por el
empleado:");
horasTrabajadas=teclado.nextInt();
System.out.print("Ingrese el valor de la hora:");
costoHora=teclado.nextFloat();
sueldo=horasTrabajadas * costoHora;
System.out.print("El empleado debe cobrar:");
System.out.print(sueldo);
}
}

Explicación.

Ahora veremos una explicación de varias partes de nuestro programa y

otras partes quedarán pendientes para más adelante ya que en este
momento difícilmente se entiendan.

Conceptos que quedarán pendientes para explicar:

 Concepto de una clase. Veremos más adelante que en Java todo debe
estar contenido en clases, por lo que hasta el problema más elemental
debe estar contenido en una clase. Para declarar una clase utilizamos la
sintaxis:

public class SueldoOperario {

}

 El nombre de la clase no puede tener espacios en blanco, comienza con

una letra mayúscula y en caso de estar constituida por dos o más
palabras el primer caracter va en mayúsculas, no puede empezar con un
número, pero si puede llevar números a partir del segundo caracter. Toda
clase debe tener una llave de apertura y una llave de cierre.

Todo programa constituido por una única clase debe tener definida la
función main:

public static void main(String[] ar) {

}

La función main es la primera que se ejecuta y debe llevar la sintaxis

indicada anteriormente (más adelante veremos que significa el parámetro ar,
las palabras claves public, static y void). La función main tiene una llave de
apertura y una llave de cierre (similar a la clase). La función main debe estar
contenida en la clase.

 Cuando se requieren utilizar otras clases debemos importarlas previo a la

declaración de la clase, en nuestro problema utilizamos la clase Scanner
que se encuentra en el paquete java.util por lo que la importamos con la
siguiente sintaxis:

import java.util.Scanner;

En la main creamos un objeto de la clase Scanner que nos permitirá

ingresar por teclado los valores:

Scanner teclado=new Scanner(System.in);

Conceptos que deben quedar claros:

 Por el momento haremos todo el algoritmo dentro de la función main. Es

decir el resto siempre será lo mismo (declarar un proyecto, declarar una
clase, definir una función main)

 Debemos definir tres variables: (horasTrabajadas, costoHora, sueldo),

aquí es donde debemos definir que tipos de datos se almacenarán en las
mismas. La cantidad de horas normalmente será un valor entero (ej. 100 -
150 - 230 etc.), pero el costo de la hora es muy común que sea un valor
real (ej. 5,35 - 7,50 etc.) y como el sueldo resulta de multiplicar las horas
trabajadas por el costo por hora el mismo deberá ser real.

La definición de las variables la hacemos en la main:

int horasTrabajadas;
float costoHora;
float sueldo;
 Utilizamos la palabra clave int para definir variables enteras (en Java las
palabras claves deben ir obligatoriamente en minúsculas, sino se produce un
error sintáctico) Luego de la palabra clave debemos indicar el nombre de la
variable, por ejemplo: horasTrabajadas (se propone que el nombre de la
variable comience con minúsculas y en caso de estar constituida por dos
palabras o más a partir de la segunda palabra el primer caracter se
especifique con mayúsculas (un nombre de variable no puede tener espacios
en blanco, empezar con un número, ni tampoco utilizar caracteres
especiales)
Debemos buscar siempre nombres de variables que nos indiquen que
almacenan (no es conveniente llamar a nombres de variables con letras
individuales)

 Para mostrar mensajes en la "Console" utilizamos la siguiente sintaxis:

System.out.print("Ingrese la cantidad de horas trabajadas por el

empleado:");

Con esta sintaxis todo lo que se encuentra contenido entre comillas

aparecerá exactamente en la ventana de la "Console".

Si disponemos una variable:

System.out.print(sueldo);

Aparecerá el contenido de la variable. Es decir el valor almacenado en la

variable sueldo y no el mensaje "sueldo".

 Para hacer la entrada de datos por teclado en Java se complica.

Utilizaremos una clase llamada Scanner que nos facilita el ingreso de
datos. Por eso tuvimos que importar la clase Scanner que se encuentra
en el paquete java.util en la primer línea de nuestro programa.
 En la función main debemos crear un objeto de la clase Scanner con la
siguiente sintaxis:
Scanner teclado=new Scanner(System.in);

Luego para cargar valores enteros por teclado debemos implementar la

siguiente sintaxis:

horasTrabajadas=teclado.nextInt();

Pero si el dato a cargar se trata de un valor float luego debemos utilizar la

siguiente sintaxis:

costoHora=teclado.nextFloat();

5 - Estructura de programación secuencial

Realizar la carga de dos números enteros por teclado e imprimir su suma

y su producto.
import java.util.Scanner;
public class SumaProductoNumeros {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int num1,num2,suma,producto;
System.out.print("Ingrese primer valor:");
num1=teclado.nextInt();
System.out.print("Ingrese segundo valor");
num2=teclado.nextInt();
suma=num1 + num2;
producto=num1 * num2;
System.out.print("La suma de los dos valores es:");
System.out.println(suma);
System.out.print("El producto de los dos valores es:");
System.out.println(producto);
}
}

6 - Estructuras condicionales simples y compuestas

Ingresar el sueldo de una persona, si supera los 3000 pesos mostrar un

mensaje en pantalla indicando que debe abonar impuestos.
import java.util.Scanner;

public class EstructuraCondicionalSimple1 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
float sueldo;
System.out.print("Ingrese el sueldo:");
sueldo=teclado.nextFloat();
if (sueldo>3000) {
System.out.println("Esta persona debe abonar impuestos");
}
}
}

Realizar un programa que solicite ingresar dos números distintos y

muestre por pantalla el mayor de ellos.

import java.util.Scanner;
public class EstructuraCondicionalCompuesta1 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int num1,num2;
System.out.print("Ingrese primer valor:");
num1=teclado.nextInt();
System.out.print("Ingrese segundo valor:");
num2=teclado.nextInt();
if (num1>num2) {
System.out.print(num1);
 } else {
System.out.print(num2);
}
}
}
Operadores

En una condición deben disponerse únicamente variables, valores

constantes y operadores relacionales.
Operadores Relacionales:
> (mayor)
< (menor)
>= (mayor o igual)
<= (menor o igual)
== (igual)
!= (distinto)
Operadores Matemáticos
+ (más)
- (menos)
* (producto)
/ (división)
% (resto de una división) Ej.: x=13%5; {se guarda 3}

Hay que tener en cuenta que al disponer una condición debemos

seleccionar que operador relacional se adapta a la pregunta.

7 - Estructuras condicionales anidadas

Confeccionar un programa que pida por teclado tres notas de un alumno,

calcule el promedio e imprima alguno de estos mensajes:
Si el promedio es >=7 mostrar "Promocionado".
Si el promedio es >=4 y <7 mostrar "Regular".
Si el promedio es <4 mostrar "Reprobado".
 import java.util.Scanner;
public class EstructuraCondicionalAnidada1 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int nota1,nota2,nota3;
System.out.print("Ingrese primer nota:");
nota1=teclado.nextInt();
System.out.print("Ingrese segunda nota:");
nota2=teclado.nextInt();
System.out.print("Ingrese tercer nota:");
nota3=teclado.nextInt();
int promedio=(nota1 + nota2 + nota3) / 3;
if (promedio>=7) {
System.out.print("Promocionado");
} else {
if (promedio>=4) {
System.out.print("Regular");
} else {
System.out.print("Reprobado");
}
}
}
}
8 - Condiciones compuestas con operadores lógicos

Hasta ahora hemos visto los operadores:

relacionales (>, <, >=, <= , ==, !=)
matemáticos (+, -, *, /, %)
pero nos están faltando otros operadores imprescindibles:
lógicos (&&, ||).
 Estos dos operadores se emplean fundamentalmente en las estructuras
condicionales para agrupar varias condiciones simples.

Operador &&

Traducido se lo lee como ?Y?. Si la Condición 1 es verdadera Y la

condición 2 es verdadera luego ejecutar la rama del verdadero.
Cuando vinculamos dos o más condiciones con el operador ?&&?, las dos
condiciones deben ser verdaderas para que el resultado de la condición
compuesta de Verdadero y continúe por la rama del verdadero de la
estructura condicional.

La utilización de operadores lógicos permiten en muchos casos plantear

algoritmos más cortos y comprensibles.

Problema:
Confeccionar un programa que lea por teclado tres números distintos y
nos muestre el mayor.
 La primera estructura condicional es una ESTRUCTURA CONDICIONAL
COMPUESTA con una CONDICION COMPUESTA.

Podemos leerla de la siguiente forma:

Si el contenido de la variable num1 es mayor al contenido de la variable

num2 Y si el contenido de la variable num1 es mayor al contenido de la
variable num3 entonces la CONDICION COMPUESTA resulta Verdadera.

Si una de las condiciones simples da falso la CONDICION

COMPUESTA da Falso y continua por la rama del falso.
 Es decir que se mostrará el contenido de num1 si y sólo si
num1>num2 y num1>num3.

En caso de ser Falsa la condición, analizamos el contenido de num2

y num3 para ver cual tiene un valor mayor.

En esta segunda estructura condicional no se requieren operadores

lógicos al haber una condición simple.

import java.util.Scanner;

public class CondicionesCompuestas1 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int num1,num2,num3;
System.out.print("Ingrese primer valor:");
num1=teclado.nextInt();
System.out.print("Ingrese segundo valor:");
num2=teclado.nextInt();
System.out.print("Ingrese tercer valor:");
num3=teclado.nextInt();
if (num1>num2 && num1>num3) {
System.out.print(num1);
} else {
if (num2>num3) {
System.out.print(num2);
}else {
System.out.print(num3);
}
}
}
}

Operador ||
 Traducido se lo lee como ?O?. Si la condición 1 es Verdadera O la
condición 2 es Verdadera, luego ejecutar la rama del Verdadero.

Cuando vinculamos dos o más condiciones con el operador ?Or", con

que una de las dos condiciones sea Verdadera alcanza para que el resultado
de la condición compuesta sea Verdadero.

Problema:
Se carga una fecha (día, mes y año) por teclado. Mostrar un mensaje si
corresponde al primer trimestre del año (enero, febrero o marzo) Cargar por
teclado el valor numérico del día, mes y año.
Ejemplo: dia:10 mes:1 año:2010
 La carga de una fecha se hace por partes, ingresamos las variables dia,
mes y año.

Mostramos el mensaje "Corresponde al primer trimestre" en caso que el

mes ingresado por teclado sea igual a 1, 2 ó 3. En la condición no participan
las variables dia y año.

import java.util.Scanner;

public class CondicionesCompuestas2 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int dia,mes,año;
System.out.print("Ingrese nro de día:");
dia=teclado.nextInt();
 System.out.print("Ingrese nro de mes:");
mes=teclado.nextInt();
System.out.print("Ingrese nro de año:");
año=teclado.nextInt();
if (mes==1 || mes==2 || mes==3) {
System.out.print("Corresponde al primer trimestre");
}
}
}

9 - Estructura repetitiva while

Hasta ahora hemos empleado estructuras SECUENCIALES y

CONDICIONALES. Existe otro tipo de estructuras tan importantes como las
anteriores que son las estructuras REPETITIVAS.

Una estructura repetitiva permite ejecutar una instrucción o un conjunto

de instrucciones varias veces.

Una ejecución repetitiva de sentencias se caracteriza por:

- La o las sentencias que se repiten.
- El test o prueba de condición antes de cada repetición, que motivará que se
repitan o no las sentencias.

Estructura repetitiva while.

Representación gráfica de la estructura while:
 No debemos confundir la representación gráfica de la estructura repetitiva
while (Mientras) con la estructura condicional if (Si).

Funcionamiento: En primer lugar se verifica la condición, si la misma resulta

verdadera se ejecutan las operaciones que indicamos por la rama del
Verdadero.

A la rama del verdadero la graficamos en la parte inferior de la condición.

Una línea al final del bloque de repetición la conecta con la parte superior de
la estructura repetitiva.

En caso que la condición sea Falsa continúa por la rama del Falso y sale
de la estructura repetitiva para continuar con la ejecución del algoritmo. El
bloque se repite MIENTRAS la condición sea Verdadera.

Importante: Si la condición siempre retorna verdadero estamos en presencia

de un ciclo repetitivo infinito. Dicha situación es un error de programación,
nunca finalizará el programa.

Problema 1:
Realizar un programa que imprima en pantalla los números del 1 al 100.
Sin conocer las estructuras repetitivas podemos resolver el problema
empleando una estructura secuencial. Inicializamos una variable con el valor
1, luego imprimimos la variable, incrementamos nuevamente la variable y así
sucesivamente.
 Si continuamos con el diagrama no nos alcanzarían las próximas 5
páginas para finalizarlo. Emplear una estructura secuencial para resolver este
problema produce un diagrama de flujo y un programa en Java muy largo.
Ahora veamos la solución empleando una estructura repetitiva while:
 Es muy importante analizar este diagrama:

La primera operación inicializa la variable x en 1, seguidamente comienza

la estructura repetitiva while y disponemos la siguiente condición ( x <= 100),
se lee MIENTRAS la variable x sea menor o igual a 100.

Al ejecutarse la condición retorna VERDADERO porque el contenido de x

(1) es menor o igual a 100. Al ser la condición verdadera se ejecuta el bloque
de instrucciones que contiene la estructura while. El bloque de instrucciones
contiene una salida y una operación.
Se imprime el contenido de x, y seguidamente se incrementa la variable x en
uno.

La operación x=x + 1 se lee como "en la variable x se guarda el contenido

de x más 1". Es decir, si x contiene 1 luego de ejecutarse esta operación se
almacenará en x un 2.
 Al finalizar el bloque de instrucciones que contiene la estructura repetitiva
se verifica nuevamente la condición de la estructura repetitiva y se repite el
proceso explicado anteriormente.

Mientras la condición retorne verdadero se ejecuta el bloque de

instrucciones; al retornar falso la verificación de la condición se sale de la
estructura repetitiva y continua el algoritmo, en este caso finaliza el programa.

Lo más difícil es la definición de la condición de la estructura while y qué

bloque de instrucciones se van a repetir. Observar que si, por ejemplo,
disponemos la condición x >=100 ( si x es mayor o igual a 100) no provoca
ningún error sintáctico pero estamos en presencia de un error lógico porque
al evaluarse por primera vez la condición retorna falso y no se ejecuta el
bloque de instrucciones que queríamos repetir 100 veces.

No existe una RECETA para definir una condición de una estructura

repetitiva, sino que se logra con una práctica continua solucionando
problemas.

Importante: Podemos observar que el bloque repetitivo puede no ejecutarse

ninguna vez si la condición retorna falso la primera vez.
La variable x debe estar inicializada con algún valor antes que se ejecute la
operación x=x + 1 en caso de no estar inicializada aparece un error de
compilación.

Como podemos observar no hemos creado un objeto de la clase

Scanner. Esto debido a que en este programa no hay que ingresar datos por
teclado. Para las salidas utilizamos la función print, que se encuentra creada
por defecto en cualquier programa que codifiquemos en Java.

Recordemos que un problema no estará 100% solucionado si no

hacemos el programa en Java que muestre los resultados buscados.
 Probemos algunas modificaciones de este programa y veamos que
cambios se deberían hacer para:

1 - Imprimir los números del 1 al 500.

2 - Imprimir los números del 50 al 100.
3 - Imprimir los números del -50 al 0.
4 - Imprimir los números del 2 al 100 pero de 2 en 2 (2,4,6,8 ....100).

Respuestas:
1 - Debemos cambiar la condición del while con x<=500.
2 - Debemos inicializar x con el valor 50.
3 - Inicializar x con el valor -50 y fijar la condición x<=0.
4 - Inicializar a x con el valor 2 y dentro del bloque repetitivo incrementar a x
en 2 ( x = x + 2 ).

Problema 2:
Escribir un programa que solicite la carga de un valor positivo y nos
muestre desde 1 hasta el valor ingresado de uno en uno.
Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los números del 1 al
30.
Es de FUNDAMENTAL importancia analizar los diagramas de flujo y la
posterior codificación en Java de los siguientes problemas, en varios
problemas se presentan otras situaciones no vistas en el ejercicio anterior.
 Podemos observar que se ingresa por teclado la variable n. El operador
puede cargar cualquier valor.

Si el operador carga 10 el bloque repetitivo se ejecutará 10 veces, ya que

la condición es ?Mientras x<=n ?, es decir ?mientras x sea menor o igual a
10?; pues x comienza en uno y se incrementa en uno cada vez que se
ejecuta el bloque repetitivo.

import java.util.Scanner;

public class EstructuraRepetitivaWhile2 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int n,x;
System.out.print("Ingrese el valor final:");
n=teclado.nextInt();
x=1;
while (x<=n) {
System.out.print(x);
 System.out.print(" - ");
x = x + 1;
}
}
}

Los nombres de las variables n y x pueden ser palabras o letras (como en

este caso)

La variable x recibe el nombre de CONTADOR. Un contador es un tipo

especial de variable que se incrementa o decrementa con valores constantes
durante la ejecución del programa.

El contador x nos indica en cada momento la cantidad de valores

impresos en pantalla.

Problema 3:
Desarrollar un programa que permita la carga de 10 valores por teclado y nos
muestre posteriormente la suma de los valores ingresados y su promedio.
 En este problema, a semejanza de los anteriores, llevamos un
CONTADOR llamado x que nos sirve para contar las vueltas que debe repetir
el while.
 También aparece el concepto de ACUMULADOR (un acumulador es un
tipo especial de variable que se incrementa o decrementa con valores
variables durante la ejecución del programa).

Hemos dado el nombre de suma a nuestro acumulador. Cada ciclo que

se repita la estructura repetitiva, la variable suma se incrementa con el
contenido ingresado en la variable valor.

Este es un seguimiento del diagrama planteado. Los números que toma

la variable valor dependerá de qué cifras cargue el operador durante la
ejecución del programa.

El promedio se calcula al salir de la estructura repetitiva (es decir primero

sumamos los 10 valores ingresados y luego los dividimos por 10)
import java.util.Scanner;

public class Ejercicio_3 {

public static void main(String[] arg) {

Scanner teclado=new Scanner(System.in);

int x=1,valor;
float suma=0,promedio;

while(x<=10) {
System.out.print("Ingrese valor "+x+": ");
valor=teclado.nextInt();
suma=suma+valor;
x++;
}
promedio=suma/10;
System.out.println("La suma de los 10 valores es: "+suma);
System.out.println("El promedio es: "+promedio);
}
}

Problema 4:
Una planta que fabrica perfiles de hierro posee un lote de n piezas.
Confeccionar un programa que pida ingresar por teclado la cantidad de
piezas a procesar y luego ingrese la longitud de cada perfil; sabiendo que la
pieza cuya longitud esté comprendida en el rango de 1,20 y 1,30 son aptas.
Imprimir por pantalla la cantidad de piezas aptas que hay en el lote.
 Podemos observar que dentro de una estructura repetitiva puede haber
estructuras condicionales (inclusive puede haber otras estructuras repetitivas
que veremos más adelante)

En este problema hay que cargar inicialmente la cantidad de piezas a

ingresar ( n ), seguidamente se cargan n valores de largos de piezas.

Cada vez que ingresamos un largo de pieza (largo) verificamos si es una

medida correcta (debe estar entre 1.20 y 1.30 el largo para que sea correcta),
en caso de ser correcta la CONTAMOS (incrementamos la variable cantidad
en 1)

Al contador cantidad lo inicializamos en cero porque inicialmente no se ha

cargado ningún largo de medida.

Cuando salimos de la estructura repetitiva porque se han cargado n

largos de piezas mostramos por pantalla el contador cantidad (que
representa la cantidad de piezas aptas)
En este problema tenemos dos CONTADORES:

x : (Cuenta la cantidad de piezas cargadas hasta el momento)

Cantidad : (Cuenta los perfiles de hierro aptos)

import java.util.Scanner;

public class Ejercicio_4 {

public static void main(String[] arg) {

Scanner teclado=new Scanner(System.in);

int x=1,n,cantidad=0;
float largo;
System.out.print("Cuantas piezas procesara: ");
n=teclado.nextInt();

while(x<=n) {
System.out.print("Ingrese la medida de la pieza: ");
largo=teclado.nextFloat();
if(largo>=1.20 && largo<=1.30) {
cantidad++;
 }
x++;
}
System.out.println("La cantidad de piezas aptas son:
"+cantidad);
}
}

10 - Estructura repetitiva for

Cualquier problema que requiera una estructura repetitiva se puede

resolver empleando la estructura while. Pero hay otra estructura repetitiva
cuyo planteo es más sencillo en ciertas situaciones.

En general, la estructura for se usa en aquellas situaciones en las cuales

CONOCEMOS la cantidad de veces que queremos que se ejecute el bloque
de instrucciones. Ejemplo: cargar 10 números, ingresar 5 notas de alumnos,
etc. Conocemos de antemano la cantidad de veces que queremos que el
bloque se repita. Veremos, sin embargo, que en el lenguaje Java la
estructura for puede usarse en cualquier situación repetitiva, porque en última
instancia no es otra cosa que una estructura while generalizada.

Representación gráfica:

En su forma más típica y básica, esta estructura requiere una variable

entera que cumple la función de un CONTADOR de vueltas. En la sección
indicada como "inicialización contador", se suele colocar el nombre de la
variable que hará de contador, asignándole a dicha variable un valor inicial.
En la sección de "condición" se coloca la condición que deberá ser verdadera
para que el ciclo continúe (en caso de un falso, el ciclo se detendrá). Y
finalmente, en la sección de "incremento contador" se coloca una instrucción
que permite modificar el valor de la variable que hace de contador (para
permitir que alguna vez la condición sea falsa)

Cuando el ciclo comienza, antes de dar la primera vuelta, la variable del

for toma el valor indicado en la sección de de "inicialización contador".
Inmediatamente se verifica, en forma automática, si la condición es
verdadera. En caso de serlo se ejecuta el bloque de operaciones del ciclo, y
al finalizar el mismo se ejecuta la instrucción que se haya colocado en la
tercer sección.

Seguidamente, se vuelve a controlar el valor de la condición, y así

prosigue hasta que dicha condición entregue un falso.

Si conocemos la cantidad de veces que se repite el bloque es muy

sencillo emplear un for, por ejemplo si queremo que se repita 50 veces el
bloque de instrucciones puede hacerse así:

La variable del for puede tener cualquier nombre. En este ejemplo se la

ha definido con el nombre f.

Analicemos el ejemplo:
- La variable f toma inicialmente el valor 1.
- Se controla automáticamente el valor de la condición: como f vale 1 y esto
es menor
que 50, la condición da verdadero.
- Como la condición fue verdadera, se ejecutan la/s operación/es.
- Al finalizar de ejecutarlas, se retorna a la instrucción f++, por lo que la
variable f se incrementa en uno.
- Se vuelve a controlar (automáticamente) si f es menor o igual a 50.
Como ahora su valor es 2, se ejecuta nuevamente el bloque de instrucciones
e incrementa nuevamente la variable del for al terminar el mismo.
- El proceso se repetirá hasta que la variable f sea incrementada al valor 51.
En este momento la condición será falsa, y el ciclo se detendrá.

La variable f PUEDE ser modificada dentro del bloque de operaciones del

for, aunque esto podría causar problemas de lógica si el programador es
inexperto.

La variable f puede ser inicializada en cualquier valor y finalizar en

cualquier valor. Además, no es obligatorio que la instrucción de modificación
sea un incremento del tipo contador (f++).

Cualquier instrucción que modifique el valor de la variable es válida. Si

por ejemplo se escribe f=f+2 en lugar de f++, el valor de f será incrementado
de a 2 en cada vuelta, y no de a 1. En este caso, esto significará que el ciclo
no efectuará las 50 vueltas sino sólo 25.

Problema 1:
Realizar un programa que imprima en pantalla los números del 1 al 100.
 Podemos observar y comparar con el problema realizado con el while.
Con la estructura while el CONTADOR x sirve para contar las vueltas. Con el
for el CONTADOR f cumple dicha función.

Inicialmente f vale 1 y como no es superior a 100 se ejecuta el bloque,

imprimimos el contenido de f, al finalizar el bloque repetitivo se incrementa la
variable f en 1, como 2 no es superior a 100 se repite el bloque de
instrucciones.

Cuando la variable del for llega a 101 sale de la estructura repetitiva y

continúa la ejecución del algoritmo que se indica después del círculo.
La variable f (o como sea que se decida llamarla) debe estar definida como
una variable más.

public class Ejercicio_5 {

public static void main(String[] arg) {
for(int i=1;i<=100;i++) {
System.out.print(i+" - ");
}
}
}
Problema 2:
Desarrollar un programa que permita la carga de 10 valores por teclado y
nos muestre posteriormente la suma de los valores ingresados y su
promedio. Este problema ya lo desarrollamos , lo resolveremos empleando la
estructura for.

En este caso, a la variable del for (f) sólo se la requiere para que se repita
el bloque de instrucciones 10 veces.

import java.util.Scanner;

public class Ejercicio_6 {

public static void main(String[] arg) {
 Scanner teclado=new Scanner(System.in);
double valor,suma=0,promedio;
for(int i=1;i<=10;i++) {
System.out.print("Ingrese valor "+i+" : ");
valor=teclado.nextDouble();
suma=suma+valor;
}
promedio=suma/10;
System.out.println("La suma es: "+suma);
System.out.println("El promedio es: "+promedio);
}
}

El problema requiere que se carguen 10 valores y se sumen los mismos.

Tener en cuenta encerrar entre llaves bloque de instrucciones a repetir dentro
del for.

El promedio se calcula fuera del for luego de haber cargado los 10

valores.

Problema 3:
Escribir un programa que lea 10 notas de alumnos y nos informe cuántos
tienen notas mayores o iguales a 7 y cuántos menores.

Para resolver este problema se requieren tres contadores:

 aprobados (Cuenta la cantidad de alumnos aprobados)
 reprobados (Cuenta la cantidad de reprobados)
 i (es el contador del for)

Dentro de la estructura repetitiva debemos hacer la carga de la variable

nota y verificar con una estructura condicional si el contenido de la variable
nota es mayor o igual a 7 para incrementar el contador aprobados, en caso
de que la condición retorne falso debemos incrementar la variable
reprobados.
 Los contadores aprobados y reprobados deben imprimirse FUERA de la
estructura repetitiva.

Es fundamental inicializar los contadores aprobados y reprobados en cero

antes de entrar a la estructura for.

Importante: Un error común es inicializar los contadores dentro de la

estructura repetitiva. En caso de hacer esto los contadores se fijan en cero en
cada ciclo del for, por lo que al finalizar el for como máximo el contador puede
tener el valor 1.
import java.util.Scanner;

public class Ejercicio_7 {

public static void main(String[] arg) {

Scanner teclado=new Scanner(System.in);

int aprobados=0,reprobados=0;
double nota;

for(int i=1;i<=10;i++) {
System.out.print("Ingrese nota "+i+": ");
nota=teclado.nextDouble();
if(nota>=7) {
aprobados++;
}else {
reprobados++;
}
}
System.out.println("La cantidad de Aprobados es: "+aprobados);
System.out.println("La cantidad de Reprobados es:
"+reprobados);
}
}

Problema 4:
Escribir un programa que lea 10 números enteros y luego muestre
cuántos valores ingresados fueron múltiplos de 3 y cuántos de 5. Debemos
tener en cuenta que hay números que son múltiplos de 3 y de 5 a la vez.
 Tengamos en cuenta que el operador matemático % retorna el resto de
dividir un valor por otro, en este caso: valor%3 retorna el resto de dividir el
valor que ingresamos por teclado, por tres.
 Veamos: si ingresamos 6 el resto de dividirlo por 3 es 0, si ingresamos 12
el resto de dividirlo por 3 es 0. Generalizando: cuando el resto de dividir por 3
al valor que ingresamos por teclado es cero, se trata de un múltiplo de dicho
valor.

Ahora bien ¿por qué no hemos dispuesto una estructura if anidada?

Porque hay valores que son múltiplos de 3 y de 5 a la vez. Por lo tanto

con if anidados no podríamos analizar los dos casos.Es importante darse
cuenta cuando conviene emplear if anidados y cuando no debe emplearse.

import java.util.Scanner;
public class Ejercicio_8 {
public static void main(String[] arg) {

Scanner teclado=new Scanner(System.in);

int mul3=0,mul5=0,valor;
for(int i=1;i<=10;i++) {
System.out.print("Ingrese un valor: ");
valor=teclado.nextInt();
if(valor%3==0) {
mul3++;
}
if (valor%5==0) {
mul5++;
}
}
System.out.println("Cantidad de valores ingresados multiples de
3: "+mul3);
System.out.println("Cantidad de valores ingresados multiples de
5: "+mul5);
}
}

Problema 5:
Escribir un programa que lea n números enteros y calcule la cantidad de
valores mayores o iguales a 1000.

Este tipo de problemas también se puede resolver empleando la

estructura repetitiva for. Lo primero que se hace es cargar una variable que
indique la cantidad de valores a ingresar. Dicha variable se carga antes de
entrar a la estructura repetitiva for.
La estructura for permite que el valor inicial o final dependa de una variable
cargada previamente por teclado.

Tenemos un contador llamado cantidad y f que es el contador del for. La

variable entera n se carga previo al inicio del for, por lo que podemos fijar el
valor final del for con la variable n.

Por ejemplo si el operador carga 5 en n la estructura repetitiva for se

ejecutará 5 veces.
 La variable valor se ingresa dentro de la estructura repetitiva, y se
verifica si el valor de la misma es mayor o igual a 1000, en dicho caso se
incrementa en uno el contador cantidad.

Fuera de la estructura repetitiva imprimimos el contador cantidad que

tiene almacenado la cantidad de valores ingresados mayores o iguales a
1000.
import java.util.Scanner;
public class Ejercicio_9 {
public static void main(String[] arg) {

Scanner teclado=new Scanner(System.in);

int cantidad=0,n,valor;
System.out.print("Cuantos numeros ingresara: ");
n=teclado.nextInt();
for(int i=1;i<=n;i++) {
System.out.print("Ingrese el valor: ");
valor=teclado.nextInt();
if(valor>=1000) {
cantidad++;
}
}
System.out.print("La cantidad de valores ingresados mayores o
iguales a 1000 es: "+cantidad);
}
}

11 - Estructura repetitiva do while

La estructura do while es otra estructura repetitiva, la cual ejecuta al

menos una vez su bloque repetitivo, a diferencia del while o del for que
podían no ejecutar el bloque.

Esta estructura repetitiva se utiliza cuando conocemos de antemano que

por lo menos una vez se ejecutará el bloque repetitivo. La condición de la
estructura está abajo del bloque a repetir, a diferencia del while o del for que
está en la parte superior.

Representación gráfica:
 El bloque de operaciones se repite MIENTRAS que la condición sea
Verdadera.

Si la condición retorna Falso el ciclo se detiene. En Java, todos los ciclos

repiten por verdadero y cortan por falso. Es importante analizar y ver que las
operaciones se ejecutan como mínimo una vez.

Problema 1:
Escribir un programa que solicite la carga de un número entre 0 y 999, y
nos muestre un mensaje de cuántos dígitos tiene el mismo. Finalizar el
programa cuando se cargue el valor 0.
 No hay que confundir los rombos de las estructuras condicionales con los
de las estructuras repetitivas do while.

En este problema por lo menos se carga un valor. Si se carga un valor

mayor o igual a 100 se trata de un número de tres cifras, si es mayor o igual a
10 se trata de un valor de dos dígitos, en caso contrario se trata de un valor
de un dígito. Este bloque se repite hasta que se ingresa en la variable valor el
número 0 con lo que la condición de la estructura do while retorna falso y sale
del bloque repetitivo finalizando el programa.
import java.util.Scanner;

public class Ejercicio_10 {

public static void main(String[] arg) {

Scanner teclado=new Scanner(System.in);

int valor;
do {
System.out.print("Ingrese un valor entre 0 y 999 (0
finaliza): ");
valor=teclado.nextInt();
if(valor>=100) {
System.out.println("Tiene 3 Digitos");
}else {
if(valor>=10) {
System.out.println("Tiene 2 Digitos");
}
else {
System.out.println("Tiene 1 Digito");
}
}
}while(valor!=0);
}
}

Problema 2:

Escribir un programa que solicite la carga de números por teclado,

obtener su promedio. Finalizar la carga de valores cuando se cargue el valor
0.
 Cuando la finalización depende de algún valor ingresado por el operador
conviene el empleo de la estructura do while, por lo menos se cargará un
valor (en el caso más extremo se carga 0, que indica la finalización de la
carga de valores)
 Es importante analizar este diagrama de flujo.

Definimos un contador cant que cuenta la cantidad de valores ingresados

por el operador (no lo incrementa si ingresamos 0)

El valor 0 no es parte de la serie de valores que se deben sumar.

Definimos el acumulador suma que almacena todos los valores ingresados
por teclado.

La estructura repetitiva do while se repite hasta que ingresamos el valor

0. Con dicho valor la condición del ciclo retorna falso y continúa con el flujo
del diagrama.

Disponemos por último una estructura condicional para el caso que el

operador cargue únicamente un 0 y por lo tanto no podemos calcular el
promedio ya que no existe la división por 0.

En caso que el contador cant tenga un valor distinto a 0 el promedio se

obtiene dividiendo el acumulador suma por el contador cant que tiene la
cantidad de valores ingresados antes de introducir el 0

import java.util.Scanner;
public class Ejercicio_11 {
public static void main(String[] arg) {
Scanner teclado=new Scanner(System.in);
int valor,suma=0,cant=0,promedio;

do {
System.out.print("Ingrese un valor (0 para finalizar): ");
valor=teclado.nextInt();
if(valor!=0) {
suma=suma+valor;
cant++;
}
}while(valor!=0);
if(cant!=0) {
promedio=suma/cant;
System.out.print("El promedio de los valores ingresados es:
"+promedio);
}else {
System.out.print("No se ingresaron valores");
}
 }
}

El contador cant DEBE inicializarse antes del ciclo, lo mismo que el

acumulador suma. El promedio se calcula siempre y cuando el contador cant
sea distinto a 0.

Problema 3:
Realizar un programa que permita ingresar el peso (en kilogramos) de piezas.
El proceso termina cuando ingresamos el valor 0. Se debe informar:
a) Cuántas piezas tienen un peso entre 9.8 Kg. y 10.2 Kg.?, cuántas con más
de 10.2 Kg.? y cuántas con menos de 9.8 Kg.?
b) La cantidad total de piezas procesadas.

import java.util.Scanner;
public class Ejercicio_12 {
public static void main(String[] arg) {

Scanner teclado=new Scanner(System.in);

float peso;
int cant1=0,cant2=0,cant3=0,suma;
do {
System.out.print("Ingrese el peso de la pieza (0 para
finalizar): ");
peso=teclado.nextFloat();
if(peso<=10.2) {
if(peso>=9.8) {
cant1++;
}else {
if(peso>0) {
cant2++;
}
}
}else {
cant3++;
}
}while(peso!=0);
suma=cant1+cant2+cant3;
System.out.println("Cantidad de piezas con peso mayor a 10.2:
"+cant3);
System.out.println("Cantidad de piezas con peso menor a 9.8:
"+cant2);
System.out.println("Cantidad de piezas aptas: "+cant1);
System.out.println("La Cantidad de piezas procesadas: "+suma);
}
}

12 - Cadenas de caracteres en Java

En Java hemos visto que cuando queremos almacenar un valor entero

definimos una variable de tipo int, si queremos almacenar un valor con
decimales definimos una variable de tipo float. Ahora si queremos almacenar
una cadena de caracteres (por ejemplo un nombre de una persona) debemos
definir un objeto de la clase String.

Más adelante veremos en profundidad y detenimiento los conceptos de

CLASE y OBJETO, por ahora solo nos interesa la mecánica para trabajar con
cadenas de caracteres.

Problema 1:
Solicitar el ingreso del nombre y edad de dos personas. Mostrar el
nombre de la persona con mayor edad.
import java.util.Scanner;

public class Ejercicio_1 {

public static void main(String[] arg) {

Scanner teclado=new Scanner(System.in);

String nombre1,nombre2;
int edad1,edad2;
System.out.print("Ingrese el nombre 1: ");
nombre1=teclado.next();
System.out.print("Ingrese la edad 1: ");
edad1=teclado.nextInt();
System.out.print("Ingrese el nombre 2: ");
nombre2=teclado.next();
System.out.print("Ingrese la edad 2: ");
edad2=teclado.nextInt();
System.out.print("La persona de mayor edad es: ");
if(edad1>edad2) {
System.out.print(nombre1);
}else {
System.out.print(nombre2);
}
}
}
 Para almacenar un nombre debemos definir una variable de tipo String y
su ingreso por teclado se hace llamando al método next() del objeto teclado:

nombre1=teclado.next();

La primera salvedad que tenemos que hacer cuando utilizamos el método

next() es que solo nos permite ingresar una cadena de caracteres con la
excepción del espacio en blanco (es decir debemos ingresar un nombre de
persona y no su nombre y apellido separado por un espacio en blanco)

Veamos que existe otro método llamado nextLine() que nos permite
cargar espacios en blanco pero para su uso se complica cuando cargamos
otras valores de tipo distinto a String (por ejemplo int, float etc.)

Problema 2:
Solicitar el ingreso del apellido, nombre y edad de dos personas. Mostrar
el nombre de la persona con mayor edad. Realizar la carga del apellido y
nombre en una variable de tipo String.

import java.util.Scanner;
public class Ejercicio_2 {
public static void main(String[] arg) {
Scanner teclado=new Scanner(System.in);
String persona1,persona2;
int edad1,edad2;
System.out.print("Ingrese el Apellido y Nombre 1: ");
persona1=teclado.nextLine();
System.out.print("Ingrese la edad: ");
edad1=teclado.nextInt();
System.out.print("Ingrese el Apellido y Nombre 1: ");
teclado.nextLine();
persona2=teclado.nextLine();
System.out.print("Ingrese la edad: ");
edad2=teclado.nextInt();
System.out.print("La persona de mayor edad es: ");
if(edad1>edad2) {
System.out.print(persona1);
}else {
System.out.print(persona2);
}
}
}
 Cuando se ingresa una cadena con caracteres en blanco debemos tener
en cuenta en llamar al método nextLine()

Una dificultad se presenta si llamamos al método nextLine() y

previamente hemos llamado al método nextInt(), esto debido a que luego de
ejecutar el método nextInt() queda almacenado en el objeto de la clase
Scanner el caracter "Enter" y si llamamos inmediatamente al método
nextLine() este almacena dicho valor de tecla y continúa con el flujo del
programa. Para solucionar este problema debemos generar un código similar
a:
System.out.print("Ingrese edad:");
edad1=teclado.nextInt();
System.out.print("Ingrese el apellido y el nombre:");
teclado.nextLine();
apenom2=teclado.nextLine();

Como vemos llamamos al método nextLine() dos veces, la primera

retorna la tecla "Enter" y la segunda se queda esperando que ingresemos el
apellido y nombre (tener en cuenta que esto es necesario solo si previamente
se llamó al método nextInt() o nextFloat().

Problema 3:
Solicitar el ingreso de dos apellidos. Mostrar un mensaje si son iguales o
distintos.

import java.util.Scanner;
public class Ejercicio_3 {
public static void main(String[] arg) {
Scanner teclado=new Scanner(System.in);
String apellido1, apellido2;
System.out.print("Ingrese primer apellido: ");
apellido1=teclado.next();
System.out.print("Ingrese segundo apellido: ");
apellido2=teclado.next();
if(apellido1.equals(apellido2)) {
System.out.print("Los Apellidos son Iguales");
}else {
 System.out.print("Los Apellidos son Distintos");
}
}
}

Para comparar si el contenido de dos String son iguales no podemos

utilizar el operador ==. Debemos utilizar un método de la clase String llamado
equals y pasar como parámetro el String con el que queremos compararlo:

if (apellido1.equals(apellido2)) {
}

El método equals retorna verdadero si los contenidos de los dos String

son exactamente iguales, esto hace que se ejecute el bloque del verdadero.

Recordemos que hemos utilizado el método next() para la carga de los

String, luego esto hace que no podamos ingresar un apellido con espacios en
blanco (podemos probar que si ingresamos por ejemplo "Rodriguez
Rodriguez" en el primer apellido, luego se carga la cadena "Rodriguez" en la
variable apellido1 y "Rodriguez" en la variable apellido2 (con esto hacemos
notar que cada vez que ingresamos un espacio en blanco cuando utilizamos
el método next() los caracteres que siguen al espacio en blanco son
recuperados en la siguiente llamada al método next())

El método equals retorna verdadero si los contenidos de los dos String

son exactamente iguales, es decir si cargamos "Martinez" en apellido1 y
"martinez" en apellido2 luego el método equals retorna falso ya que no es lo
mismo la "M" mayúscula y la "m" minúscula.

En el caso que necesitemos considerar igual caracteres mayúsculas y

minúsculas podemos utilizar el método equalsIgnoreCase:

if (apellido1.equalsIgnoreCase(apellido2)) {
System.out.print("Los apellidos son iguales sin tener en cuenta
mayúsculas y minúsculas");
 } else {
System.out.print("Los apellidos son distintos sin tener en cuenta
mayúsculas y minúsculas");
}

13 - Declaración de una clase y definición de objetos.

La programación orientada a objetos se basa en la programación de

clases; a diferencia de la programación estructurada, que está centrada en
las funciones.

Una clase es un molde del que luego se pueden crear múltiples objetos,
con similares características.

Una clase es una plantilla (molde), que define atributos (variables) y

métodos (funciones)

La clase define los atributos y métodos comunes a los objetos de ese

tipo, pero luego, cada objeto tendrá sus propios valores y compartirán las
mismas funciones.

Debemos crear una clase antes de poder crear objetos (instancias) de

esa clase. Al crear un objeto de una clase, se dice que se crea una instancia
de la clase o un objeto propiamente dicho.

La estructura de una clase es:

class [nombre de la clase] {

[atributos o variables de la clase]
[métodos o funciones de la clase]
[main]
}
Problema 1:
Confeccionar una clase que permita cargar el nombre y la edad de una
persona. Mostrar los datos cargados. Imprimir un mensaje si es mayor de
edad (edad>=18)

import java.util.Scanner;
public class Persona {
private Scanner teclado;
private String nombre;
private int edad;

public void inicializar() {

teclado=new Scanner(System.in);
System.out.print("Ingrese nombre: ");
nombre=teclado.next();
System.out.print("Ingrese edad: ");
edad=teclado.nextInt();
}
public void imprimir() {
System.out.println("Nombre: "+nombre);
System.out.println("Edad: "+edad);
}
public void esMayorEdad() {
if(edad>=18) {
System.out.print(nombre+ " es mayor de edad");
}else {
System.out.print(nombre+" NO es mayor de edad");
}
}
public static void main(String[] arg) {
Persona persona1=new Persona();
persona1.inicializar();
persona1.imprimir();
persona1.esMayorEdad();
}
}

El nombre de la clase debe hacer referencia al concepto (en este caso la

hemos llamado Persona):

public class Persona {

Los atributos los definimos dentro de la clase pero fuera de la main:

 private Scanner teclado;
private String nombre;
private int edad;

Veremos más adelante que un atributo es normalmente definido con la

cláusula private (con esto no permitimos el acceso al atributo desde otras
clases)

A los atributos se tiene acceso desde cualquier función o método de la

clase (salvo la main).

Luego de definir los atributos de la clase debemos declarar los métodos o

funciones de la clase. La sintaxis es parecida a la main (sin la cláusula
static):

public void inicializar() {

teclado=new Scanner(System.in);
System.out.print("Ingrese nombre:");
nombre=teclado.next();
System.out.print("Ingrese edad:");
edad=teclado.nextInt();
}

En el método inicializar (que será el primero que deberemos llamar desde

la main) creamos el objeto de la clase Scanner y cargamos por teclado los
atributos nombre y edad. Como podemos ver el método inicializar puede
hacer acceso a los tres atributos de la clase Persona.

El segundo método tiene por objetivo imprimir el contenido de los

atributos nombre y edad (los datos de los atributos se cargaron al ejecutarse
previamente el método inicializar:

public void imprimir() {

System.out.println("Nombre:"+nombre);
System.out.println("Edad:"+edad);
}
 El tercer método tiene por objetivo mostrar un mensaje si la persona es
mayor o no de edad:

public void esMayorEdad() {

if (edad>=18) {
System.out.print(nombre+" es mayor de edad.");
} else {
System.out.print(nombre+" no es mayor de edad.");
}
}
Por último en la main declaramos un objeto de la clase Persona y
llamamos a los métodos en un orden adecuado:

public static void main(String[] ar) {

Persona persona1;
persona1=new Persona();
persona1.inicializar();
persona1.imprimir();
persona1.esMayorEdad();
}

Persona persona1; //Declaración del objeto

persona1=new Persona(); //Creación del objeto
persona1.inicializar(); //Llamada de un método

Problema 2:
Desarrollar un programa que cargue los lados de un triángulo e
implemente los siguientes métodos: inicializar los atributos, imprimir el valor
del lado mayor y otro método que muestre si es equilátero o no.
import java.util.Scanner;
public class Triangulo {
private Scanner teclado;
private int lado1,lado2,lado3;
public void inicializar() {
teclado=new Scanner(System.in);
System.out.print("Lado 1: ");
lado1=teclado.nextInt();
System.out.print("Lado 2: ");
lado2=teclado.nextInt();
System.out.print("Lado 3: ");
lado3=teclado.nextInt();
}
 public void ladoMayor() {
System.out.print("Lado Mayor: ");
if(lado1>lado2 && lado1>lado3) {
System.out.println(lado1);
}else {
if(lado2>lado1 && lado2>lado3) {
System.out.println(lado2);
}else {
System.out.println(lado3);
}
}
}
public void esEquilatero() {
if(lado1==lado2 && lado1==lado3) {
System.out.print("Es un Triangulo Equilatero");
}else {
System.out.print("NO es un Triangulo Equilatero");
}
}

public static void main(String[] arg) {

Triangulo triangulo1=new Triangulo();

triangulo1.inicializar();
triangulo1.ladoMayor();
triangulo1.esEquilatero();
}
}

Todos los problemas que requieran la entrada de datos por teclado

debemos definir un atributo de la clase Scanner:

private Scanner teclado;

Este problema requiere definir tres atributos de tipo entero donde

almacenamos los valores de los lados del triángulo:
private int lado1,lado2,lado3;

El primer método que deberá llamarse desde la main es el inicializar

donde creamos el objeto de la clase Scanner y cargamos los tres atributos
por teclado:
 public void inicializar() {
teclado=new Scanner(System.in);
System.out.print("Medida lado 1:");
lado1=teclado.nextInt();
System.out.print("Medida lado 2:");
lado2=teclado.nextInt();
System.out.print("Medida lado 3:");
lado3=teclado.nextInt();
}

El método ladoMayor muestra el valor mayor de los tres enteros

ingresados:

public void ladoMayor() {

System.out.print("Lado mayor:");
if (lado1>lado2 && lado1>lado3) {
System.out.println(lado1);
} else {
if (lado2>lado3) {
System.out.println(lado2);
} else {
System.out.println(lado3);
}
}
}

Como podemos observar cuando un problema se vuelve más complejo

es más fácil y ordenado separar los distintos algoritmos en varios métodos y
no codificar todo en la main.

El último método de esta clase verifica si los tres enteros ingresados son
iguales:

public void esEquilatero() {

if (lado1==lado2 && lado1==lado3) {
System.out.print("Es un triángulo equilátero");
} else {
System.out.print("No es un triángulo equilátero");
}
}
En la main creamos un objeto de la clase Triangulo y llamamos los
métodos respectivos:
 public static void main(String []ar) {
Triangulo triangulo1=new Triangulo();
triangulo1.inicializar();
triangulo1.ladoMayor();
triangulo1.esEquilatero();
}

Problema 3:
Desarrollar una clase que represente un punto en el plano y tenga los
siguientes métodos: cargar los valores de x e y, imprimir en que cuadrante se
encuentra dicho punto (concepto matemático, primer cuadrante si x e y son
positivas, si x<0 e y>0 segundo cuadrante, etc.)

import java.util.Scanner;
public class Punto {
private Scanner teclado;
private int x,y;

public void inicializar() {

teclado=new Scanner(System.in);
System.out.print("Ingrese la coordenada x: ");
x=teclado.nextInt();
System.out.print("Ingrese la coordenada y: ");
y=teclado.nextInt();
}
public void imprimirCuadrante() {
if(x>0) {
if(y>0) {
System.out.println("I Cuadrante");
}else {
System.out.print("IV Cuadrante");
}
}else {
if(y>0) {
System.out.println("II Cuadrante");
}else {
System.out.print("III Cuadrante");
}
}
}
public static void main(String[] arg) {
Punto punto1=new Punto();
punto1.inicializar();
punto1.imprimirCuadrante();
}
}
Problema 4:
Desarrollar una clase que represente un Cuadrado y tenga los siguientes
métodos: cargar el valor de su lado, imprimir su perímetro y su area.

import java.util.Scanner;
public class Cuadrado {
private Scanner teclado;
private int lado;
public void inicializar() {
teclado=new Scanner(System.in);
System.out.print("Ingrese el lado del cuadrado: ");
lado=teclado.nextInt();
}
public void imprimirArea() {
int area;
area=lado*lado;
System.out.println("El area del cuadrado es: "+area);
}
public void imprimirPerimetro() {
int perimetro;
perimetro=lado*4;
System.out.println("El perimetro del cuadrado es: "+perimetro);
}
public static void main(String[] arg) {
Cuadrado cuadrado1=new Cuadrado();
cuadrado1.inicializar();
cuadrado1.imprimirArea();
cuadrado1.imprimirPerimetro();
}
}

En este problema es interesante ver como no definimos dos atributos

donde se almacenan el area y el perímetro del cuadrado, esto debido a que
solo estos datos se los requiere en el método donde se imprimen:

public void imprimirPerimetro() {

int perimetro;
perimetro=lado*4;
System.out.println("El perimetro del cuadrado es: "+perimetro);
}

Esto significa que la variable perimetro es una variable local al método

imprimirPerimetro. Esta variable es local a dicho método y solo se la puede
acceder dentro del método. La diferencia fundamental entre una variable local
y un atributo de la clase es que al atributo se lo puede acceder desde
cualquier método de la clase y la variable local solo existe mientras se está
ejecutando el método.

14 - Declaración de métodos.

Cuando uno plantea una clase en lugar de especificar todo el algoritmo

en un único método (lo que hicimos en los primeros pasos de este tutorial) es
dividir todas las responsabilidades de las clase en un conjunto de métodos.

Un método hemos visto que tiene la siguiente sintaxis:

public void [nombre del método]() {

[algoritmo]
}

Veremos que hay varios tipos de métodos:

Métodos con parámetros.

Un método puede tener parámetros:

public void [nombre del método]([parámetros]) {

[algoritmo]
}

Los parámetros los podemos imaginar como variables locales al método,

pero su valor se inicializa con datos que llegan cuando lo llamamos.

Problema 1:
Confeccionar una clase que permita ingresar valores enteros por teclado
y nos muestre la tabla de multiplicar de dicho valor. Finalizar el programa al
ingresar el -1.
import java.util.Scanner;
public class TablaMultiplicar {
public void cargarValor() {
Scanner teclado=new Scanner(System.in);
int numero;
do {
System.out.print("Ingre el numero: ");
numero=teclado.nextInt();
if(numero!=-1)
calcular(numero);
}while(numero!=-1);

}
public void calcular(int n) {
int resultado;
for(int i=1;i<=10;i++) {
resultado=n*i;
System.out.println(n+"*"+i+"="+resultado);
}
}
public static void main(String[] arg) {
TablaMultiplicar tabla=new TablaMultiplicar();
tabla.cargarValor();
}
}

En esta clase no hemos definido ningún atributo, ya que el objeto de la

clase Scanner lo requerimos en un solo método, por ello lo definimos como
una variable local.

El método calcular recibe un parámetro de tipo entero, luego lo utilizamos

dentro del método para mostrar la tabla de multiplicar de dicho valor.

public void calcular(int n) {

int resultado;
for(int i=1;i<=10;i++) {
resultado=n*i;
System.out.println(n+"*"+i+"="+resultado);
}
}

Un método puede no tener parámetros como hemos visto en problemas

anteriores o puede tener uno o más parámetros (en caso de tener más de un
parámetro los mismos se separan por coma)
 El método cargarValor no tiene parámetros y tiene por objetivo cargar un
valor entero por teclado y llamar al método calcular para que muestre la tabla
de multiplicar del valor que le pasamos por teclado:

public void cargarValor() {

Scanner teclado=new Scanner(System.in);
int numero;
do {
System.out.print("Ingre el numero: ");
numero=teclado.nextInt();
if(numero!=-1)
calcular(numero);
}while(numero!=-1);

Como vemos al método calcular lo llamamos por su nombre y entre

paréntesis le pasamos el dato a enviar (debe ser un valor o variable entera)

En este problema en la main solo llamamos al método cargarValor, ya

que el método calcular luego es llamado por el método cargarValor:

public static void main(String[] arg) {

TablaMultiplicar tabla=new TablaMultiplicar();
tabla.cargarValor();
}

Métodos que retornan un dato.

Un método puede retornar un dato:

public [tipo de dato] [nombre del método]([parámetros]) {

[algoritmo]
return [tipo de dato]
}

Cuando un método retorna un dato en vez de indicar la palabra clave

void previo al nombre del método indicamos el tipo de dato que retorna.
Luego dentro del algoritmo en el momento que queremos que finalice el
mismo y retorne el dato empleamos la palabra clave return con el valor
respectivo.
Problema 2:
Confeccionar una clase que permita ingresar tres valores por teclado.
Luego mostrar el mayor y el menor.

import java.util.Scanner;
public class MayorMenor {
public void cargarDatos() {
Scanner teclado=new Scanner(System.in);
int n1,n2,n3, mayor,menor;
System.out.print("Ingrese Numero 1: ");
n1=teclado.nextInt();
System.out.print("Ingrese Numero 2: ");
n2=teclado.nextInt();
System.out.print("Ingrese Numero 3: ");
n3=teclado.nextInt();
mayor=calcularMayor(n1,n2,n3);
menor=calcularMenor(n1,n2,n3);
System.out.println("El mayor de los numeros es: "+mayor);
System.out.println("El menor de los numeros es: "+menor);
}
public int calcularMayor(int v1, int v2, int v3) {
int m;
if(v1>v2 && v1>v3) {
m=v1;
}else {
if(v2>v1 && v2>v3) {
m=v2;
}else {
m=v3;
}
}
return m;
}
public int calcularMenor(int v1, int v2, int v3) {
int m;
if(v1<v2 && v1<v3) {
m=v1;
}else {
if(v2<v1 && v2<v3) {
m=v2;
}else {
m=v3;
}
}
return m;
}
public static void main(String[] arg) {
 MayorMenor objeto1=new MayorMenor();
objeto1.cargarDatos();
}
}

Lo primero que podemos observar que el método retorna un entero y

recibe tres parámetros:
public int calcularMayor(int v1, int v2, int v3) {

Dentro del método verificamos cual de los tres parámetros almacena un

valor mayor, a este valor lo almacenamos en una variable local llamada "m",
al valor almacenado en esta variable lo retornamos al final con un return.

La llamada al método calcularMayor lo hacemos desde dentro del método

cargarDatos:
mayor=calcularMayor(n1,n2,n3);

Debemos asignar a una variable el valor devuelto por el método

calcularMayor. Luego el contenido de la variable mayor lo mostramos:

System.out.println("El valor mayor de los tres es:"+mayor);

La lógica es similar para el cálculo del menor.

15 - Estructura de datos tipo vector

Hemos empleado variables de distinto tipo para el almacenamiento de

datos (variables int, float, String) En esta sección veremos otros tipos de
variables que permiten almacenar un conjunto de datos en una única
variable.

Un vector es una estructura de datos que permite almacenar un

CONJUNTO de datos del MISMO tipo. Con un único nombre se define un
vector y por medio de un subíndice hacemos referencia a cada elemento del
mismo (componente)
Problema 1:
Se desea guardar los sueldos de 5 operarios.

Según lo conocido deberíamos definir 5 variables si queremos tener en

un cierto momento los 5 sueldos almacenados en memoria. Empleando un
vector solo se requiere definir un único nombre y accedemos a cada
elemento por medio del subíndice.

import java.util.Scanner;
public class PruebaVector1 {
private Scanner teclado;
private float[] sueldos;

public void cargar() {

teclado=new Scanner(System.in);
sueldos=new float[5];
for (int i=0;i<5;i++) {
System.out.print("Ingrese el sueldo: ");
sueldos[i]=teclado.nextFloat();
}
}
public void imprimir() {
for(int i=0;i<5;i++) {
System.out.println(sueldos[i]);
}
}
public static void main(String[] arg) {
PruebaVector1 pv=new PruebaVector1();
pv.cargar();
pv.imprimir();
}
}

Para la declaración de un vector le antecedemos al nombre los corchetes

abiertos y cerrados:
 private float[] sueldos;

Lo definimos como atributo de la clase ya que lo utilizaremos en los dos

métodos.
En el método de cargar lo primero que hacemos es crear el vector (en
java los vectores son objetos por lo que es necesario proceder a su creación
mediante el operador new):
sueldos=new float[5];

Cuando creamos el vector indicamos entre corchetes la cantidad de

elementos que se pueden almacenar posteriormente en el mismo.

Para cargar cada componente debemos indicar entre corchetes que

elemento del vector estamos accediendo:

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

System.out.print("Ingrese el sueldo: ");
sueldos[i]=teclado.nextFloat();
}

La estructura de programación que más se adapta para cargar en forma

completa las componentes de un vector es un for, ya que sabemos de
antemano la cantidad de valores a cargar.

Cuando i vale cero estamos accediendo a la primer componente del

vector (en nuestro caso sería):
sueldos[0]=teclado.nextFloat();

Lo mas común es utilizar una estructura repetitiva for para recorrer cada
componente del vector.
Utilizar el for nos reduce la cantidad de código, si no utilizo un for debería
en forma secuencial implementar el siguiente código:

System.out.print("Ingrese el sueldo:");
sueldos[0]=teclado.nextFloat();
System.out.print("Ingrese el sueldo:");
 sueldos[1]=teclado.nextFloat();
System.out.print("Ingrese el sueldo:");
sueldos[2]=teclado.nextFloat();
System.out.print("Ingrese el sueldo:");
sueldos[3]=teclado.nextFloat();
System.out.print("Ingrese el sueldo:");
sueldos[4]=teclado.nextFloat();

Siempre que queremos acceder a una componente del vector debemos

indicar entre corchetes la componente, dicho valor comienza a numerarse en
cero y continua hasta un número menos del tamaño del vector, en nuestro
caso creamos el vector con 5 elementos:
sueldos=new int[5];

Problema 2:
Definir un vector de 5 componentes de tipo float que representen las
alturas de 5 personas. Obtener el promedio de las mismas. Contar cuántas
personas son más altas que el promedio y cuántas más bajas.

import java.util.Scanner;
public class PruebaVector2 {
private Scanner teclado;
private float[] estaturas;
private float promedio;

public void cargar() {

teclado=new Scanner(System.in);
estaturas=new float[5];
for(int i=0;i<5;i++) {
System.out.print("Ingrese la Estatura: ");
estaturas[i]=teclado.nextFloat();
}
}
public void calcularPromedio() {
float suma=0;
for(int i=0;i<5;i++) {
suma=suma+estaturas[i];
}
promedio=suma/5;
System.out.println("El promedio de las Estaturas es:
"+promedio);
}
public void mayoresMenores() {
int mayores=0,menores=0;
 for(int i=0;i<5;i++) {
if(estaturas[i]>promedio) {
mayores++;
}else {
if(estaturas[i]<promedio)
{
menores++;
}
}
}
System.out.println("La cantidad de Estaturas mayores al
promedio es: "+mayores);
System.out.println("La cantidad de Estaturas menores al
promedio es: "+menores);
}
public static void main(String[] arg) {
PruebaVector2 objeto1=new PruebaVector2();
objeto1.cargar();
objeto1.calcularPromedio();
objeto1.mayoresMenores();
}
}
Definimos como atributo un vector donde almacenaremos las alturas:
private float[] estaturas;

En la carga creamos el vector indicando que reserve espacio para 5

componentes:
estaturas=new float[5];

Procedemos seguidamente a cargar todos sus elementos:

for(int i=0;i<5;i++) {
System.out.print("Ingrese la Estatura: ");
estaturas[i]=teclado.nextFloat();
}

En otro método procedemos a sumar todas sus componentes y obtener el

promedio. El promedio lo almacenamos en un atributo de la clase ya que lo
necesitamos en otro método:
public void calcularPromedio() {
float suma=0;
for(int i=0;i<5;i++) {
suma=suma+estaturas[i];
}
promedio=suma/5;
 System.out.println("El promedio de las Estaturas es:
"+promedio);
}
Por último en un tercer método comparamos cada componente del vector
con el atributo promedio, si el valor almacenado supera al promedio
incrementamos un contador en caso que sea menor al promedio
incrementamos otro contador:
public void mayoresMenores() {
int mayores=0,menores=0;
for(int i=0;i<5;i++) {
if(estaturas[i]>promedio) {
mayores++;
}else {
if(estaturas[i]<promedio)
{
menores++;
}
}
}
System.out.println("La cantidad de Estaturas mayores al
promedio es: "+mayores);
System.out.println("La cantidad de Estaturas menores al
promedio es: "+menores);
}

Importante:
En este problema podemos observar una ventaja de tener almacenadas
todas las alturas de las personas. Si no conociéramos los vectores tenemos
que cargar otra vez las alturas por teclado para compararlas con el promedio.
Mientras el programa está en ejecución tenemos el vector alturas a nuestra
disposición. Es importante tener en cuenta que cuando finaliza la ejecución
del programa se pierde el contenido de todas las variables (simples y
vectores)

Problema 3:
Una empresa tiene dos turnos (mañana y tarde) en los que trabajan 8
empleados (4 por la mañana y 4 por la tarde)

Confeccionar un programa que permita almacenar los sueldos de los

empleados agrupados por turno.Imprimir los gastos en sueldos de cada
turno.

import java.util.Scanner;
public class Turnos {
private Scanner teclado;
private float[] turnoManana;
private float[] turnoTarde;

public void cargarDatos() {

teclado=new Scanner(System.in);
turnoManana= new float[4];
turnoTarde=new float[4];
System.out.println("Sueldos empleados turno de la mañana: ");
for(int i=0;i<4;i++) {
System.out.print("Ingrese Sueldo: ");
turnoManana[i]=teclado.nextFloat();
}
System.out.println("Sueldos empleados turno de la tarde: ");
for(int i=0;i<4;i++) {
System.out.print("Ingrese Sueldo: ");
turnoTarde[i]=teclado.nextFloat();
}
}
public void calcularGastos() {
float total1=0, total2=0;
for(int i=0;i<4;i++) {
total1=total1+turnoManana[i];
total2=total2+turnoTarde[i];
}
System.out.println("El Gasto total en sueldos Tuno de la mañana
es: "+total1);
System.out.println("El Gasto total en sueldos Tuno de la tarde
es: "+total2);
}
public static void main(String[] arg) {
Turnos objeto1=new Turnos();
objeto1.cargarDatos();
objeto1.calcularGastos();
}
}

16 - Vector (Tamaño de un vector)

 Como hemos visto cuando se crea un vector indicamos entre corchetes
su tamaño:

sueldos=new int[5];

Luego cuando tenemos que recorrer dicho vector disponemos una

estructura repetitiva for:
for(int f=0;f<5;f++) {
System.out.print("Ingrese valor de la componente:");
sueldos[f]=teclado.nextInt();
}

Como vemos el for se repite mientras el contador f vale menos de 5. Este

estructura repetitiva es idéntica cada vez que recorremos el vector.

Que pasa ahora si cambiamos el tamaño del vector cuando lo creamos:

sueldos=new int[7];

Con esto tenemos que cambiar todos los for que recorren dicho vector.
Ahora veremos que un vector al ser un objeto tiene un atributo llamado
length que almacena su tamaño. Luego podemos modificar todos los for con
la siguiente sintaxis:

for(int f=0;f<sueldos.length;f++) {
System.out.print("Ingrese valor de la componente:");
sueldos[f]=teclado.nextInt();
}

También podemos pedir al usuario que indique el tamaño del vector en

tiempo de ejecución, en estos casos se hace imprescindible el empleo del
atributo length.

Problema 1:
Se desea almacenar los sueldos de operarios. Cuando se ejecuta el
programa se debe pedir la cantidad de sueldos a ingresar. Luego crear un
vector con dicho tamaño.
import java.util.Scanner;
public class Ejemplo5 {
private Scanner teclado;
private float[] sueldos;

public void cargarDatos() {

Scanner teclado=new Scanner(System.in);
int n;
System.out.print("Cuantos sueldos va a Ingresar ? :");
n=teclado.nextInt();
sueldos=new float[n];
for(int i=0;i<sueldos.length;i++) {
System.out.print("Ingrese sueldo: ");
sueldos[i]=teclado.nextFloat();
}
}
public void imprimirDatos() {
for(int i=0;i<sueldos.length;i++) {
System.out.println(sueldos[i]);
}
}
public static void main(String[] arg) {
Ejemplo5 objeto1=new Ejemplo5();
objeto1.cargarDatos();
objeto1.imprimirDatos();
}
}
La definición del vector no varía:

private float[] sueldos;

Luego para la creación del mismo ingresamos una variable entera y la

utilizamos como subíndice en el momento de la creación del vector:
int n;
System.out.print("Cuantos sueldos va a Ingresar ? :");
n=teclado.nextInt();
sueldos=new float[n];

Luego las estructuras repetitivas las acotamos accediendo al atributo

length del vector:
for(int i=0;i<sueldos.length;i++) {
System.out.print("Ingrese sueldo: ");
sueldos[i]=teclado.nextFloat();
 }

17 - Vectores paralelos

Este concepto se da cuando hay una relación entre las componentes de

igual subíndice (misma posición) de un vector y otro.

Si tenemos dos vectores de 5 elementos cada uno. En uno se almacenan

los nombres de personas en el otro las edades de dichas personas.

Decimos que el vector nombres es paralelo al vector edades si en la

componente 0 de cada vector se almacena información relacionada a una
persona (Juan - 12 años)

Es decir hay una relación entre cada componente de los dos vectores.
Esta relación la conoce únicamente el programador y se hace para facilitar el
desarrollo de algoritmos que procesen los datos almacenados en las
estructuras de datos.

Problema 1:

Desarrollar un programa que permita cargar 5 nombres de personas y

sus edades respectivas. Luego de realizar la carga por teclado de todos los
datos imprimir los nombres de las personas mayores de edad (mayores o
iguales a 18 años)
import java.util.Scanner;
public class Personas {
private Scanner teclado;
 private String[] nombres;
private int[] edad;

public void cargarDatos() {

Scanner teclado=new Scanner(System.in);
nombres=new String[5];
edad=new int[5];
for(int i=0;i<nombres.length;i++) {
System.out.print("Ingrese nombre: ");
nombres[i]=teclado.next();
System.out.print("Ingrese edad: ");
edad[i]=teclado.nextInt();
}
}
public void mayoresEdad() {
System.out.println("Personas mayores de edad: ");
for(int i=0;i<nombres.length;i++) {
if(edad[i]>=18) {
System.out.println(nombres[i]);
}
}
}
public static void main(String[] arg) {
Personas objeto1=new Personas();
objeto1.cargarDatos();
objeto1.mayoresEdad();
}
}

Definimos los dos vectores:

private String[] nombres;
private int[] edad;

Creamos los dos vectores con 5 elementos cada uno:

nombres=new String[5];
edad=new int[5];

Mediante un for procedemos a la carga de los elementos de los vectores:

for(int i=0;i<nombres.length;i++) {
System.out.print("Ingrese nombre: ");
nombres[i]=teclado.next();
System.out.print("Ingrese edad: ");
edad[i]=teclado.nextInt();
}
 Podemos utilizar el length de cualquiera de los dos vectores, ya que
tienen el mismo tamaño.

Para imprimir los nombres de las personas mayores de edad verificamos

cada componente del vector de edades, en caso que sea igual o mayor o 18
procedemos a mostrar el elemento de la misma posición del otro vector:

for(int i=0;i<nombres.length;i++) {
if(edad[i]>=18) {
System.out.println(nombres[i]);
}
}

18 - Vectores (mayor y menor elemento)

Es una actividad común la búsqueda del mayor y menor elemento de un

vector, lo mismo que su posición.

El mayor elemento es el 820 y se encuentra en la posición nº 2.

Problema 1:
Confeccionar un programa que permita cargar los nombres de 5 operarios y
sus sueldos respectivos. Mostrar el sueldo mayor y el nombre del operario.

import java.util.Scanner;
public class Ejemplo7 {
private Scanner teclado;
private String[] nombres;
private float[] sueldos;

public void cargarDatos() {

Scanner teclado=new Scanner(System.in);
nombres=new String[5];
sueldos=new float[5];
for(int i=0;i<nombres.length;i++) {
 System.out.print("Ingrese el nombre del empleado: ");
nombres[i]=teclado.next();
System.out.print("Ingrese el sueldo: ");
sueldos[i]=teclado.nextFloat();
}
}
public void mayorSueldo() {
float mayor=sueldos[0];
int pos=0;
for(int i=1;i<nombres.length;i++) {
if(sueldos[i]>mayor)
{
mayor=sueldos[i];
pos=i;
}
}
System.out.println("La persona con mayor sueldo es:
"+nombres[pos]);
System.out.println("Y su sueldo es: "+mayor);
}
public static void main(String[] arg) {
Ejemplo7 objeto1=new Ejemplo7();
objeto1.cargarDatos();
objeto1.mayorSueldo();
}
}
Definimos los dos vectores paralelos donde almacenaremos los nombres
y los sueldos de los operarios:
private String[] nombres;
private float[] sueldos;

Creamos los dos vectores y procedemos a cargar sus elementos:

nombres=new String[5];
sueldos=new float[5];
for(int i=0;i<nombres.length;i++) {
System.out.print("Ingrese el nombre del empleado: ");
nombres[i]=teclado.next();
System.out.print("Ingrese el sueldo: ");
sueldos[i]=teclado.nextFloat();
}

Para obtener el mayor sueldo y el nombre del operario realizar los

siguientes pasos:
Inicializamos una variable mayor con la primer componente del vector
sueldos:
 float mayor=sueldos[0];

Inicializamos una variable pos con el valor 0, ya que decimos

primeramente que el mayor es la primer componente del vector:
int pos=0;

Recorremos las componentes del vector que faltan analizar, o sea, de la

1 a la 4:
for(int i=1;i<nombres.length;i++) {

Accedemos a cada componente para controlar si supera lo que tiene la

variable mayor:
if(sueldos[i]>mayor)

En caso de ser verdadera la condición asignamos a la variable mayor

este nuevo valor sueldos[f]
mayor=sueldos[i];

y a la variable pos le cargamos la variable i que indica la componente que

estamos analizando:
pos=i;

Cuando salimos de la estructura repetitiva imprimimos la variable mayor

que contiene el mayor sueldo y para imprimir el nombre del operario
conociendo la posición del mayor sueldo imprimimos el elemento que ocupa
la posición que indica la variable pos en el vector paralelo:

System.out.println("La persona con mayor sueldo es:

"+nombres[pos]);
System.out.println("Y su sueldo es: "+mayor);

19 - Vectores (ordenamiento)
 El ordenamiento de un vector se logra intercambiando las componentes
de manera que:
vec[0] <= vec[1] <= vec[2] etc.
El contenido de la componente vec[0] sea menor o igual al contenido de
la componente vec[1] y así sucesivamente. Si se cumple lo dicho
anteriormente decimos que el vector está ordenado de menor a mayor.
Igualmente podemos ordenar un vector de mayor a menor.

Se puede ordenar tanto vectores con componentes de tipo int, float como
String. En este último caso el ordenamiento es alfabético.

Problema 1:
Se debe crear un vector donde almacenar 5 sueldos. Ordenar el vector
sueldos de menor a mayor.

Esta primera aproximación tiene por objetivo analizar los intercambios de

elementos dentro del vector.
 El algoritmo consiste en comparar si la primera componente es mayor a
la segunda, en caso que la condición sea verdadera, intercambiamos los
contenidos de las componentes.
Vamos a suponer que se ingresan los siguientes valores por teclado:
1200
750
820
550
490

En este ejemplo: ¿es 1200 mayor a 750? La respuesta es verdadera, por

lo tanto intercambiamos el contenido de la componente 0 con el de la
componente 1.

Luego comparamos el contenido de la componente 1 con el de la

componente 2: ¿Es 1200 mayor a 820?

La respuesta es verdadera entonces intercambiamos.

Si hay 5 componentes hay que hacer 4 comparaciones, por eso el for se

repite 4 veces.

Generalizando: si el vector tiene N componentes hay que hacer N-1

comparaciones.

Cuando f = 0 f = 1 f = 2 f = 3

750 750 750 750

1200 820 820 820
820 1200 550 550
550 550 1200 490
490 490 490 1200

Podemos ver cómo el valor más grande del vector desciende a la última
componente. Empleamos una variable auxiliar (aux) para el proceso de
intercambio:
aux=sueldos[f];
sueldos[f]=sueldos[f+1];
sueldos[f+1]=aux;
 Al salir del for en este ejemplo el contenido del vector es el siguiente:
750
820
550
490
1200

Analizando el algoritmo podemos comprobar que el elemento mayor del

vector se ubica ahora en el último lugar.

Podemos definir otros vectores con distintos valores y comprobar que

siempre el elemento mayor queda al final.

Pero todavía con este algoritmo no se ordena un vector. Solamente está

ordenado el último elemento del vector.

Ahora bien, con los 4 elementos que nos quedan podemos hacer el
mismo proceso visto anteriormente, con lo cual quedará ordenado otro
elemento del vector. Este proceso lo repetiremos hasta que quede ordenado
por completo el vector.

Como debemos repetir el mismo algoritmo podemos englobar todo el

bloque en otra estructura repetitiva.
 Realicemos una prueba del siguiente algoritmo:

Cuando k = 0
f = 0 f = 1 f = 2 f = 3
750 750 750 750
1200 820 820 820
820 1200 550 550
550 550 1200 490
490 490 490 1200

Cuando k = 1
f = 0 f = 1 f = 2 f = 3
750 750 750 750
820 550 550 550
550 820 490 490
490 490 820 820
1200 1200 1200 1200

Cuando k = 2
f = 0 f = 1 f = 2 f = 3
550 550 550 550
750 490 490 490
 490 750 750 750
820 820 820 820
1200 1200 1200 1200

Cuando k = 3
f = 0 f = 1 f = 2 f = 3
490 490 490 490
550 550 550 550
750 750 750 750
820 820 820 820
1200 1200 1200 1200

¿Porque repetimos 4 veces el for externo?

Como sabemos cada vez que se repite en forma completa el for interno
queda ordenada una componente del vector. A primera vista diríamos que
deberíamos repetir el for externo la cantidad de componentes del vector, en
este ejemplo el vector sueldos tiene 5 componentes.

Si observamos, cuando quedan dos elementos por ordenar, al ordenar

uno de ellos queda el otro automáticamente ordenado (podemos imaginar
que si tenemos un vector con 2 elementos no se requiere el for externo,
porque este debería repetirse una única vez)

Una última consideración a este ALGORITMO de ordenamiento es que

los elementos que se van ordenando continuamos comparándolos.

Ejemplo: En la primera ejecución del for interno el valor 1200 queda

ubicado en la posición 4 del vector. En la segunda ejecución comparamos si
el 820 es mayor a 1200, lo cual seguramente será falso.

Podemos concluir que la primera vez debemos hacer para este ejemplo 4
comparaciones, en la segunda ejecución del for interno debemos hacer 3
comparaciones y en general debemos ir reduciendo en uno la cantidad de
comparaciones.
 Si bien el algoritmo planteado funciona, un algoritmo más eficiente, que
se deriva del anterior es el plantear un for interno con la siguiente estructura:
(f=0 ; f<4-k; f++) Es decir restarle el valor del contador del for externo.

import java.util.Scanner;
public class OrdenarVector1 {
private Scanner teclado;
private int[] sueldos;

public void cargarDatos() {

Scanner teclado=new Scanner(System.in);
sueldos=new int[5];
for(int i=0;i<5;i++) {
System.out.print("Ingrese el sueldo: ");
sueldos[i]=teclado.nextInt();
}
}
public void ordenar() {
int aux;
for(int i=0;i<4;i++) {
for(int j=0;j<4-i;j++) {
if(sueldos[j]>sueldos[j+1]) {
aux=sueldos[j];
sueldos[j]=sueldos[j+1];
sueldos[j+1]=aux;
}
}
}
}
public void imprimir() {
System.out.println("Vector Ordenado");
for(int i=0;i<sueldos.length;i++) {
System.out.println(sueldos[i]);
}
}
public static void main(String[] arg) {
OrdenarVector1 objeto1=new OrdenarVector1();
objeto1.cargarDatos();
objeto1.ordenar();
objeto1.imprimir();
}
}
 También podemos ordenar vectores cuyas componentes sean de tipo
String. Para esto no podemos utilizar el operador > sino debemos utilizar un
método de la clase String:
String cad1="juan";
String cad2="analia";
if (cad1.compareTo(cad2)>0)
{
System.out.println(cad1 + " es mayor alfabéticamente que " +
cad2);
}
El método compareTo retorna un valor mayor a cero si cad1 es mayor
alfabéticamente. En este ejemplo cad1 tiene un valor alfabéticamente mayor
a cad2, luego el compareTo retorna un valor mayor a cero.

Si los dos String son exactamente iguales el método compareTo retorna

un cero, y finalmente si cad1 es menor alfabeticamente retorna un valor
menor a cero.

Problema 2:
Definir un vector donde almacenar los nombres de 5 paises. Confeccionar
el algoritmo de ordenamiento alfabético.

import java.util.Scanner;
public class OrdenarVector2 {
private Scanner teclado;
private String[] paises;

public void cargarDatos() {

teclado=new Scanner(System.in);
paises=new String[5];
for(int i=0;i<paises.length;i++) {
System.out.print("Ingrese el nombre del pais: ");
paises[i]=teclado.next();
}
}
public void ordenar() {
String aux;
for(int i=0;i<4;i++) {
for(int j=0;j<4-i;j++) {
if(paises[j].compareTo(paises[j+1])>0) {
aux=paises[j];
paises[j]=paises[j+1];
 paises[j+1]=aux;
}
}
}
}
public void imprimir() {
System.out.println("Paises odenados Alfabeticamente");
for(int i=0;i<paises.length;i++) {
System.out.println(paises[i]);
}
}
public static void main(String[] arg) {
OrdenarVector2 objeto1=new OrdenarVector2();
objeto1.cargarDatos();
objeto1.ordenar();
objeto1.imprimir();
}
}
20 - Vectores (ordenamiento con vectores paralelos)

Cuando se tienen vectores paralelos y se ordena uno de ellos hay que

tener la precaución de intercambiar los elementos de los vectores paralelos.

Problema 1:
Confeccionar un programa que permita cargar los nombres de 5 alumnos
y sus notas respectivas. Luego ordenar las notas de mayor a menor. Imprimir
las notas y los nombres de los alumnos.
import java.util.Scanner;
public class OrdenarVector3 {
private Scanner teclado;
private String[] nombres;
private int[] notas;

public void cargarDatos() {

teclado=new Scanner(System.in);
nombres=new String[5];
notas=new int[5];

for(int i=0;i<notas.length;i++) {
System.out.print("Ingrese nombre del Estudiante: ");
nombres[i]=teclado.next();
System.out.print("Ingrese la nota del Estudiante: ");
notas[i]=teclado.nextInt();
}
}
 public void ordenar() {
String aux;
int aux_nota;
for(int i=0;i<notas.length-1;i++) {
for(int j=0;j<notas.length-1-i;j++) {
if(notas[j]<notas[j+1]){
aux_nota=notas[j];
notas[j]=notas[j+1];
notas[j+1]=aux_nota;

aux=nombres[j];
nombres[j]=nombres[j+1];
nombres[j+1]=aux;
}
}
}
}
public void imprimir() {
System.out.println("Notas Ordenadas de Mayor a Menor: ");
for(int i=0;i<notas.length;i++) {
System.out.println(nombres[i]+" : "+notas[i]);
}
}
public static void main(String[] arg) {
OrdenarVector3 objeto1=new OrdenarVector3();
objeto1.cargarDatos();
objeto1.ordenar();
objeto1.imprimir();
}
}

Problema 2:
Cargar en un vector los nombres de 5 países y en otro vector paralelo la
cantidad de habitantes del mismo. Ordenar alfabéticamente e imprimir los
resultados. Por último ordenar con respecto a la cantidad de habitantes (de
mayor a menor) e imprimir nuevamente.

import java.util.Scanner;
public class OrdenarVector4 {
private Scanner teclado;
private String[] paises;
private int[] habitantes;

public void cargarDatos() {

teclado=new Scanner(System.in);
paises=new String[5];
 habitantes=new int[5];
for(int i=0;i<paises.length;i++) {
System.out.print("Ingrese el nombre del Pais: ");
paises[i]=teclado.next();
System.out.print("Ingrese la cantidad de Habitantes: ");
habitantes[i]=teclado.nextInt();
}
}
public void ordenarAlfabeticamente() {
String aux_paises;
int aux_habitantes;
for(int i=0;i<paises.length-1;i++) {
for(int j=0;j<paises.length-1-i;j++) {
if(paises[j].compareTo(paises[j+1])>0) {
aux_paises=paises[j];
paises[j]=paises[j+1];
paises[j+1]=aux_paises;

aux_habitantes=habitantes[j];
habitantes[j]=habitantes[j+1];
habitantes[j+1]=aux_habitantes;
}
}
}
}
public void imprimir(String texto) {
System.out.println("Vector Ordenado "+texto);
for(int i=0;i<paises.length;i++) {
System.out.println(paises[i]+": "+habitantes[i]);
}
}
public void ordenarHabitantes() {
String aux_paises;
int aux_habitantes;
for(int i=0;i<paises.length-1;i++) {
for(int j=0;j<paises.length-1-i;j++) {
if(habitantes[j]<habitantes[j+1]) {
aux_habitantes=habitantes[j];
habitantes[j]=habitantes[j+1];
habitantes[j+1]=aux_habitantes;

aux_paises=paises[j];
paises[j]=paises[j+1];
paises[j+1]=aux_paises;
}
}
}
}
public static void main(String[] arg) {
OrdenarVector4 objeto1=new OrdenarVector4();
 objeto1.cargarDatos();
objeto1.ordenarAlfabeticamente();
objeto1.imprimir("Alfabeticamente:");
objeto1.ordenarHabitantes();
objeto1.imprimir("Por Numero de Habitantes:");
}
}

21 - Estructura de datos tipo matriz

Una matriz es una estructura de datos que permite almacenar un

CONJUNTO de datos del MISMO tipo.

Con un único nombre se define la matriz y por medio de DOS subíndices

hacemos referencia a cada elemento de la misma (componente).

Hemos graficado una matriz de 3 filas y 5 columnas. Para hacer

referencia a cada elemento debemos indicar primero la fila y luego la
columna, por ejemplo en la componente 1,4 se almacena el valor 97.

En este ejemplo almacenamos valores enteros. Todos los elementos de

la matriz deben ser del mismo tipo (int, float, String etc.)

Las filas y columnas comienzan a numerarse a partir de cero, similar a los

vectores.
Una matriz se la puede representar por un conjunto de vectores.

Problema 1:
 Crear una matriz de 3 filas por 5 columnas con elementos de tipo int,
cargar sus componentes y luego imprimirlas.

import java.util.Scanner;
public class Matriz1 {
private Scanner teclado;
private int[][] mat;

public void cargarDatos() {

teclado=new Scanner(System.in);
mat=new int[3][5];
for(int i=0;i<3;i++) {
for(int j=0;j<5;j++) {
System.out.print("Ingrese valor: ");
mat[i][j]=teclado.nextInt();
}
}
}
public void imprimir() {
for(int i=0;i<3;i++) {
for(int j=0;j<5;j++) {
System.out.print(mat[i][j]+" ");
}
System.out.println();
}
}
public static void main(String[] arg) {
Matriz1 objeto1=new Matriz1();
objeto1.cargarDatos();
objeto1.imprimir();
}
}

Para definir una matriz debemos antecederle los corchetes abiertos y

cerrados dos veces:
private int[][] mat;

De esta forma el compilador de Java puede diferenciar los vectores de las

matrices.

Para crear la matriz, es decir hacer la reserva de espacio de todas sus

componentes debemos utilizar el operador new y mediante dos subíndices
indicamos la cantidad de filas y columnas que tendrá la matriz:
 mat=new int[3][5];

Luego debemos pasar a cargar sus 15 componentes (cada fila almacena

5 componentes y tenemos 3 filas)

Lo más cómodo es utilizar un for anidado, el primer for que incrementa el

contador i lo utilizamos para recorrer las filas y el contador interno llamado j
lo utilizamos para recorrer las columnas.

Cada vez que se repite en forma completa el for interno se carga una fila
completa, primero se carga la fila cero en forma completa, luego la fila uno y
finalmente la fila 2.

Siempre que accedemos a una posición de la matriz debemos disponer

dos subíndices que hagan referencia a la fila y columna mat[i][j]):

for(int i=0;i<3;i++) {
for(int j=0;j<5;j++) {
System.out.print("Ingrese valor: ");
mat[i][j]=teclado.nextInt();
}
}

Para imprimir la matriz de forma similar utilizamos dos for para acceder a
cada elemento de la matriz:
for(int i=0;i<3;i++) {
for(int j=0;j<5;j++) {
System.out.print(mat[i][j]+" ");
}
System.out.println();
}

Cada vez que se ejecuta todas las vueltas del for interno tenemos en
pantalla una fila completa de la matriz, por eso pasamos a ejecutar un salto
de línea (con esto logramos que en pantalla los datos aparezcan en forma
matricial):
System.out.println();
Problema 2:
Crear y cargar una matriz de 4 filas por 4 columnas. Imprimir la diagonal
principal.
x - - -
- x - -
- - x -
- - - x

public class Matriz2 {

private String[][] diagonal;

public void rellenarMatriz() {

diagonal=new String[4][4];
for(int i=0;i<4;i++) {
for(int j=0;j<4;j++) {
if(i==j)
diagonal[i][j]="x";
else
diagonal[i][j]="-";
}
}
}
public void imprimir() {
for(int i=0;i<4;i++) {
for(int j=0;j<4;j++) {
System.out.print(diagonal[i][j]+" ");
}
System.out.println();
}
}
public static void main(String[] arg) {
Matriz2 objeto1=new Matriz2();
objeto1.rellenarMatriz();
objeto1.imprimir();
}
}

Problema 3:
Crear y cargar una matriz de 3 filas por 4 columnas. Imprimir la primer fila.
Imprimir la última fila e imprimir la primer columna.
package matrices;
import java.util.Scanner;
public class Matriz3 {
private Scanner teclado;
private int[][] mat;

public void cargarDatos() {

teclado=new Scanner(System.in);
mat=new int[3][4];
for(int i=0;i<3;i++) {
for(int j=0;j<4;j++) {
System.out.print("Ingrese valor: ");
mat[i][j]=teclado.nextInt();
}
}
}
public void primeraFila() {
System.out.println("Primera Fila de la Matriz");
for(int i=0;i<4;i++) {
System.out.print(mat[0][i]+" ");
}
System.out.println();
}
public void ultimaFila() {
System.out.println("Ultima Fila de la Matriz");
for(int i=0;i<4;i++) {
System.out.print(mat[2][i]+" ");
}
System.out.println();
}
public void primeraColumna() {
System.out.println("Primera Columa de la Matriz");
for(int i=0;i<3;i++) {
System.out.print(mat[i][0]+" ");
}
}
public static void main(String[] arg) {
Matriz3 objeto1=new Matriz3();
objeto1.cargarDatos();
objeto1.primeraFila();
objeto1.ultimaFila();
objeto1.primeraColumna();
}
}
Creamos una matriz de 3 filas y 4 columnas:
mat=new int[3][4];
 Luego de cargarla el primer método que codificamos es el que imprime la
primer fila. Disponemos un for para recorrer las columnas, ya que la fila
siempre será la cero. Como son cuatro los elementos de la primer fila el for
se repite esta cantidad de veces:

System.out.println("Primera Fila de la Matriz");

for(int i=0;i<4;i++) {
System.out.print(mat[0][i]+" ");
}

Para imprimir la última fila el algoritmo es similar, disponemos un for que

se repita 4 veces y en el subíndice de la fila disponemos el valor 2 (ya que la
matriz tiene 3 filas):
System.out.println("Ultima Fila de la Matriz");
for(int i=0;i<4;i++) {
System.out.print(mat[2][i]+" ");
}

Para imprimir la primer columna el for debe repetirse 3 veces ya que la

matriz tiene 3 filas. Dejamos constante el subíndice de la columna con el
valor cero:
System.out.println("Primera Columa de la Matriz");
for(int i=0;i<3;i++) {
System.out.print(mat[i][0]+" ");
}

22 - Matrices (cantidad de filas y columnas)

Como hemos visto para definir y crear la matriz utilizamos la siguiente

sintaxis:
int[][] mat;
Creación:
mat=new int[3][4];

Como las matrices son objetos en Java disponemos por un lado del
atributo length que almacena la cantidad de filas de la matriz:

System.out.println("Cantidad de filas de la matriz:" + mat.length);

 También podemos preguntarle a cada fila de la matriz la cantidad de
elementos que almacena:

System.out.println("Cantidad de elementos de la primer fila:" +

mat[0].length);

Problema 1:
Crear una matriz de n * m filas (cargar n y m por teclado) Imprimir la matriz
completa y la última fila.

import java.util.Scanner;
public class matriz5 {
private Scanner teclado;
private int[][] mat;

public void cargarDatos() {

Scanner teclado=new Scanner(System.in);
int filas,columnas;
System.out.print("Ingrese la cantidad de Filas de la Matriz: ");
filas=teclado.nextInt();
System.out.print("Ingrese la cantidad de Columnas de la Matriz:
");
columnas=teclado.nextInt();
mat=new int[filas][columnas];
for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
System.out.print("Ingrese valor: ");
mat[i][j]=teclado.nextInt();
}
}
}
public void imprimir() {
for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
System.out.print(mat[i][j]+" - ");
}
System.out.println();
}
}
public void imprimirUltimaFila() {
System.out.println("Ultima fila");
for(int i=0;i<mat[mat.length-1].length;i++) {
System.out.print(mat[mat.length-1][i]+" - ");
}
 }
public static void main(String[] arg) {
matriz5 objeto1=new matriz5();
objeto1.cargarDatos();
objeto1.imprimir();
objeto1.imprimirUltimaFila();
}
}
En este ejemplo cada vez que se ejecute el programa el tamaño de la
matriz lo define el usuario, para ello ingresamos por teclado dos enteros y
seguidamente procedemos a crear la matriz con dichos valores:

int filas,columnas;
System.out.print("Ingrese la cantidad de Filas de la Matriz: ");
filas=teclado.nextInt();
System.out.print("Ingrese la cantidad de Columnas de la Matriz:
");
columnas=teclado.nextInt();
mat=new int[filas][columnas];

Ahora las estructuras repetitivas las acotamos preguntando a la misma

matriz la cantidad de filas y la cantidad de elementos de cada fila(mat.length
almacena la cantidad de filas de la matriz y mat[i].length cuando i vale cero
accedemos a la cantidad de elementos de la fila cero y así sucesivamente
para cada valor de i):

for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
System.out.print("Ingrese valor: ");
mat[i][j]=teclado.nextInt();
}
}

El algoritmo de impresión es idéntico al visto anteriormente con la

modificación de las condiciones de los for:

public void imprimir() {

for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
 System.out.print(mat[i][j]+" - ");
}
System.out.println();
}
}

Para imprimir la última fila debemos disponer un valor fijo en el subíndice

de la fila (en este caso no podemos disponer un número fijo sino preguntarle
a la misma matriz la cantidad de filas y restarle uno ya que las filas
comienzan a numerarse a partir de cero: mat[mat.length-1][i])

También la condición del for debemos acceder al atributo length de la

última fila mat[mat.length-1].length

for(int i=0;i<mat[mat.length-1].length;i++) {
System.out.print(mat[mat.length-1][i]+" - ");
}

Problema 2:
Crear una matriz de n * m (cargar n y m por teclado) Imprimir el mayor
elemento y la fila y columna donde se almacena.

import java.util.Scanner;
public class matriz_7 {
private Scanner teclado;
private int[][] mat;

public void cargarDatos() {

teclado=new Scanner(System.in);
int filas,columnas;
System.out.print("Ingrese la cantidad de Filas de la Matriz: ");
filas=teclado.nextInt();
System.out.print("Ingrese la cantidad de Columnas de la Matriz:
");
columnas=teclado.nextInt();
mat=new int[filas][columnas];
for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
System.out.print("Ingrese valor: ");
mat[i][j]=teclado.nextInt();
}
}
}
 public void imprimirMayor() {
int mayor=mat[0][0],fila_mayor=0,columna_mayor=0;
for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
if(mat[i][j]>mayor) {
mayor=mat[i][j];
fila_mayor=i;
columna_mayor=j;
}
}
}
System.out.println("El mayor elemento es: "+mayor);
System.out.println("Esta almacenado en la Fila: "+fila_mayor);
System.out.println("Esta almacenado en la Columna:
"+columna_mayor);
}
public static void main(String[] arg) {
matriz_7 objeto1=new matriz_7();
objeto1.cargarDatos();
objeto1.imprimirMayor();
}
}
Para obtener el mayor elemento de la matriz y la fila y columna donde se
ubica debemos inicializar una variable mayor con el elemento de la fila cero y
columna cero (esto lo hacemos suponiendo que en dicha posición se
almacena el mayor):
int mayor=mat[0][0];
fila_mayor=0;
columna_mayor=0;

Luego mediante dos for recorremos todos los elementos de la matriz y

cada vez que encontramos un elemento mayor al actual procedemos a
actualizar la variable mayor y la posición donde se almacena:

for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
if(mat[i][j]>mayor) {
mayor=mat[i][j];
fila_mayor=i;
columna_mayor=j;
 }
}
}

23 - Matrices y vectores paralelos

Dependiendo de la complejidad del problema podemos necesitar el

empleo de vectores y matrices paralelos.

Problema 1:
Se tiene la siguiente información:
· Nombres de 4 empleados.
· Ingresos en concepto de sueldo, cobrado por cada empleado, en los últimos
3 meses.
Confeccionar el programa para:
a) Realizar la carga de la información mencionada.
b) Generar un vector que contenga el ingreso acumulado en sueldos en los
últimos 3 meses para cada empleado.
c) Mostrar por pantalla el total pagado en sueldos a todos los empleados en
los últimos 3 meses
d) Obtener el nombre del empleado que tuvo el mayor ingreso acumulado

import java.util.Scanner;
public class matriz9 {
private Scanner teclado;
private String[] empleados;
private float[][] sueldos;
private float[] total_sueldos;
 public void cargarDatos() {
teclado=new Scanner(System.in);
empleados=new String[4];
sueldos=new float[4][3];

for(int i=0;i<sueldos.length;i++) {
System.out.print("Ingrese el nombre del Empleado: ");
empleados[i]=teclado.next();
for(int j=0;j<sueldos[i].length;j++) {
int contador=j+1;
System.out.print("Ingrese Sueldo mes "+contador+": ");
sueldos[i][j]=teclado.nextFloat();
}
}
}
public void sueldo_Acumulado() {
total_sueldos=new float[4];
float sumatoria;
for(int i=0;i<sueldos.length;i++) {
sumatoria=0;
for(int j=0;j<sueldos[i].length;j++) {
sumatoria=sumatoria+sueldos[i][j];
}
total_sueldos[i]=sumatoria;
}
}
public void imprimir_Total_Pagado() {
System.out.println("Total Pagado a los Empleados Ultimos 3
Meses");
for(int i=0;i<empleados.length;i++) {
System.out.println(empleados[i]+": "+total_sueldos[i]);
}
}
public void empleado_Mayor_Sueldo() {
float mayor_sueldo=total_sueldos[0];
int posicion=0;
for(int i=1;i<total_sueldos.length;i++) {
if(total_sueldos[i]>mayor_sueldo) {
mayor_sueldo=total_sueldos[i];
posicion=i;
}
}
System.out.println("El empleado con el mayor Sueldo es
"+empleados[posicion]+" con un sueldo de "+mayor_sueldo);
}
public static void main(String[] arg) {
matriz9 objeto1=new matriz9();
objeto1.cargarDatos();
objeto1.sueldo_Acumulado();
 objeto1.imprimir_Total_Pagado();
objeto1.empleado_Mayor_Sueldo();
}
}
24 - Matrices irregulares
Java nos permite crear matrices irregulares. Se dice que una matriz es
irregular si la cantidad de elementos de cada fila varía. Luego podemos
imaginar una matriz irregular:

Como podemos ver la fila cero tiene reservado dos espacios, la fila uno
reserva cuatro espacios y la última fila reserva espacio para tres
componentes.

Para crear la matriz irregular del gráfico:

La declaración es la misma que para matrices regulares:
int [][] mat;

Primero creamos la cantidad de filas dejando vacío el espacio que indica

la cantidad de columnas:
mat=new int[3][];

Luego debemos ir creando cada fila de la matriz indicando la cantidad de

elementos de la respectiva fila:

mat[0]=new int[2];
mat[1]=new int[4];
mat[2]=new int[3];
 Luego la forma para acceder a sus componentes es similar a las matrices
regulares, siempre teniendo en cuenta y validando que exista dicha
componente:
mat[0][0]=120;

Dará un error si queremos cargar la tercer componente de la fila cero

(esto debido a que no existe):

mat[0][2]=230;

Luego si queremos saber la cantidad de filas que tiene la matriz:

Sytem.out.println(mat.length);

Si queremos saber la cantidad de elementos de una determinada fila:

Sytem.out.println("Cantidad de elementos de la fila 0:"+mat[0].length);
Sytem.out.println("Cantidad de elementos de la fila 1:"+mat[1].length);
Sytem.out.println("Cantidad de elementos de la fila 2:"+mat[2].length);

Problema 1:

Confeccionaremos un programa que permita crear una matriz irregular y

luego imprimir la matriz en forma completa.

import java.util.Scanner;
public class matriz11 {
private Scanner teclado;
private int[][] mat;

public void cargarDatos() {

teclado=new Scanner(System.in);
int filas, columnas;
System.out.print("Cuantas filas tiene la matriz: ");
filas=teclado.nextInt();
mat=new int[filas][];
for(int i=0;i<mat.length;i++) {
System.out.print("De cuantas columnas es la fila "+i+": ");
columnas=teclado.nextInt();
mat[i]=new int[columnas];
for(int j=0;j<mat[i].length;j++) {
 System.out.print("Ingrese valor: ");
mat[i][j]=teclado.nextInt();
}
}
}
public void imprimir() {
for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
System.out.print(mat[i][j]+" - ");
}
System.out.println();
}
}
public static void main(String[] arg) {
matriz11 objeto1=new matriz11();
objeto1.cargarDatos();
objeto1.imprimir();
}
}
25 - Constructor de la clase

En Java podemos definir un método que se ejecute inicialmente y en

forma automática. Este método se lo llama constructor.

El constructor tiene las siguientes características:

 Tiene el mismo nombre de la clase.

 Es el primer método que se ejecuta.
 Se ejecuta en forma automática.
 No puede retornar datos.
 Se ejecuta una única vez.
 Un constructor tiene por objetivo inicializar atributos.

Problema 1:
Se desea guardar los sueldos de 5 operarios en un vector. Realizar la
creación y carga del vector en el constructor.
import java.util.Scanner;
public class Constructor {
private Scanner teclado;
private float[] vector;
 public Constructor() {
teclado=new Scanner(System.in);
vector=new float[5];
for(int i=0;i<5;i++) {
System.out.print("Ingrese el sueldo: ");
vector[i]=teclado.nextFloat();
}
}
public void imprimir() {
for(int i=0;i<5;i++) {
System.out.println(vector[i]);
}
}
public static void main(String[] arg) {
Constructor objeto1=new Constructor();
objeto1.imprimir();
}
}

Como podemos ver es el mismo problema que resolvimos cuando vimos

vectores. La diferencia es que hemos sustituido el método cargar con el
constructor:
public Constructor() {
teclado=new Scanner(System.in);
vector=new float[5];
for(int i=0;i<5;i++) {
System.out.print("Ingrese el sueldo: ");
vector[i]=teclado.nextFloat();
}
}

Como la clase se llama Constructor, el constructor tiene el mismo

nombre, no disponemos la palabra clave void ya que el constructor no puede
retornar datos.
La ventaja de plantear un constructor en lugar de definir un método con
cualquier nombre es que se llamará en forma automática cuando se crea un
objeto de esta clase:
public static void main(String[] arg) {
Constructor objeto1=new Constructor();
Cuando se crea el objeto se llama al método constructor. Finalmente
llamamos al método imprimir:
objeto1.imprimir();
Problema 2:
Plantear una clase llamada Alumno y definir como atributos su nombre y
su edad. En el constructor realizar la carga de datos. Definir otros dos
métodos para imprimir los datos ingresados y un mensaje si es mayor o no
de edad (edad >=18)
import java.util.Scanner;
public class Alumno {
private Scanner teclado;
private String nombre;
private int edad;

public Alumno() {
teclado=new Scanner(System.in);
System.out.print("Ingrese el nombre: ");
nombre=teclado.next();
System.out.print("Ingrese la edad: ");
edad=teclado.nextInt();
}
public void imprimir() {
System.out.println("***Datos del Alumno***");
System.out.println("Nombre: "+nombre);
System.out.println("Edad: "+edad);
}
public void esMayor() {
if(edad>=18)
System.out.println(nombre+" Es mayor de edad");
else
System.out.println(nombre+" No es mayor de edad");
}
public static void main(String[] arg) {
Alumno objeto1=new Alumno();
objeto1.imprimir();
objeto1.esMayor();
}
}

Problema 3:
Plantear una clase TablaMultiplicar. Definir dos constructores uno con un
parámetro que llegue un entero indicando que tabla queremos ver y otro con
dos enteros que indique el primero que tabla queremos ver y el segundo
parámetro indica cuantos términos mostrar.
 Si no llega la cantidad de términos a mostrar inicializar en 10 los términos
a mostrar

public class TablaMultiplicar2 {

private int numero;
private int termino;

public TablaMultiplicar2(int valor)

{
numero=valor;
termino=10;
}
public TablaMultiplicar2(int valor1, int valor2) {
numero=valor1;
termino=valor2;
}
public void imprimir() {
int resultado;
System.out.println("***Tabla de Multiplicar del "+numero+"***");
for(int i=1;i<=termino;i++) {
resultado=numero*i;
System.out.println(numero+"*"+i+"="+resultado);
}
}
public static void main(String[] arg) {
TablaMultiplicar2 tabla1=new TablaMultiplicar2(5);
tabla1.imprimir();
TablaMultiplicar2 tabla2=new TablaMultiplicar2(3,5);
tabla2.imprimir();
}
}
26 - Clase String

La clase String está orientada a manejar cadenas de caracteres. Hasta

este momento hemos utilizado algunos métodos de la clase String (equals,
compareTo) Ahora veremos otro conjunto de métodos de uso común de la
clase String:

Métodos
boolean equals(String s1)

Como vimos el método equals retorna true si el contenido de caracteres

del parámetro s1 es exactamente igual a la cadena de caracteres del objeto
que llama al método equals.

boolean equalsIgnoreCase(String s1)

El funcionamiento es casi exactamente igual que el método equals con la

diferencia que no tiene en cuenta mayúsculas y minúsculas (si comparamos
'Ana' y 'ana' luego el método equalsIgnoreCase retorna true)

int compareTo(String s1)

Este método retorna un 0 si el contenido de s1 es exactamente igual al

String contenido por el objeto que llama al método compareTo. Retorna un
valor >0 si el contenido del String que llama al método compareTo es mayor
alfabéticamente al parámetro s1.

char charAt(int pos)

Retorna un caracter del String, llega al método la posición del caracter a

extraer.

int length()
Retorna la cantidad de caracteres almacenados en el String.

String substring(int pos1,int pos2)

Retorna un substring a partir de la posición indicada en el parámetro pos1

hasta la posición pos2 sin incluir dicha posición.

int indexOf(String s1)

 Retorna -1 si el String que le pasamos como parámetro no está contenida
en la cadena del objeto que llama al método. En caso que se encuentre
contenido el String s1 retorna la posición donde comienza a repetirse.

String toUpperCase()

Retorna un String con el contenido convertido todo a mayúsculas.

String toLowerCase()
Retorna un String con el contenido convertido todo a minúsculas.

Problema 1:
Confeccionar una clase que solicite el ingreso de dos String y luego
emplee los métodos más comunes de la clase String.

import java.util.Scanner;
public class Funciones {
public static void main(String[] arg) {
Scanner teclado=new Scanner(System.in);
String cad1,cad2;
System.out.print("Ingrese la Primera Cadena: ");
cad1=teclado.nextLine();
System.out.print("Ingrese la Segunda Cadena: ");
cad2=teclado.nextLine();
if(cad1.equals(cad2)==true)
System.out.println(cad1+" es exactamente igual a "+cad2);
else
System.out.println(cad1+" NO es exactamente igual a
"+cad2);
if(cad1.equalsIgnoreCase(cad2)==true)
System.out.println(cad1+" es igua a "+cad2+" sin tner en
cuenta mayusculas/minusculas");
else
System.out.println(cad1+" NO es igua a "+cad2+" sin tner en
cuenta mayusculas/minusculas");
if(cad1.compareTo(cad2)==0)
System.out.println(cad1+" es exactamente igua a "+cad2);
else {
if(cad1.compareTo(cad2)>0)
System.out.println(cad1+" es mayor alfabeticamente que
"+cad2);
else
 System.out.println(cad2+" es mayor alfabeticamente que
"+cad1);
}
char letra=cad1.charAt(0);
System.out.println("El primer caracter de "+cad1+" es "+letra);
int largo=cad1.length();
System.out.println("El largo de la cadena "+cad1+" es "+largo);
String cad3=cad1.substring(0,3);
System.out.println("Los primeros 3 caracteres de "+cad1+" son
"+cad3);
int pos=cad1.indexOf(cad2);
if(pos==-1)
System.out.println(cad2+" no esta contenida en "+cad1);
else
System.out.println(cad2+" esta contenido en "+cad1+" a
partir de la posicion "+pos);
System.out.println(cad1+" convertida a Mayusculas es:
"+cad1.toUpperCase());
System.out.println(cad1+" convertida a minusculas es:
"+cad1.toLowerCase());
}
}