MÉTODO DE LAS 6’D

modelamiento – algoritmo – programación

(Enfoque orientado a las estructuras lógicas)
2da Edición
 MÉTODO DE LAS 6’D
modelamiento – algoritmo - programación
(Enfoque orientado a las estructuras lógicas)
2da Edición

Ing. Juan José Flores Cueto

Ing. Carmen Bertolotti Zuñiga

- 2008 -
EL PAQUETE DEL LENGUAJE JAVA

El paquete del lenguaje Java, conocido también como java.lang, es uno de los paquetes
más importantes de la API1 de Java, y contiene las clases que constituyen el corazón del
lenguaje de programación Java.

El paquete Java.lang debido a su importancia no requiere ser importado por las

aplicaciones para usar las clases que contiene, es decir, está automáticamente
importado para todos los programas, por lo que la siguiente sentencia no será
necesaria:

import java.lang.* ;

El paquete java.lang contiene clases que encapsulan los tipos primitivos de datos, una
clase que proporciona los objetos 2 para manipular la entrada y la salida estándar, clases
para manipular cadenas de caracteres, una clase que proporciona métodos 3
correpondientes a las funciones matemáticas, etc.

Entre las clases más importantes están las siguientes:

Boolean Double Object StringBuffer

Byte Float Package System
Character Integer Process Thread
Class Long Runtime Trowable
ClassLoader Math Short
Compiler Number String

1
API: Aplication Program Interface.
Una API es un conjunto de normas que determinan como debe usarse una determinada función de un
lenguaje de programación en una aplicación.

2
Objetos: Modelos de entes del mundo.
Un objeto de software es cualquier cosa, real o abstracta, acerca del cual almacenamos datos y los métodos
que controlan dichos datos.

3
Métodos: Desarrollo de algoritmos.
Los métodos especifican la forma en que se controlan los datos de un objeto y es donde se define el
comportamiento del mismo. En palabras sencillas; en los métodos se desarrollan o codifican los algoritmos.

Pag. 3
Entre las clases que serán tratadas en esta primera parte del Apéndice se tienen:

1. Clases que envuelven los tipos de datos primitivos, conocidas como las clases
wrappers (envoltorios). Cada una de estas clases (consideradas subclases 4), a
excepción de la clase Character, se derivan de la clase abstracta 5 Number
(considerada superclase).

• Boolean.
• Byte.
• Character.
• Double.
• Float.
• Integer.
• Long.
• Short.

2. Clase que proporciona métodos correspondientes a las funciones matemáticas

básicas.

• Math.

3. Clase que proporciona los objetos necesarios para manipular y tratar cadenas
de caracteres.

• String.

4
Herencia: Subclase y Superclase.
La Herencia es uno de los conceptos más importantes de la Programación Orientada a Objetos (POO).
Utilizando la herencia se puede derivar una nueva clase a partir de otra clase existente, donde la nueva clase
derivada heredará todos los atributos y métodos de la clase existente. La nueva clase se llama Clase Derivada
(o subclase) y la clase original se llama Clase Base (o superclase).

5
Clase Abstracta: Clase tratada como SuperClase.
Una Clase Abstracta es un tipo de clase de la cual no se pueden crear o instanciar objetos. En su lugar, se
debe derivar una nueva clase a partir de la clase abstracta, codificar los métodos que son declarados como
abstractos en la clase abstracta y crear o instanciar objetos a partir de la clase derivada. Las clases abstractas
se utilizan para forzar a los programadores a desarrollar algunos o todos los métodos de una clase.

Pag. 4
En Java, los métodos siempre están dentro de una clase. Algunos métodos pueden ser
invocados o ejecutados utilizando directamente el nombre de la clase en la cual están
definidos, tal es el caso de los métodos de la clase Math de Java. Estos métodos son
conocidos como métodos estáticos o de clase.

Por otro lado, otros métodos son invocados o ejecutados utilizando un objeto o
instancia6 de la clase en la cual están definidos, tal es el caso de los métodos de la clase
String de Java. Estos métodos son conocidos como métodos de instancia o de objeto.

También serán tratadas otras clases incorporadas en el lenguaje de programación Java

tales como:

▪ Clase Calendar

▪ Clase GregorianCalendar

▪ Clase SimpleDateFormat

6
Instancia: Representación concreta de una clase.
Una Instancia viene a ser lo mismo que un objeto. Crear un objeto o instanciar una clase se refiere a poder
tener una representación real de una clase.

Pag. 5
Pag. 6
CONVERSIÓN DE DATOS

Como regla general, una variable solo puede almacenar valores de acuerdo al tipo de
dato con el que fue declarado. Es decir, si se declara una variable con un tipo de dato
específico, solo podrá almacenar valores de dicho tipo de dato. En base a esto, si se
declara una variable con un tipo de dato específico y se intenta almacenar un valor de
distinto tipo, al momento de compilar, el programa indicará un error.

Problema 156

Clase PrgTipoDato01

package dominioDeLaAplicacion ;
class PrgTipoDato01 {

public static void main ( String arg [ ] ) {

double numReal = 4.3 ;

int numEntero ;

// La siguiente línea genera error.

numEntero = numReal ;

System.out.println ( numEntero ) ;
}
}

Observación: No se puede almacenar un número real grande (double) en una variable entera
(int).

Problema 157

Clase PrgTipoDato02

package dominioDeLaAplicacion ;
class PrgTipoDato02 {

public static void main ( String arg [ ] ) {

double numRealDouble = 2.3 ;

float numRealFloat ;

// La siguiente línea genera error.

numRealFloat = numRealDouble ;

System.out.println ( numRealFloat ) ;
}
}

Pag. 7
 Observación: No se puede almacenar un número real grande (double) en una variable real
(float).

Problema 158

Clase PrgTipoDato03

package dominioDeLaAplicacion ;
class PrgTipoDato03 {

public static void main ( String arg [ ] ) {

boolean estado = true ;

char caracter ;

// La siguiente línea genera error.

caracter = estado ;

System.out.println ( caracter ) ;
}
}

Observación: No se puede almacenar un valor lógico (boolean) en una variable caracter

(char).

Como se mencionó, solo se puede almacenar un solo valor en una variable y ese valor
debe ser del tipo de dato con el que la variable fue declarada. Pero como toda regla,
esta también tiene su excepción, y la excepción para estos casos se denomina
conversión de datos.

A través de la conversión de datos se puede almacenar en una variable valores de tipo

diferente al tipo de dato con el que se declaró la variable. La conversión de datos es un
tema propio de los lenguajes de programación y se aplica generalmente sobre los tipos
de datos numéricos, aunque también se puede aplicar sobre el tipo de dato
CARACTER.

Conversión implícita de datos en Java:

La conversión implícita de datos se da entre un tipo de dato de menor precisión a un tipo

de dato de mayor precisión (mas amplio, mas grande) y son generadas
automáticamente por el compilador Java.

A continuación se muestra los tipos de datos numéricos ubicados desde el tipo de dato
de menor precisión al tipo de dato de mayor precisión:

byte, short, int, long, float y double

Pag. 8
Problema 159

Clase PrgTipoDato04

package dominioDeLaAplicacion ;

class PrgTipoDato04 {
public static void main ( String arg [ ] ) {

int numEntero = 5 ;
long numEnteroGrande ;

// La siguiente línea no genera error.

numEnteroGrande = numEntero ;

// Se visualiza 5
System.out.println ( numEnteroGrande ) ;
}
}

Observación: Al ejecutar esta aplicación el compilador utiliza la conversión implícita y

convierte un número entero (int) en un número entero largo (long). Esto es válido ya que el
tipo de dato long en Java es de mayor precisión que el tipo de dato int.

Problema 160

Clase PrgTipoDato05

package dominioDeLaAplicacion ;

class PrgTipoDato05 {
public static void main ( String arg [ ] ) {

char caracter = ‘a’ ;

double numReal ;

// La siguiente línea no genera error.

numReal = caracter ;

// Se visualiza 97.0
System.out.println ( numReal ) ;
}
}

Observación: Al ejecutar esta aplicación el compilador utiliza la conversión implícita y

convierte la letra ‘a’ en un valor real (double) equivalente a su código ASCII, por lo que se
visualiza 97.0 (la letra a en código ASCII es 97).

Pag. 9
La conversión implícita de datos se realiza al mezclar variables de distinto
tipo en expresiones matemáticas o al ejecutar instrucciones o sentencias de
asignación. En ambos casos, es necesario que el lado izquierdo de la
expresión tenga un tipo de dato más amplio que el resultado de evaluar el
lado derecho:

numReal = numEntero + 5 ;

Lado izquierdo
de la expresión

En caso contrario, si el lado derecho de la expresión tiene un tipo de dato

más amplio que el lado izquierdo, al momento de compilar, el programa
indicará un error.

La conversión implícita de datos en Java, se da de un tipo de dato de menor

precisión a uno de mayor precisión.

Conversión explicita de datos en Java (casting):

Las conversiones de un tipo de dato de mayor precisón a otro tipo de dato

de menor precisión requieren que se coloque en forma explicita en los
programas. Estás conversiones son inseguras y puedan dar lugar a errores.
Este tipo de conversión de datos se le denomina también cast (casting). El
cast se realiza colocando entre paréntesis el tipo de dato al que se desea
convertir el resultado de una expresión.

Problema 161

Pag. 10
 Clase PrgTipoDato06

package dominioDeLaAplicacion ;

class PrgTipoDato06 {
public static void main ( String arg [ ] ) {
double num1 = 20, num2 = 3 ;
int div ;

// La siguiente línea genera error.

div = num1 / num2 ;

System.out.println ( div ) ;
}
}

Problema 162

Clase PrgTipoDato07

package dominioDeLaAplicacion ;

class PrgTipoDato07 {
public static void main ( String arg [ ] ) {
double num1 = 20, num2 = 3 ;

int div ;

// La siguiente línea no genera error.

div = ( int ) ( num1 / num2 ) ;

// Se visualiza 6.
System.out.println ( div ) ;
}
}

Observación: Al ejecutar esta aplicación el compilador utiliza la conversión explícita (casting)

para poder almacenar el resultado de una división de numeros reales (double) en una
variable entera (int).

Las Clases Wrappers tratadas a continuación permiten envolver los tipos de datos
simples y realizar operaciones de conversión, entre otras.

Pag. 11
ENVOLTORIOS DE LOS TIPOS DE DATOS PRIMITIVOS: CLASES WRAPPERS

INTRODUCCIÓN

Los tipos de datos primitivos (boolean, byte, char, double, float, int, long,
short), conocidos también como tipos de datos simples, son los únicos
elementos del lenguaje de programación Java que se representan internamente
a través de valores, tal y como se representan en un lenguaje de programación
convencional. Esto significa que los tipos de datos primitivos no son objetos y se
sitúan fuera de la jerarquía de clases 7 de Java. Esto tiene algunas ventajas
desde el punto de vista de la eficiencia.

En ocasiones, interesa sacrificar parte de la eficiencia por flexibilidad, por lo que

en Java se han creado clases que permiten integrar los tipos de datos primitivos
o simples dentro de la jerarquía de clases. Dichas clases son conocidas como
las clases wrappers (envoltorios). Los wrappers son clases diseñadas para ser
un complemento de los tipos de datos primitivos y proporcionan métodos para
realizar diferentes tareas con los tipos de datos primitivos, tales como la
conversión con cadenas de caracteres, comprobación, traslación, entre otras.

Existe una clase wrapper para cada uno de los tipos de datos primitivos, que
permiten tratarlos como objetos. Dichas clases se muestran a continuación:

TIPO DE DATO CLASES

PRIMITIVO WRAPPERS

boolean Boolean

byte Byte

char Character

double Double

float Float

int Integer

7
Jerarquía de clases: Forma de ordenar las clases.
La jerarquía de clases es una forma de ordenar las clases existentes en un lenguaje de Programación
Orientado a Objetos (POO). Una jerarquía de clases define conceptos abstractos en la parte superior de la
jerarquía y conforme se desciende en la jerarquía los conceptos se tornan cada vez más concretos. Java tiene
su propia jerarquía de clases, estando en la parte superior de la jerarquía, la clase Object (esta clase
pertenece al paquete java.lang).

Pag. 12
 TIPO DE DATO CLASES
PRIMITIVO WRAPPERS

Long Long

Short Short

Cada uno de estas clases wrappers (a excepción de Character), tienen un

método que permite convertir desde una cadena (String) al tipo primitivo.
Simplemente hay que ejecutar el método de la clase wrappers adecuada y el
String se convierte al tipo de dato primitivo asociado.

JERARQUÍA DE CLASES Y HERENCIA

java.lang.Object

java.lang.Boolean java.lang.Character java.lang.Number

Byte Double Float Integer Long Short

Las clases Java, en general, tienen métodos estáticos y métodos de instancia.

Para ejecutar un método de instancia es necesario crear un objeto de la clase
donde está definido dicho método. Para crear un objeto en Java se usa la
sentencia new (a excepción de los objetos de algunas clases, como los objetos
de la clase String que no necesariamente se crean con dicha sentencia).

Por ejemplo, para crear un objeto de la clase Integer

utilizamos:

int i = 5;
Integer I = new Integer ( i );

Donde el objeto I, es un objeto de la clase Integer, que

tiene un valor igual a 5 y métodos para manipular dicho
valor.

Pag. 13
MÉTODOS

Con la finalidad de resumir los métodos de las clases wrappers que permiten la
conversión, comprobación y traslación de datos, se utilizarán algunos objetos de
dichas clases. Se asume que los objetos han sido creados previamente. Dichos
objetos son:

CLASE AL QUE
OBJETO
PERTENECE

S String

I Integer

L Long

F Float

D Double

C Character

También se utilizarán algunas variables para lo cual se deberá asumir que

dichas variables han sido declaradas previamente. Las variables son:

TIPO DE DATO
VARIABLE
PRIMITIVO

i int

l long

f float

d double

b boolean

c char

Para referirnos a objetos se utilizará una letra en mayúscula, mientras que, para
referirnos a las variables se utilizará una letra minúscula.

Pag. 14
Conversión de tipo de dato primitivo a objeto String

Se puede convertir el valor de un tipo de dato primitivo o simple, a un valor de

tipo cadena contenido en un objeto String. Para realizar esta conversión, se
puede utilizar clases wrappers y variables, o utilizar objetos de las clases
wrappers. Esto depende si se tiene disponible la variable (con el tipo de dato
primitivo) o el objeto de la clase wrapper (que contiene el valor).

Conversión de tipo de dato primitivo a objeto String utilizando

clases wrappers y variables:

CLASES WRAPPERS Y
OBJETO STRING
VARIABLES

S = Integer.toString (i ) ;

S = Long.toString ( l ) ;

S = Float.toString ( f ) ;

S = Double.toString ( d ) ;

Observe que se utiliza el método toString ( ) para convertir el valor de una

variable a un valor de tipo cadena contenido en un objeto String. El método
toString ( ) es un método estático o de clase por que se utiliza directamente el
nombre de la clase para ejecutar el método.

Conversión de tipo de dato primitivo a objeto String utilizando

objetos wrappers:

OBJETO STRING OBJETOS WRAPPERS

S = I.toString ( ) ;

S = L.toString ( ) ;

S = F.toString ( ) ;

S = D.toString ( ) ;

Observe que se utiliza el método toString ( ) para convertir el valor contenido

en el objeto wrappers a un valor de tipo cadena contenido en un objeto String.
A pesar que el método toString ( ) es un método estático o de clase, también
puede ejecutarse utilizando un objeto.

Pag. 15
Todas las clases wrappers tienen en común el método estático o de clase
toString ( ). Esto se debe, a que este método no pertenece a dichas clases, sino
que pertenece a la clase Object.

La clase Object es la clase principal en la Jerarquía de Clases de Java (se

puede decir que es la clase padre de todas las clases). Todas las clases en Java
pueden utilizar los métodos definidos en la clase Object (debido
fundamentalmente a la herencia), y uno de los métodos definidos en esta clase,
como ya se ha mencionado, es el método toString ( ).
|

Conversión de objetos String a tipo de dato primitivo

Se puede convertir un objeto String a un tipo de dato primitivo, siempre y cuando

el objeto String contenga un dato equivalente al tipo de dato primitivo que se
desea convertir.

Conversión de objetos String a tipos de dato primitivo,

utilizando clases wrappers y objeto String:

VARIABLE WRAPPERS Y OBJETO STRING

Integer.valueOf (S) ;
i =
Integer.parseInt (S) ;
Long.valueOf (S) ;
l =
Long.parseLong (S) ;
Float.valueOf (S) ;
f =
Float.parseFloat (S) ;
Double.valueOf (S) ;
d =
Double.parseDouble (S) ;

Observe que se utiliza el método valueOf ( ) para convertir el valor contenido

en el objeto String S, a un dato de tipo primitivo o valor de una variable. Este
método es un método estático o de clase. También se tiene la posibilidad de
utilizar los métodos parseInt ( ), parseLong ( ), parseFloat ( ) y parseDouble ( )
para los wrappers Integer, Long, Float y Double respectivamente.

Pag. 16
Conversión de objetos wrappers a tipos de datos primitivos

Se puede convertir un valor de tipo cadena contenido en un objeto String a un

valor de un tipo de dato primitivo o simple, siempre y cuando el objeto String
contenga un valor equivalente al valor del tipo de dato primitivo que se desea
convertir.

Conversión de objetos wrappers a tipos de dato primitivo,

utilizando clases wrappers:

VARIABLE CLASES WRAPPERS

I.intValue ( ) ;
L.intValue ( ) ;
i =
F.intValue ( ) ;
D.intValue ( ) ;

I.longValue ( ) ;
L.longValue ( ) ;
l =
F.longValue ( ) ;
D.longValue ( ) ;

I.floatValue ( ) ;
L.floatValue ( ) ;
f =
F.floatValue ( ) ;
D.floatValue ( ) ;

I.doubleValue ( ) ;
L.doubleValue ( ) ;
d =
F.doubleValue ( ) ;
D.doubleValue ( ) ;

Observe que todas las clases wrappers tienen en común los métodos de
instancia intValue ( ), longValue ( ), floatValue ( ) y doubleValue ( ).

Todas las clases wrappers tienen en común los métodos de instancia intValue( ),
longValue( ), floatValue( ) y doubleValue( ). Estos métodos pertenecen en
realidad a la clase Number.

La clase Number es la superclase de las clases wrappers (a excepción de la

clase wrapper Character). Estas clases pueden utilizar los métodos definidos en
la clase Number a través de la herencia.

Pag. 17
Comprobaciones del valor Not-a-Number

Comprobación del valor Not-a-Number utilizando clases

wrappers y variables:

CLASES WRAPPERS Y
VARIABLE
VARIABLES
Float.isNaN ( f ) ;
b =
Double.isNaN ( d );

Comprobación del valor Not-a-Number utilizando clases

wrappers y variables:

VARIABLE OBJETOS WRAPPERS

F.isNaN ( ) ;
b =
D.isNaN ( );

Observe que se utiliza el método isNaN ( ) para determinar si la variable es o

no un número. El método devuelve true si el valor de la variable no es un
número.
Los valores Not-a-Number proceden de indeterminaciones tales como por
ejemplo el resultado de la siguiente operación: 0.0 / 0.0.

Comprobaciones del valor infinito

Comprobación del valor infinito utilizando clases wrappers y

variables:

CLASES WRAPPERS Y
VARIABLE
VARIABLES
Float.isInfinite ( f ) ;
b =
Double.isInfinite ( d );

Pag. 18
 Comprobación del valor infinito utilizando objetos wrappers:

VARIABLE OBJETOS WRAPPERS

F.isInfinite ( ) ;
b =
D.isInfinite ( );

Observe que se utiliza el método isInfinite ( ) para determinar si la variable es o

no un número infinito. El método devuelve true si el valor de la variable es un
número infinito.
Los valores Infinite proceden normalmente de la división por cero de un valor
finito. Por ejemplo el resultado de la siguiente operación: 10.5 / 0.0.

Comprobaciones de caracteres

Comprobación de caracteres utilizando la clase Character y

variable tipo char:

VARIABLE CLASE Character Y VARIABLE char

“Devuelve true si el
Character.isLowerCase (c) ; caracter es una
letra minúscula”.

“Devuelve true si el
Character.isUpperCase (c) ; caracter es una
letra mayúscula”.
b =
“Devuelve true si el
Character.isDigit (c) ; caracter es un
dígito decimal”.

“Devuelve true si el
Character.isSpace (c) ; caracter es un
espacio en blanco”.

Pag. 19
Traslación de caracteres

Traslación de caracteres utilizando la clase Character y

variable tipo char:

VARIABLE CLASE Character y VARIABLE char

“Convierte el
Character.toLowerCase (c); caracter a una letra
minúscula”.
c =
“Convierte el
Character.toUpperCase (c); caracter a una letra
mayúscula”.

Pag. 20
Problema 163

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita convertir valores de diferentes tipos

de datos en valores de tipo cadena.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgConvertirAString

package dominioDeLaAplicacion ;

class PrgConvertirAString {

public static void main ( String arg [ ] ) {

boolean estado = true;

char letra = ‘z’;
int numEntero = 10;
long numEnteroLargo = 100000000;
float numReal = 15.5f;
double numRealDoble = 10000.98;

String cadena = “ ”;

cadena = String.valueOf ( estado ) ;

System.out.println ( “ Tipo boolean en String: ” + cadena ) ;
cadena = String.valueOf ( letra ) ;
System.out.println ( “ Tipo char en String: ” + cadena ) ;
cadena = String.valueOf ( numEntero ) ;
System.out.println ( “ Tipo int en String: ” + cadena ) ;
cadena = String.valueOf ( numEnteroLargo ) ;
System.out.println( “ Tipo long en String: ” + cadena ) ;
cadena = String.valueOf ( numReal ) ;
System.out.println ( “ Tipo float en String: ” + cadena ) ;
cadena = String.valueOf ( numRealDoble ) ;
System.out.println ( “ Tipo double en String: ” + cadena ) ;
}
}

Observe que es posible convertir cualquier tipo de dato a cadena (String) utilizando el método valueOf
( ) de la clase String. En ciertas ocasiones esto es necesario ya que las cadenas pueden ser
manipuladas. Analice como se pueden manipular las variables de tipo cadena (String) más adelante en
este mismo capítulo.

Pag. 21
Problema 164

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita obtener la fecha del sistema y la

convierta en un valor de tipo cadena.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgConvertirFecha

package dominioDeLaAplicacion ;

import java.util.Date ;
class PrgConvertirFecha {

public static void main ( String arg [ ] ) {

Date hoy = new Date() ;

String cadena = “ ”;

cadena = hoy.toString ( ) ;
System.out.println ( “ Fecha: ” + cadena ) ;
}
}

La clase Date, es una clase propia de Java y está incluida en el paquete java.util. En este paquete
podrá encontrar clases de utilidad para sus aplicaciones. Este paquete está fuera del alcance del
presente texto (sugiero que investigue las clases que forman parte de este paquete).

El ejecutar esta aplicación se visualizará algo parecido a lo siguiente:

Fecha: Sat Mar 20 11:38:46 GMT-05:00 2004.

Observe como se convierte la fecha almacenada en un objeto (llamado hoy) de la clase Date en una
cadena (String) utilizando el método toString ( ) de la clase String. Esta cadena de texto podrá ser
manipulada para obtener otros datos, tales como, el día, el mes, el año actual o la hora del sistema.
Analice como se pueden manipular las variables de tipo cadena (String) más adelante en este mismo
capítulo.

Pag. 22
Problema 165

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita convertir una cadena en un número

entero y en un objeto de tipo Integer. Calcular y mostrar la suma de ambos
valores.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgCadenaAEntero

package dominioDeLaAplicacion ;

class PrgCadenaAEntero {

public static void main ( String arg [ ] ) {

int numEntero = 0 ;
String cadena = “10" ;

numEntero = Integer.parseInt ( cadena ) ;

Integer objInteger = Integer.valueOf ( cadena ) ;

System.out.println ( “ Valores enteros: ” + numEntero + “ " + objInteger ) ;

System.out.println ( “ La suma es: ” + (numEntero + objInteger.intValue ( ) ) ) ;

}
}

Observe que es posible convertir una cadena (String) en un valor entero (int) o en un objeto de la clase
Integer. Recuerde, que deberá asegurarse que la cadena contenga un valor válido para que pueda ser
almacenado en un tipo de dato determinado.

Puede utilizar el método parseInt ( ) de la clase String para convertir una cadena en un número entero
(numEntero) y también el método valueOf ( ) de la clase Integer para convertir una cadena en un un
objeto (objInteger) de la clase Integer. El método intValue ( ) nos permite obtener el valor entero del
objeto (objInteger) de la clase Integer.

Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice
una variable long y la clase Long.

Pag. 23
Problema 166

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita convertir una cadena en un número

real y en un objeto de tipo Double. Calcular y mostrar la suma de ambos valores.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgCadenaAReal

package dominioDeLaAplicacion ;

class PrgCadenaAReal {

public static void main ( String arg [ ] ) {

double numRealDoble = 0 ;
String cadena = “10.5” ;

numRealDoble = Double.parseDouble ( cadena ) ;

Double objDouble = Double.valueOf ( cadena ) ;

System.out.println ( “ Valores enteros: ” + numRealDoble + “ ” + objDouble ) ;

System.out.print ( “ La suma es: ” ) ;
System.out.println ( numRealDoble + objDouble.doubleValue ( ) ) ;

}
}

Observe que es posible convertir una cadena (String) en un valor entero (double) o en un objeto de la
clase Double. Recuerde, que deberá asegurarse que la cadena contenga un valor válido para que
pueda ser almacenado en un tipo de dato determinado.

Puede utilizar el método parseDouble ( ) de la clase Double para convertir una cadena en un número
real (numRealDoble) y también el método valueOf ( ) de la clase Double para convertir una cadena en
un un objeto (objDouble) de la clase Double. El método doubleValue ( ) nos permite obtener el valor
real del objeto (objDouble) de la clase Double.

Como sugerencia desarrolle un programa en Java que realice lo mismo que este programa pero utilice
una variable float y la clase Float.

Pag. 24
Pag. 25
FUNCIONES MATEMÁTICAS: CLASE MATH

INTRODUCCIÓN

La clase Math, es una clase que viene incorporada en el lenguaje de

programación Java, incluida en el paquete java.lang, la cual nos proporciona
métodos y atributos, para implementar diversas funciones mátemáticas.

JERARQUÍA DE CLASES Y HERENCIA

java.lang.Object

java.lang.Math

El paquete java.lang es el paquete principal del lenguaje Java por lo cual no se

necesita importar ninguna clase incluida en dicho paquete. En consecuencia, no
será necesario importar el paquete java.lang cada vez que se necesite utilizar la
clase Math de Java.

La clase Math contiene métodos de cálculo básico, como exponencial, logaritmo,

raiz cuadrada y funciones trigonométricas. La clase Math a diferencia de otras
clases es una clase final8. Esto significa que no puede ser instanciada (es decir;
no se pueden crear objetos de la clase Math). Los métodos de la clase Math son
métodos estáticos (llamados también métodos de clase) y para poder utilizarlos
solo se debe colocar el nombre de la clase, el operador punto y el nombre del
método a utilizar.

Ejemplo:
Math.pow (a, b) ;

8
Clase Final: No puede ser una superclase.
Una clase final o declarada como final es una clase que no puede ser una superclase. Es decir, las clases
finales no pueden heredarse. Todos los métodos de una clase final son implícitamente finales.

Pag. 26
MÉTODOS

La clase Math presenta los siguientes atributos y métodos de clase:

Atributos de clase:
1. E.
2. PI.

Métodos de clase:

1. abs( ).
2. acos( ).
3. asin( ).
4. atan( ).
5. ceil( ).
6. cos( ).
7. exp( ).
8. floor( ).
9. log( ).
10. max( ).
11. min( ).
12. pow( ).
13. random( ).
14. round( ).
15. sin( ).
16. sqrt( ).
17. tan( ).
18. toDegrees( ).
19. toRadians( ).

Para trabajar con los métodos de clase, de la clase Math, no será necesario
crear previamente un objeto de dicha clase (esto se cumple para todas las
clases que implementen métodos de clase).

Para ejecutar un método de clase, de la clase Math, es necesario colocar la

palabra Math (que es el nombre de la clase), el operador punto (.) y el nombre
del método de clase que desea ejecutar.

Asimismo; para ejecutar un método de la clase Math debemos tener en cuenta

que si, el método necesita algunos datos, estos deben ser necesariamente
proporcionados en la cantidad y tipos requeridos. En caso que el método
devuelva un resultado deberá almacenarlo en una variable del mismo tipo que el
resultado proporcionado o mostrarlo a través de la pantalla.

Pag. 27
A continuación se presenta una breve descripción del uso de cada uno de los
métodos de la clase Math:

CLASE Math

ATRIBUTOS DE
DESCRIPCIÓN USO
CLASE
double e = Math.E ;
Almacena el valor de E. Es decir, nos
System.out.print( e) ;
proporciona la base de un logaritmo
E
natural. El valor es equivalente a
Resultado:
2.718281828459045.
e = 2.718281828459045.

double pi = Math.PI ;
Almacena el valor de PI. Es decir, System.out.print( pi) ;
PI almacena el valor equivalente a
3.141592653589793. Resultado:
pi = 3.141592653589793.

MÉTODOS DE
DESCRIPCIÓN USO
CLASE

abs (float)

int x = -5 ;
abs (double)
Retorna el valor absoluto de un System.out.print( Math.abs( x)) ;
número (que puede ser float, double,
int, long) dado como parámetro. Resultado:
abs (int) x = 5.

abs (long)

double angulo = 45.0 * Math.PI/180.0;

double result ;
Retorna un valor double con el result = Math.acos( angulo ) ;
arcocoseno de un ángulo expresado System.out.print( result ) ;
acos (double) en radianes. El ángulo expresado en
radianes debe ser un valor double Resultado :
enviado al método como parámetro.
result = 0.6674572160283838

double angulo = 45.0 * Math.PI/180.0 ;

Retorna un valor double con el double result ;
arcoseno de un ángulo expresado en result = Math.asin( angulo ) ;
System.out.print( result ) ;
asin (double) radianes. El ángulo expresado en
radianes debe ser un valor double Resultado :
enviado al método como parámetro.
result = 0.9033391107665127

Pag. 28
 MÉTODOS DE
DESCRIPCIÓN USO
CLASE

double angulo = 45.0 * Math.PI/180.0 ;

Retorna un valor double con el double result ;
arcotangente de un ángulo expresado result = Math.atan( angulo ) ;
en radianes. El ángulo expresado en System.out.print( result ) ;
atan (double)
radianes debe ser un valor double
Resultado :
enviado al método como parámetro.
result = 0.6657737500283538

double n = 0.65 , result ;

Retorna un valor double con el valor result = Math.ceil( n ) ;
más corto no menor que el parámetro System.out.print( result ) ;
ceil (double)
dado. El parámetro dado debe ser
double. Resultado:

result = 1.0

double angulo = 30.0 * Math.PI/180.0 ;

Retorna un valor double con el coseno double result ;
de un ángulo expresado en radianes. result = Math.cos( angulo ) ;
cos (double) El ángulo expresado en radianes debe System.out.println( result ) ;
ser un valor double enviado al método Resultado :
como parámetro.
result = 0.8660254037844387

double exponente=1.0 , result ;

result = Math.exp(exponente) ;
Retorna un valor double con el valor
System.out.println(result) ;
exponencial de Euler del parámetro
exp (double)
dado. El parámetro dado sebe ser
Resultado:
double.
result = 2.7182818284590455

double n = 5.65 , result ;

result = Math.floor(n) ;
Retorna un valor double con el valor
System.out.print(result) ;
floor (double) más grande no mayor que el
parámetro dado. El parámetro dado Resultado:
debe ser double.
resutl = 5.0

double logaritmo = 3.0 , result ;

Retorna un valor double con el result = Math.log(logaritmo) ;
logaritmo natural (base e) de un System.out.println( result ) ;
log (double)
parámetro dado. El parámetro dado
Resultado:
sebe ser double.
result = 1.0986122886681096

Pag. 29
 MÉTODOS DE
DESCRIPCIÓN USO
CLASE

max (float, float)

double x = 10 , y = 15 , mayor ;
Retorna el valor del número mayor
mayor = Math.max( x , y ) ;
max (double, double) (que puede ser float, double, int, long)
System.out.print ( mayor ) ;
de dos números dados como
parámetros.
Resultado:
max (int, int)
mayor = 15.

max (long, long)

min (float, float)

double x = 10 , y = 15 , menor ;
menor = Math.min( x , y ) ;
min (double, double) Retorna el valor del número menor System.out.print ( menor ) ;
(que puede ser float, double, int, long)
de dos números dados como Resultado:
min (int, int) parámetros.
menor = 10.

min (long, long)

double x = 2 , y = 4 , result ;
Retorna un valor double con la result = Math.pow( x , y ) ;
potencia de un número (dado como System.out.print ( result ) ;
primer parámetro) elevado a otro
pow (double, double)
número (dado como segundo Resultado:
parámetro). Los dos parámetros
dados deben ser double. result = 16.

Retorna un valor double con un double num ;

número generado aleatoriamente (al num = Math.random( ) ;
random ()
azar) mayor o igual que 0.0 y menor System.out.print ( num ) ;
que 1.0.

round (float)

double x = 10.53 , result ;

Retorna un valor (que puede ser float result = Math.round( x ) ;
o double) con el valor redondeado del System.out.print ( result ) ;
parámetro dado. El parámetro dado
puede ser un valor float o double. Resultado:
round (double)
result = 11.

Pag. 30
 MÉTODOS DE
DESCRIPCIÓN USO
CLASE

double angulo = 37.0 *

Retorna un valor double con el seno
Math.PI/180.0; double result ;
de un ángulo expresado en radianes.
result = Math.sin(angulo) ;
sin (double) El ángulo expresado en radianes debe System.out.println(result) ;
ser un valor double enviado al método
como parámetro.
Resultado:

result = 0.6018150231520483

double x = 16 , result ;
Retorna un valor double con la raiz result = Math.sqrt( x ) ;
System.out.print ( result ) ;
cuadrada del parámetro dado. El
sqrt (double)
parámetro dado debe ser un valor
double. Resultado:

result = 4.

double angulo = 53.0 * Math.PI/180.0 ;

Retorna un valor double con la double result ;
tangente de un ángulo expresado en result = Math.tan(angulo);
tan (double) radianes. El ángulo expresado en System.out.println( result ) ;
radianes debe ser un valor double Resultado:
enviado al método como parámetro.
result = 1.3270448216204098

double angulo = Math.PI/3, result ;

Retorna un valor double. Permite result = Math.toDegrees(angulo) ;
convertir un ángulo expresado en System.out.println(result) ;
toDegrees (double) radianes (enviado como parámetro
double) en un ángulo expresado en Resultado:
sexagesimal.
result = 59.99999999999999

double angulo = 60, result ;

Retorna un valor double. Permite result = Math.toRadians(angulo) ;
convertir un ángulo expresado en System.out.println( result ) ;
toRadians (double) sexadecimal (enviado como parámetro
double) en un ángulo expresado en Resultado:
radianes.
result = 1.0471975511965976

A continuación, con la finalidad de mejorar la comprensión del tema tratado, se

presentan algunas soluciones a problemas planteados utilizando algunos de los
métodos de la clase Math. Analice cada una de las siguientes soluciones.

Pag. 31
Problema 167

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar 3 números enteros a través

del teclado. Determinar y mostrar cuál de ellos es el número mayor.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumeroMayor

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumeroMayor {

public static void main ( String arg [ ] ) {

int num1, num2, num3, resultado ;

System.out.println ( “ Ingresar el primer número: ” ) ;

num1 = Lectura.leerInt( ) ;

System.out.println ( “ Ingresar el segundo número: ” ) ;

num2 = Lectura.leerInt( ) ;

System.out.println ( “ Ingresar el tercer número: ” ) ;

num3 = Lectura.leerInt( ) ;

resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ;

System.out.println ( “ El número mayor es: ” + resultado ) ;

}
}

¿Que hay de nuevo en la codificación?

Observe el uso del método max ( ) de la clase Math:

Math.max ( num2, num3 )

Parámetros.

Nombre del método.

Operador punto.

Nombre de la Clase.

Pag. 32
El método max ( ) nos permite determinar el número mayor entre dos números (en nuestro caso el
número mayor entre num2 y num3).

Observe que en esta solución se emplea una estrategia mas simple para determinar el número mayor
entre tres números. El método max ( ) de la clase Math, retorna el valor del número mayor (puede ser
un número float, double, int o long) de dos números dados como parámetros. En nuestro ejemplo
determinamos el mayor de los dos últimos números ingresados y en la misma línea de código
evaluamos el mayor de estos dos números con el primer número ingresado, tal y como se muestra a
continuación:

resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ;

Es importante tener presente que el método max ( ) es un método que solo podemos utilizar con la
clase Math y su función es determinar el número mayor entre dos números dados como parámetros.

Pag. 33
Problema 168

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar 3 números enteros a través

del teclado. Determinar y mostrar cuál de ellos es el número menor.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumeroMenor

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumeroMenor {

public static void main ( String arg [ ] ) {

int num1, num2, num3, resultado ;

System.out.println ( “ Ingresar el primer número: ” ) ;

num1 = Lectura.leerInt( ) ;

System.out.println ( “Ingresar el segundo número: ” ) ;

num2 = Lectura.leerInt( ) ;

System.out.println ( “Ingresar el tercer número: ” ) ;

num3 = Lectura.leerInt( ) ;

resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ;

System.out.println ( “ El número menor es: " + resultado ) ;

}
}

¿Que hay de nuevo en la codificación?

Observe el uso del método min ( ) de la clase Math: En la codificación de esta solución se emplea una
nueva estrategia para hallar el menor de tres números ingresados por teclado (anteriormente se
utilizaban sentencias if anidadas).

Observe que Math.min ( ) retorna el valor del número menor (que puede ser float, double, int, long) de
dos números dados como parámetros. En nuestro ejemplo hallamos el menor de los dos últimos
números ingresados, y en la misma línea evaluamos el menor de estos dos números con el primer
número ingresado, tal y como se muestra a continuación:

resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ;

Pag. 34
Problema 169

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita generar una cantidad determinada

de números aleatorios. Los números aleatorios generados deberán estar entre 1 y
6. Mostrar el número generado aleatoriamente y la suma de dichos números.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumerosAleatorios

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumerosAleatorios {

public static void main ( String arg [ ] ) {

int x, cant, num, suma=0 ;

System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ;

cant = Lectura.leerInt( ) ;

for ( x = 1; x <= cant; x++) {

num = 1 + (int) ( Math.random( ) * 6 ) ;

System.out.println ( “El número aleatorio generado es: ” + num ) ;

suma = suma + num ;

}

System.out.println ( “La suma de los números aleatorios es: ” + suma ) ;

}
}

¿Que hay de nuevo en la codificación?

Observe el uso del método random ( ) de la clase Math:

num = 1 + (int) (Math.random ( ) * 6 ) ;

En la codificación de esta solución se utiliza una sentencia for con la finalidad de generar la cantidad
de números aleatorios (al azar) que el usuario desee. Cada vez que se ejecuta la sentencia for, se
genera y muestra un número aleatorio (un número entre 1 y 6), el cual es acumulado en la variable
suma. Finalizada la ejecución de la sentencia for se muestra el contenido de dicha variable (es decir,
se muestra la suma de los números aleatorios generados).

Pag. 35
Recuerde que para generar números aleatorios entre dos números (entre un intervalo o rango),
utilizando el método random ( ) de la clase Math, se emplea la siguiente fórmula:

min + (int) ( Math.random( ) * (max – min + 1 ) ) ;

Para nuestro ejemplo tenemos:

1 + (int) ( Math.random( ) * ( 6 – 1 + 1 ) ) ;

1 + (int) ( Math.random( ) * ( 6 ) ) ;

Pag. 36
Problema 170

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita generar una cantidad determinada

de números aleatorios. Los números aleatorios generados deberán estar entre 1 y
10. Mostrar los números aleatorios que son números pares.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumAleatoriosPares

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumAleatoriosPares {

public static void main ( String arg [ ] ) {

int x, cant, num, cont = 0 ;

System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ;

cant = Lectura.leerInt( ) ;

do {
num = 1 + (int) ( Math.random( ) * 10 ) ;

if (num % 2 == 0) {
cont++;
System.out.print ( num + “ \t ” ) ;
}

} while (cant != cont) ;

}
}

¿Que hay de nuevo en la codificación?

En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números
aleatorios. Si el número generado es par se le aumenta uno a la variable cont (que esta trabajando
como contador de números pares generados al azar) y se muestra el número generado.

Pag. 37
Problema 171

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita generar una cantidad determinada

de números aleatorios. Los números aleatorios generados deberán estar entre 1 y
10. Mostrar los números aleatorios que son números impares.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumAleatoriosImpares

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumAleatoriosImpares {

public static void main ( String arg [ ] ) {

int x, cant, num, cont = 0 ;

System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ;

cant = Lectura.leerInt( ) ;

do {
num = 1 + (int) ( Math.random( ) * 10 ) ;

if ( num % 2 == 1 ) {
cont ++;
System.out.print ( num + “ \t ” ) ;
}

} while ( cant != cont ) ;

}
}

¿Que hay de nuevo en la codificación?

En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números
aleatorios. Si el número generado es impar se le aumenta uno a la variable cont (que esta trabajando
como contador de números impares generados al azar) y se muestra el número generado.

Pag. 38
Problema 172

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar por teclado el radio de una
esfera. Calcular y mostrar el volumen de dicha esfera.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgRadioEsfera

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgRadioEsfera {

public static void main ( String arg [ ] ) {

double radio, volume ;

System.out.println ( “Ingresar el radio de la esfera: ” ) ;

radio = Lectura.leerDouble();

volume = (4 / 3) * Math.PI * Math.pow ( radio, 3 ) ;

System.out.println ( “El volumen de la esfera es: ” + volume ) ;

}
}

¿Que hay de nuevo en la codificación?

Observe el uso del método pow ( ) y del atributo PI de la clase Math:

volume = (4 / 3) * Math.PI * Math.pow ( radio, 3 ) ;

El método pow ( ) retorna un valor double con la potencia de un número (dado como primer parámetro)
elevado a otro número (dado como segundo parámetro). En nuestro caso el método pow ( ) eleva a la
potencia 3 el radio del círculo.

Para hallar el volumen de la esfera se tendrá que utilizar la fórmula v=4/3*PI*R 3. La clase Math define
un atributo (constante) muy útil, que contiene en valor del número PI (Math.PI).

Pag. 39
Problema 173

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar un número decimal.

Mostrar el número ingresado redondeado.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumRedondeado

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumRedondeado {

public static void main ( String arg [ ] ) {

double num, resultado ;

System.out.println ( “Ingrese un número decimal: ” ) ;

num = Lectura.leerDouble( ) ;

resultado = Math.round(num) ;

System.out.println ( “El número redondeado es: ” + resultado ) ;

}
}

¿Que hay de nuevo en la codificación?

Observe el uso del método round ( ) de la clase Math:

resultado = Math.round(num) ;

El método round ( ) permite redondear un número dado como parámetro.

En esta solución se ingresa un número y se almacena en la variable num. Luego, dicho número es
redondeado utilizando el método round ( ) y se almacena en la variable resultado.

Pag. 40
Problema 174

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar un número entero y un

exponente. Mostrar el resultado de calcular la potencia de todos los números
menores que el número ingresado elevado al exponente ingresado.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumPotencia

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumPotencia {

public static void main ( String arg [ ] ) {

int cant, expo ;

double rpta ;

System.out.println ( “Ingresar un número entero: ” ) ;

cant = Lectura.leerInt( ) ;

System.out.println ( “Ingresar el exponente: ” ) ;

expo = Lectura.leerInt( ) ;

for ( int x = 1; x < cant; x++) {

rpta = Math.pow ( x, expo ) ;

System.out.println ( “El Exponencial de ” + x + “ es: ” + rpta ) ;
}
}
}

¿Que hay de nuevo en la codificación?

Observe el uso del método pow ( ) de la clase Math:

rpta = Math.pow ( x, expo ) ;

El método pow ( ) permite elevar a la potencia un número determinado. En la presente solución se

utiliza una sentencia for con la finalidad de elevar a la potencia todos los números menores que la
variable cant y mostrarlos por pantala. La variable cant y el exponente expo se ingresan por el teclado.

Recuerde y siempre tenga presente que el método pow ( ) de la clase Math, retorna un valor double,
por lo que dicho valor deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por
la pantalla.

Pag. 41
Problema 175

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar un número entero. Mostrar

el resultado de calcular la raíz cuadrada de todos los números menores que el
número ingresado.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumRaiz

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumRaiz {

public static void main ( String arg [ ] ) {

int cant ;
double rpta ;

System.out.println ( “Ingrese un número entero: ” ) ;

cant = Lectura.leerInt( ) ;

for ( int x = 1; x < cant; x++ ) {

rpta = Math.sqrt (x) ;

System.out.println ( “La raíz cuadrada de ” + x + “ es: ” + rpta ) ;
}
}
}

¿Que hay de nuevo en la codificación?

Observe el uso del método sqrt ( ) de la clase Math:

rpta = Math.sqrt ( x ) ;

El método sqrt ( ) permite obtener la raíz cuadrada de un número determinado.

En la presente solución se utiliza una sentencia for con la finalidad de obtener la raíz cuadrada de
todos los números menores que la variable cant y mostrarlos por pantalla. La variable cant se ingresa
por el teclado.

Recuerde y siempre tenga presente que el método sqrt ( ) de la clase Math, retorno un valor double,
por lo que dicho valor deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por
la pantalla.

Pag. 42
Problema 176

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita generar una cantidad determinada

de números aleatorios. Los números aleatorios generados deberán estar entre 1 y
10. Mostrar los números generados aleatoriamente elevados al cuadrado.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumAleatorioCuad

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgNumAleatorioCuad {

public static void main ( String arg [ ] ) {

int cant, num ;

double rpta ;

System.out.print ( “Ingresar la cantidad de números aleatorios a generar: ” ) ;

cant = Lectura.leerInt( ) ;

for ( int x = 1; x <= cant; x++ ) {

num = (int) ( 1 + ( Math.random() * 10 ) ) ;

rpta = Math.pow (num, 2) ;
System.out.println ( num + “ elevado al cuadrado es: ” + rpta ) ;
}
}
}

¿Que hay de nuevo en la codificación?

Observe el uso de los métodos random ( ) y sqrt ( ) de la clase Math:

num = (int) ( 1 + ( Math.random() * 10 ) ) ;

rpta = Math.pow (num, 2) ;

En la presente solución se utiliza una sentencia for con la finalidad de obtener números aleatorios,
elevarlos al cuadrado y mostrarlos por pantalla. La variable cant se ingresa por el teclado.

Pag. 43
Problema 177

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita determinar y mostrar el área de un

tríangulo en base a las longitudes de sus lados. Considerar el valor absoluto de la
diferencia entre el semiperimetro y cada uno de los lados. Utilizar las siguientes
fórmulas:
area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2).
p = (a+b+c) / 2.
Donde:
p = Semiperímetro.
a, b, c = Lados del triángulo.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgTriangulo

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgTriangulo {

public static void main ( String arg [ ] ) {

double a, b, c, p, tmp, area ;

System.out.println ( “Ingrese el valor del primer lado del triángulo (a): ” ) ;

a = Lectura.leerDouble( ) ;

System.out.println ( “Ingrese el valor del segundo lado del triángulo (b): ” ) ;

b = Lectura.leerDouble( ) ;

System.out.println ( “Ingrese el valor del terecr lado del triángulo (c): ” ) ;

c = Lectura.leerDouble( ) ;

p = (a + b + c) / 2 ;
tmp = ( p * (Math.abs(p - a)) * (Math.abs(p - c)) * (Math.abs(p - b) ) ) ;
area = Math.sqrt ( tmp ) ;

System.out.println ( “El área del triángulo es: ” + area ) ;

}
}

¿Que hay de nuevo en la codificación?

Pag. 44
Observe el uso de los métodos abs ( ) y sqrt ( ) de la clase Math:

tmp = ( p * (Math.abs(p - a)) * (Math.abs(p - c)) * (Math.abs(p - b) ) ) ;

area = Math.sqrt ( tmp ) ;

En esta solución se ingresan los valores de los tres lados de un triángulo y se obtiene el valor del
semiperímetro del triángulo.

Luego, se procede a calcular el área del triángulo en base a la siguiente fórmula:

area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2)

Primero, se hace uso del método abs ( ) de la clase Math para calcular el valor absoluto de la
diferencia entre el semiperímetro y cada uno de los lados del triángulo. Luego, se multiplican los
valores resultantes con el valor del semiperímetro del triángulo y finalmente, se obtiene la raíz
cuadrada del valor resultante utilizando el método sqrt ( ) de la clase Math.

Pag. 45
Problema 178

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita determinar y mostrar el perímetro y

el área de un círculo. Utilizar las siguientes fórmulas:

perimetro = 2 * PI * radio.
area = PI * radio * radio.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgCirculo

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgCirculo {

public static void main ( String arg [ ] ) {

double radioCirculo, areaCirculo, perimetroCirculo ;

System.out.println ( “ Ingrese el valor del radio del círculo: ” ) ;

radioCirculo = Lectura.leerDouble( ) ;

areaCirculo = Math.PI * Math.pow (radioCirculo, 2) ;

perimetroCirculo = 2 * Math.PI * radioCirculo ;

System.out.println ( “ El área del círculo es: ” + areaCirculo ) ;

System.out.println ( “ El perímetro del círculo es : ” + perimetroCirculo ) ;
}
}

Pag. 46
Problema 179

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar un ángulo expresado en

grados. Deeterminar el tipo de ángulo ingresado y su equivalente en radianes. Los
ángulos expresados en grados se clasifican de la siguiente manera:
0 grados. = Nulo.
Entre 0 y 90 grados. = Agudo.
90 grados. = Recto.
Entre 90 y 180 grados. = Obtuso.
180 grados. = Llano.
Entre 180 grados y 360 grados. = Cóncavo.
360 grados. = Completo.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgConversionAngulo

package dominioDeLaAplicacion ;
import biblioteca.Lectura ;
class PrgConversionAngulo {
public static void main ( String arg [ ] ) {
double anguloGrados, anguloRadianes ;
String tipoAngulo = “” ;

System.out.println ( “ Ingrese un ángulo en grados (entre 0 y 360): ” ) ;

anguloGrados = Lectura.leerDouble( ) ;
if (anguloGrados == 0)
tipoAngulo = “Nulo” ;
if (anguloGrados > 0 && anguloGrados < 90)
tipoAngulo = “Agudo” ;
if (anguloGrados == 90)
tipoAngulo = “Recto” ;
if (anguloGrados > 90 && anguloGrados < 180)
tipoAngulo = “Obtuso” ;
if (anguloGrados == 180)
tipoAngulo = “Llano” ;
if (anguloGrados > 180 && anguloGrados < 360)
tipoAngulo = “Concavo” ;
if (anguloGrados == 360)
tipoAngulo = “Completo” ;
anguloRadianes = Math.toRadians (anguloGrados) ;
System.out.println ( “ Tipo de ángulo: ” + tipoAngulo ) ;
System.out.println ( “ Ángulo expresado en radianes: ” + anguloRadianes ) ;
}
}

Pag. 47
¿Que hay de nuevo en la codificación?

Observe el uso del método toRadians ( ) de la clase Math:

anguloRadianes = Math.toRadians (anguloGrados) ;

Para el desarrollo de esta solución se hace uso de sentencias if múltiples con la finalidad de
determinar el tipo de ángulo ingresado por teclado. El tipo de ángulo es almacenado en una variable
String (tipoAngulo) y mostrado por pantalla.

Para realizar la conversión del ángulo ingresado en el sistema sexagesimal al sistema radial se utiliza
el método toRadians ( ) de la clase Math.

Pag. 48
Problema 180

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita determinar y mostrar las raíces de

una ecuación de segundo grado. Tipo:
Ax2 + Bx + C = 0

Considerar que la solución puede tener raíces imaginarias. Utilizar la siguiente

fórmula:

x = ( - B + - ( ( B ** 2 – 4 * A * C ) RAIZ ( 2 ) ) ) / 2 * A.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgEcuacion2Grado

package dominioDeLaAplicacion ;
import biblioteca.Lectura ;
class PrgEcuacion2Grado {
public static void main ( String arg [ ] ) {
int a, b, c ;
double tmp, x, x1, x2 ;
System.out.println ( “ Ingrese el coeficiente A: ” ) ;
a = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el coeficiente B: ” ) ;
b = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el coeficiente C: ” ) ;
c = Lectura.leerInt( ) ;
if (a == 0 && b == 0) {
System.out.println ( “ La ecuación no tiene solución ” ) ;
} else {
tmp = Math.pow (b, 2) - (4 * a * c) ;
if (tmp < 0) {
System.out.println ( “ La ecuación tiene raices imaginarias ” ) ;
} else {
if (a == 0) {
x = c / b * (-1) ;
System.out.println ( “ El valor para x es: ” + x ) ;
} else {
x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ;
x2 = ( - b - Math.sqrt (tmp)) / (2 * a) ;
System.out.println ( “ El primer valor para x es: ” + x1 ) ;
System.out.println ( “ El segundo valor para x es: ” + x2 ) ;
}
}
}
}
}

Pag. 49
¿Que hay de nuevo en la codificación?

Observe el uso de los métodos pow ( ) y sqrt ( ) de la clase Math:

En esta solución se ingresan los coeficientes de una ecuación de segundo grado (a, b y c). Si los
coeficientes a y b son iguales a cero, se muestra un mensaje por la pantalla; “La ecuación no tiene
solución”. Caso contrario, se determina el valor de la discriminante, el cual se almacena en la variable
tmp utilizando la siguiente formula:

tmp = Math.pow (b, 2) - (4 * a * c) ;

En caso que el valor de tmp sea igual a cero, se muestra el siguiente mensaje por pantalla; “La
ecuación tiene raices imaginarias”. Caso contrario, si el coeficiente a es igual a cero la ecuación
tendría una sola solución, la cual se calcularía utilizando:

x = c / b * (-1) ;

Si el coeficiente a es diferente de cero la ecuación tendría dos soluciones, las cuales se calcularían
utilizando:

x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ;
x2 = ( - b - Math.sqrt (tmp)) / (2 * a) ;

Pag. 50
Problema 181

Etapa 01 - Descripción del problema.

Desarrollar un juego en Java que permita generar un número aleatorio. Se debe

intentar adivinar que número es el que generó la computadora. El rango de
números válidos en el juego es de 1 a 100, y cada vez que intente adivinar le
indicará si el número buscado es menor o es mayor.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgJuego

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgJuego {
public static void main ( String arg [ ] ) {
int maximo = 100, num, numAzar, inten = 1 ;
double tmp;
System.out.println ( “ Bienvenido al juego: ¿Que número es? ” ) ;
System.out.println ( “ ----------------------------------------------------” ) ;
System.out.println ( “ - La computadora genera un -” ) ;
System.out.println ( “ - numero aleatorio y ud. tratara -” ) ;
System.out.println ( “ - de adivinar que número es -” ) ;
System.out.println ( “ - Trate de adivinar el número en -” ) ;
System.out.println ( “ - el menor número de intentos -” ) ;
do {
System.out.println ( “ Ingrese un número entre 0..100: ” ) ;
num = Lectura.leerInt( ) ;
} while (num < 0 || num > 100 ) ;
tmp = maximo * Math.random( ) ;
numAzar = (int) Math.round(tmp) ;
while (num != numAzar) {
inten++ ;
if (num < numAzar)
System.out.println ( “ El número buscado es mayor ” ) ;
else
System.out.println ( “ El número buscado es menor ” ) ;
do {
System.out.println ( “ Ingrese otro número entre 0..100: ” ) ;
num = Lectura.leerInt( ) ;
} while (num < 0 || num > 100) ;
}
System.out.println ( “ Ud. encontró el número en: ” + inten + “ intento(s) ” ) ;
}
}

Pag. 51
¿Qué hay de nuevo en la codificación?

Observe el uso de los métodos random ( ) y round ( ) de la clase Math:

Utilizando el método random ( ) generamos un número aleatorio (al azar) entre el número 0 y el
número 100, utilizando la siguiente fórmula:

tmp = maximo * Math.random( ) ;

El número generado aleatoriamente es almacenado en la varable tmp. Luego es redondeado utilizando

el método round ( ) y convertido a un número entero utilizando la siguiente sentencia:

numAzar = (int) Math.round(tmp) ;

Este número generado al azar, almacenado en la variable numAzar, es comparado con un número
previamente ingresado por teclado y almacenado en la variable num. Si ambos son iguales, se
mostrará un mensaje indicando que el número numAzar fue encontrado. Si no son iguales, se
mostrará un mensaje, indicando si el número buscado es mayor o es menor (en relación al número
ingresado) y se solicitará otro número hasta encontrar el número que se generó en forma aleatoria.

Intente modificar la codificación de la solución. Utilice la sentencia do y optimice el código.

Pag. 52
Problema 182

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar 6 números a traves del

teclado. Determinar y mostrar cuál de ellos es el número mayor y cuál es el
número menor.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumeroMayorMenor

package dominioDeLaAplicacion ;
import biblioteca.Lectura ;
class PrgNumeroMayorMenor {
public static void main ( String arg [ ] ) {
int n1, n2, n3, n4, n5, n6 ;
double mayor, meno r;
System.out.println ( “ Ingrese el primer número: ” ) ;
n1 = Lectura.leerInt();
System.out.println ( “ Ingrese el segundo número: ” ) ;
n2 = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el tercer número: ” ) ;
n3 = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el cuarto número: ” ) ;
n4 = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el quinto número: ” ) ;
n5 = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el sexto número: ” ) ;
n6 = Lectura.leerInt( ) ;
mayor = Math.max (n1,n2) ;
mayor = Math.max (mayor,n3) ;
mayor = Math.max (mayor,n4) ;
mayor = Math.max (mayor,n5) ;
mayor = Math.max (mayor,n6) ;
menor = Math.min (n1,n2) ;
menor = Math.min (menor,n3) ;
menor = Math.min (menor,n4) ;
menor = Math.min (menor,n5) ;
menor = Math.min (menor,n6) ;
System.out.println ( “ El mayor número es: " + mayor ) ;
System.out.println ( “ El menor número es: " + menor ) ;
}
}

Modificar la codificación de la solución de tal forma que pueda optimizar el código. Utilice una
sentencia for.

Pag. 53
Pag. 54
Problema 183

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar las notas de todos los
alumnos de un determinado salon de clase. Calcular y mostrar el promedio final de
cada alumno en base a la siguiente fórmula:

pf = ( pp + ep + ( ef * 2 ) ) / 4.
Donde:
pf = Promedio final.
pp = Promedio de prácticas.
Son 4 prácticas de las cuales se elimina la más baja
pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3
ep = Examen parcial.
ef = Examen final.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgPromedioNotas

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgPromedioNotas {

public static void main ( String arg [ ] ) {

double pf, pp, ep, ef, p1, p2, p3, p4, notaMenor ;
char opc ;

do {

System.out.println ( “ Ingrese la nota de la práctica 1: ” ) ;

p1 = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la nota de la práctica 2: ” ) ;
p2 = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la nota de la práctica 3: ” ) ;
p3 = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la nota de la práctica 4: ” ) ;
p4 = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la nota del examen parcial: ” ) ;
ep = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la nota del examen final: ” ) ;
ef = Lectura.leerDouble( ) ;

notaMenor = Math.min (p1,p2) ;

notaMenor = Math.min (notaMenor,p3) ;
notaMenor = Math.min (notaMenor,p4) ;

Pag. 55
Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgPromedioNotas

pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3 ;

pf = ( pp + ep + ef ) / 3 ;
pf = Math.round (pf) ;

System.out.println ( “ El promedio final del alumno es: ” + pf ) ;

System.out.println ( “ Desea continuar (si=s/ no=n)?: ” ) ;

opc=Lectura.leerChar( ) ;

} while ( opc=='s' || opc=='S' ) ;

}
}

Modificar la codificación de la solución de tal forma que se elimine la práctica con la nota más baja y se
duplique la nota de la práctica más alta. Muestre el promedio de las notas redondeado a dos
decimales.

Pag. 56
Problema 184

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar un número cualquiera con

parte decimal y muestre la parte entera del número, el número redondeado sin
decimales, y el número redondeado a uno, dos y tres decimales.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgRedondearNumero

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgRedondearNumero {

public static void main ( String arg [ ] ) {

double numero ;

System.out.println ( “ Ingrese un número con decimales: ” ) ;

numero=Lectura.leerDouble( ) ;

System.out.println ( “ -----------------------------------” ) ;
System.out.println ( “ La parte entera del número es: ” ) ;
System.out.println ( Math.floor (numero) ) ;

System.out.println ( “ El número redondeado es: ” ) ;

System.out.println ( Math.floor (numero+0.5) ) ;

System.out.println ( “ El número redondeado a un decimal es: ” ) ;

System.out.println ( Math.floor (numero * 10 + 0.5 ) / 10 ) ;

System.out.println ( “ El número redondeado a dos decimales es: ” ) ;

System.out.println ( Math.floor (numero * 100 + 0.5 ) / 100 ) ;

System.out.println ( “ El número redondeado a tres decimales es: ” ) ;

System.out.println ( Math.floor (numero * 1000 + 0.5 ) / 1000 ) ;
}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método floor ( ) de la clase Math:

El método floor ( ) retorna un valor double con el valor más grande no mayor que el parámetro dado. El
parámetro dado debe ser double. Nótese que si ingresamos un numero cuya parte decimal es mayor
que 5 sólo retorna la parte entera para tal caso se le agrega 0.5 para que en el segundo cálculo tenga
efecto de redondeo perfecto. Observe como se redondea un número con uno, dos y tres decimales
utilizando el método floor ( ).

Pag. 57
Problema 185

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permite realizar un sorteo en base a un

número determinado de boletos.

Sugerencia:
Utilice el método random ( ) de la clase Math para
generar el número del boleto ganador.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgSorteo

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgSorteo {

public static void main ( String arg [ ] ) {

double num ;
int boletos, ganador ;

do {

System.out.println ( “ Ingrese el total de boletos: ” ) ;

boletos = Lectura.leerInt( ) ;

if (boletos > 0) {

do {

num = boletos * Math.random( ) ;

ganador = (int) Math.round(num) ;

} while (ganador == 0) ;

System.out.println ( “ El número ganador es: ” + ganador ) ;

}

} while ( boletos < 0 ) ;

}
}

Pag. 58
Problema 186

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita calcular la suma de cuadrados y la

suma de cubos de los “n” primeros números. Se deberá ingresar un número por
teclado y mostrar los resultados.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgSumaCuadradosCubos

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgSumaCuadradosCubos {

public static void main ( String arg [ ] ) {

long num, sumaCuad = 0, sumaCubos = 0 ;

System.out.println ( “ Ingrese un numero cualquiera: ” ) ;

num = Lectura.leerLong( ) ;

for ( int i=1; i <= num; i++ ) {

sumaCuad += Math.pow (i,2) ;

sumaCubos += Math.pow (i,3) ;

System.out.print ( “ La suma de cuadrados de 1 hasta ” + num + “ es: ” ) ;

System.out.println ( sumaCuad ) ;

System.out.print ( “ La suma de cubos de 1 hasta ” + num + “ es: ” ) ;

System.out.println ( sumaCubos ) ;
}
}

Pag. 59
Problema 187

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar un ángulo no mayor de 360

grados ni menor de 0 grados. Mostrar como resultado el seno y el coseno del
ángulo ingresado.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgSenCos

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgSenCos {

public static void main ( String arg [ ] ) {

double anguloGrados, anguloRadianes, seno = 0, coseno = 0 ;

do{

System.out.println ( “ Ingrese un ángulo en grados entre 0 y 360: ” ) ;

anguloGrados = Lectura.leerDouble( ) ;

if (anguloGrados < 0 || anguloGrados > 360 ){

System.out.println ( “El dato ingresado es incorrecto, intente otra vez: ” );

}

}while(anguloGrados < 0 || anguloGrados > 360) ;

anguloRadianes = Math.toRadians( anguloGrados ) ;

seno = Math.sin( anguloRadianes ) ;

coseno = Math.cos( anguloRadianes ) ;

System.out.println ( “ El sen [” + anguloGrados + “ ] = ” + seno ) ;

System.out.println ( “ y el cos [” + anguloGrados + “ ] = ” + coseno ) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso de los métodos toRadians ( ), sin ( ) y cos ( ) de la clase Math:

Es importante mencionar que Java trabaja con el sistema radial y para obtener las razones
trigonométricas, seno y coseno, de un ángulo ingresado por teclado hay que convertirlo primero al

Pag. 60
sistema radial. Para esto, utilizamos el método toRadians ( ) de la clase Math. Este método retorna un
valor double y permite convertir un ángulo expresado en el sistema sexagesimal (enviado como
parámetro double) en un ángulo expresado en radianes. Una vez convertido el ángulo en radianes
podemos utilizar los métodos sin ( ) y cos ( ) de la clase Math para obtener el seno y el coseno del
ángulo ingresado por teclado.

Pag. 61
Problema 188

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar un ángulo de inclinación de

la recta con respecto al eje x. Mostrar como resultado la pendiente de la recta.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgTangente

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgTangente {

public static void main ( String arg [ ] ) {

double anguloGrados, anguloRadianes, tangente = 0 ;

System.out.println ( “ Ingrese el ángulo de inclinación de la recta: ” ) ;

anguloGrados = Lectura.leerDouble( ) ;

anguloRadianes = Math.toRadians(anguloGrados) ;

tangente = Math.tan(anguloRadianes) ;
System.out.println ( “ La pendiente de la resta es = ” + tangente ) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método tan ( ) de la clase Math:

El método tan ( ) permite hallar la pendiente de una recta con respecto al eje X. Para ello, utiliza el
ángulo de inclinación de la recta, expresado en el sistema radial, tal y como se muestra:

tangente = Math.tan(anguloRadianes) ;

Pag. 62
Problema 189

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar los catetos de un triángulo

perpendicular. Calcular y mostrar la hipotenusa del tríangulo.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgHipotenusa

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgHipotenusa {

public static void main ( String arg [ ] ) {

double cateto1, cateto2, hipotenusa ;

System.out.println ( “ Ingrese el primer cateto: ” ) ;

cateto1 = Lectura.leerDouble( ) ;

System.out.println ( “ Ingrese el segundo cateto: ”) ;

cateto2 = Lectura.leerDouble( ) ;

hipotenusa = Math.sqrt ( Math.pow (cateto1, 2) + Math.pow (cateto2, 2) ) ;

System.out.println ( “ La hipotenusa del triángulo es: ” + hipotenusa) ;

}
}

La fórmula para este caso sería: (hipotenusa)2 = (cateto1)2 + (cateto2)2 . Se ingresan los catetos por el
teclado y son elevados al cuadrado con Math.pow ( ). El resultado obtenido, al elevar al cuadrado cada
uno de los catetos, se suman. Luego se obtiene la raíz cuadrada con Math.sqrt ( ) y finalmente se
muestra el resultado almacenado en la variable hipotenusa. Ejemplo:

Ingrese el primer cateto: 2

Ingrese el segundo cateto: 3

La hipotenusa del triángulo es: 3.605551275463989

Pag. 63
Problema 190

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar la ordenada y la abscisa de

un punto. Calcular y mostrar el ángulo de las coordenadas del punto en grados.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgPunto

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgPunto {

public static void main ( String arg [ ] ) {

double ordenada, abscisa, anguloGrados, anguloRadianes ;

System.out.println ( “ Ingrese la ordenada(y) del punto: ” ) ;

ordenada = Lectura.leerDouble( ) ;

System.out.println ( “ Ingrese la abscisa(x) del punto: ” ) ;

abscisa = Lectura.leerDouble( ) ;

anguloRadianes = Math.atan2(ordenada, abscisa) ;

anguloGrados = Math.toDegrees(anguloRadianes) ;

System.out.print ( “ El ángulo en grados de [” + ordenada + “,” ) ;

System.out.println ( abscisa + “] es: ” + anguloGrados) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso de los métodos atan2 ( ) y toDegress ( ) de la clase Math:

anguloRadianes = Math.atan2(ordenada, abscisa) ;

anguloGrados = Math.toDegrees(anguloRadianes) ;

Sabemos que Math.atan ( ) retorna un valor double con el arcotangente de un ángulo expresado en
radianes. Dicho ángulo expresado en radianes debe ser un valor double enviado al método como
parámetro.

Pag. 64
Pero en este caso, se ingresan por teclado la ordenada y la abcisa de un punto cualquiera en el
sistema de coordenadas, por lo que el método atan ( ) de la clase Math no nos serviría (este método
necesita el valor de un ángulo expresado en radianes y no los valores de las coordenadas de un
punto).

En este caso, se utiliza el método atan2 ( ) de la clase Math. Este método nos permite obtener el valor
del arcotangente de un par ordenado.

Es importante mencionar que el método atan2 ( ) nos devuelve el arcotangente de un ángulo

expresado en radianes por lo cual se tendrá que convertir dicho ángulo al sistema sexagesimal,
utilizando el método toDegrees ( ) de la clase Math.

Pag. 65
Problema 191

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar un número cualquiera.

Calcular y mostrar el número e elevado al número ingresado y el logaritmo natural
(de base e) del número ingresado.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgExpLog

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgExpLog {

public static void main ( String arg [ ] ) {

double num, exponencial, logaritmo ;

System.out.println ( “ Ingrese un número: ” ) ;

num=Lectura.leerDouble();

exponencial = Math.exp(num) ;
logaritmo = Math.log(num) ;

System.out.print ( “ El valor del número [e] elevado a [” + num ) ;

System.out.println ( “] es: ” + exponencial ) ;

System.out.print ( “ El valor del logaritmo [en base e] del número [” ) ;

System.out.println ( num + “] es: ” + logaritmo) ;
}
}

¿Qué hay de nuevo en la codificación?

Observe el uso de los métodos exp ( ) y log ( ) de la clase Math:

exponencial = Math.exp(num) ;
logaritmo = Math.log(num) ;

En esta solución se hace necesario el uso del método exp ( ) para obtener el número e elevado al
número ingresado por teclado:

enum

También se hace necesario el uso del método log ( ) para obtener el logaritmo natural del número
ingresado en base e:

Pag. 66
 logenum

Tenga presente que Java sólo resuelve logaritmos en base e y no en base 10.

A continuación se presentan algunas soluciones a problemas utilizando básicamente el

método random ( ) de la clase Math, desarrollados con la finalidad de mejorar su
comprensión del tema y sus capacidades lógicas.

Analizar cada uno de las soluciones y desarrolle sus propias conclusiones.

Pag. 67
Problema 192

Etapa 01 - Descripción del problema.

Un jugador lanza dos dados, cada uno de los cuales tiene 6 caras, las caras
contienen 1, 2, 3, 4 ,5 y 6 puntos. Una vez que los dados quedan en reposo, se
suman los puntos de las dos caras que quedan hacia arriba. Si la suma es 7 o 11
en el primer lanzamiento, el jugador gana. Si la suma es 2, 3 o 12 en el primer
lanzamiento (resultado que en los casinos reciben el nombre de “craps”), el
jugador pierde (es decir, la casa gana). Si la suma es 4, 5, 6, 8, 9, 10 en el primer
lanzamiento, esto suma se convierte en el punto del jugador. Para ganar, el
jugador debe seguir tirando los dados hasta “lograr su punto”. El jugador perderá
si tira un 7 antes de lograr su punto.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgLanzarDados1

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgLanzarDados1 {

public static void main ( String arg [ ] ) {

double n1, n2, n3, nf ;

int dado1 = 0, dado2 = 0, suma1 = 0, suma2 = 0, estado = 0 ;
String opc1 = “ ”, opc2 = “ ” ;

do {

System.out.println ( “Lanzar dados” ) ;

Lectura.leerString ( ) ;

dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

suma1 = dado1 + dado2 ;

System.out.println ( “Dado1 : ” + dado1 ) ;

System.out.println ( “Dado2 : ” + dado2 ) ;

if ( suma1 == 7 || suma1 == 11 ) {
opc1 = “s” ;
estado = 1 ;

Pag. 68
Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgLanzarDados1

} else
if ( suma1 == 2 || suma1 == 3 || suma1 == 12 ) {
opc1 = “s” ;
estado = 0 ;
} else {

do {
System.out.println ( “Lanzar dados” ) ;
Lectura.leerString ( ) ;

dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

suma2 = dado1 + dado2 ;

System.out.println ( “Dado1 : ” + dado1 ) ;

System.out.println ( “Dado2 : ” + dado2 ) ;

if ( suma1 == suma2 ) {
estado = 1 ;
opc1 = “s” ;
opc2 = “s” ;
} else
if ( suma2 == 7 ) {
estado = 0 ;
opc1 = “s” ;
opc2 = “s” ;
}

} while ( opc2 != “s” ) ;

}
}while ( opc1 != “s” ) ;

if ( estado == 1 )
System.out.println ( “El jugador gana” ) ;
else
System.out.println ( “El jugador pierde ” ) ;

}
}

Pag. 69
Problema 193

Etapa 01 - Descripción del problema.

Modificar el programa del problema anterior, de tal forma que se muestre un

mensaje preguntando si desea volver a tirar los dados.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgLanzarDados2

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgLanzarDados2 {

public static void main ( String arg [ ] ) {

int dado1 = 0, dado2 = 0, suma1 = 0, suma2 = 0, estado = 0 ;

String opc1 = “ ”, opc2 = “ ” ;
char opc3 = ‘n’ ;

do {
opc1 = “ ” ;
opc2 = “ ” ;

do {

System.out.println ( “Lanzar dados” ) ;

Lectura.leerString ( ) ;

dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

suma1 = dado1 + dado2 ;

System.out.println ( “Dado1 : ” + dado1 ) ;

System.out.println ( “Dado2 : ” + dado2 ) ;

if ( suma1 == 7 || suma1 == 11 ) {
opc1 = “s” ;
estado = 1 ;
} else
if (suma1 == 2 || suma1 == 3 || suma1 == 12) {
opc1 = “s” ;
estado = 0 ;
} else {

Pag. 70
Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgLanzarDados2

do {
System.out.println ( “Lanzar dados” ) ;
Lectura.leerString ( ) ;

dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

dado2 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

suma2 = dado1 + dado2 ;

System.out.println ( “Dado1 : ” + dado1 ) ;

System.out.println ( “Dado2 : ” + dado2 ) ;

if ( suma1 == suma2 ) {
estado = 1 ;
opc1 = “s” ;
opc2 = “s” ;
} else
if ( suma2 == 7 ) {
estado = 0 ;
opc1 = “s” ;
opc2 = “s” ;
}

} while ( opc2 != “s” ) ;

}
} while ( opc1 != “s” ) ;

if ( estado == 1 )
System.out.println ( “ El jugador gana ” ) ;
else
System.out.println ( “ El jugador pierde ” ) ;

System.out.println ( “Desea volver a jugar [s/n] ” ) ;

opc3 = Lectura.leerChar ( ) ;

} while ( opc3 != ‘n’ ) ;

}
}

Pag. 71
Problema 194

Etapa 01 - Descripción del problema.

Elaborar un programa que simule el lanzamiento de una moneda. Solicitar el

número de veces que se lanzará la moneda. Cuentar el número de veces que
aparece cada lado de la moneda. Mostrar los resultados.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgLanzarMoneda

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgLanzarMoneda {

public static void main ( String arg [ ] ) {

int moneda, cont1 = 0, cont2 = 0, cant ;

System.out.println ( “Cuántas veces desea Lanzar moneda ? ” ) ;

cant = Lectura.leerInt ( ) ;

for ( int x = 1; x <= cant; x++ ) {

moneda = ( int ) (1 + ( Math.random ( ) * 2 ) ) ;

if (moneda == 1)
cont1 ++ ;
else
cont2 ++ ;

System.out.println ( “La cantidad de veces que a salido la cara es : ” + cont1 ) ;

System.out.println ( “La cantidad de veces que a salido el sello es : ” + cont2 ) ;
}
}

Pag. 72
Problema 195

Etapa 01 - Descripción del problema.

Elaborar un programa que simule el juego de tragamonedas, los números son: 1,

2, 3, 4, 5 ,6 y 7 opciones de ganar. El jugador gana cuando el número se repita
tres veces. Los números deberán ser generados aleatoriamente. El premio mayor
se obtiene con el número 7.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgTragamoneda1

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgTragamoneda1 {

public static void main ( String arg [ ] ) {

int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0 ;

char s, opc1 ;

do {

System.out.println( “Presionar enter para empezar” ) ;

Lectura.leerString ( ) ;

valor1 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ;

valor2 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ;
valor3 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ;

System.out.println ( valor1 + “ ” + valor2 + “ ” + valor3 ) ;

if ( valor1 == valor2 && valor1 == valor3 ) {

s = (char) valor1 ;
switch (s) {
case 1 :
monto = 100 ;
break ;
case 2 :
monto = 200 ;
break ;
case 3 :
monto = 300 ;
break ;

Pag. 73
Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgTragamoneda1

case 4 :
monto = 400 ;
break ;
case 5 :
monto = 500 ;
break ;
case 6 :
monto = 600 ;
break ;
case 7 :
monto = 1000 ;
break ;
}
System.out.println ( “Usted gana : ” + monto + “Soles ” ) ;
} else
System.out.println ( “La casa gana” ) ;

monto = 0 ;
System.out.println ( “Desea volver a jugador [s/n] : ” ) ;
opc1 = Lectura.leerChar ( ) ;

} while ( opc1 != ‘n’ ) ;

}
}

Pag. 74
Problema 196

Etapa 01 - Descripción del problema.

Modificar el programa del problema anterior, de tal forma que se muestre la

cantidad acumulada del dinero ganado en el tragamoneda.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgTragamoneda2

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgTragamoneda2 {

public static void main ( String arg [ ] ) {

int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0, acumonto = 0 ;

char s,opc1 ;

do {

System.out.println ( “Presionar enter para empezar” ) ;

Lectura.leerString ( ) ;

valor1=( int ) (1 + ( Math.random ( ) * 7 ) ) ;

valor2=( int ) (1 + ( Math.random ( ) * 7 ) ) ;
valor3=( int ) (1 + ( Math.random ( ) * 7 ) ) ;

System.out.println ( valor1 + “ ” + valor2 + “ ” + valor3 ) ;

if ( valor1 == valor2 && valor1 == valor3 ) {

s= (char) valor1 ;
switch ( s ) {
case 1 :
monto=100 ;
break ;
case 2 :
monto=200 ;
break ;

Pag. 75
Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgTragamoneda2

case 3 :
monto=300 ;
break ;
case 4 :
monto=400 ;
break ;
case 5 :
monto=500 ;
break ;
case 6 :
monto=600 ;
break ;
case 7 :
monto=1000 ;
break ;
}

acumonto = acumonto + monto ;

System.out.println ( “Usted gana : ” + monto ) ;
System.out.println ( “El dinero acumulado ganado es : ” + acumonto ) ;

} else
System.out.println ( “La casa gana” ) ;

monto = 0 ;
System.out.println ( “Desea volver a jugador [s/n] : ” ) ;
opc1=Lectura.leerChar ( ) ;

} while ( opc1! = ‘n’ ) ;

}
}

Pag. 76
Problema 197

Etapa 01 - Descripción del problema.

Las computadoras están desempeñando un papel cada vez más importante en la

educación. Desarrolle un programa que ayude a un estudiante de primaria a
aprender a multiplicar. Utilice números aleatorios para producir dos enteros
positivos de un solo digito. El programa deberá preguntar ¿Cuánto es 6 por 7?, El
estudiante deberá ingresar la respuesta. El programa verificara si la respuesta es
correcta. Si es correcta mostrará un mensaje ¡Muy bien! y si es incorrecto
mostrará el mensaje ¡No es correcto, por favor intente otra vez!.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgMultiplicacion

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgMultiplicacion {

public static void main ( String arg [ ] ) {

int valor1 = 0, valor2 = 0, resul1 = 0, resul2 = 0 ;
char s, opc1 ;
do {
System.out.println ( “Aprendiendo a Multiplicar” ) ;
Lectura.leerString ( ) ;

valor1 = ( int ) (1 + ( Math.random() * 9 ) ) ;

valor2 = ( int ) (1 + ( Math.random() * 9 ) ) ;
resul1 = valor1 * valor2 ;

System.out.println ( “¿Cuánto es ” + valor1 + “ por ” + valor2 + “ ?” ) ;

System.out.println ( “Ingresar resultado de la multiplicación : ” ) ;
resul2 = Lectura.leerInt ( ) ;

if ( resul1 == resul2 )
System.out.println ( “Respuesta correcta… Muy bien” ) ;
else
System.out.println ( “No es la respuesta correcta… Vuelva a intentarlo” ) ;

System.out.println ( “Desea volver a intentarlo [s/n] : ” ) ;

opc1 = Lectura.leerChar ( ) ;

} while ( opc1 != ‘n’ ) ;

}
}

Pag. 77
Problema 198

Etapa 01 - Descripción del problema.

Modificar el programa del problema anterior, de tal forma que se muestre un menú
de opciones donde permita sumar, restar, multiplicar y dividir dos números
generados al azar. Se permitirá al estudiante contestar la misma pregunta una y
otra vez hasta que responda correctamente.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgMenuOperaciones1

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgMenuOperaciones1 {

public static void main ( String arg [ ] ) {

int valor1 = 0, valor2 = 0, resul1 = 0, resul2 = 0, op ;

String operacion = “ ” ;
char opc, signo = ‘ ’ ;

do {

System.out.println ( “Menú de operaciones” ) ;

System.out.println ( “-----------------------------” ) ;
System.out.println ( “[1] Sumar ”);
System.out.println ( “[2] Restar ”);
System.out.println ( “[3] Multiplicar ” ) ;
System.out.println ( “[4] Dividir ”);
System.out.println ( “[5] Salir ”);

System.out.println ( “Elegir opcion : ” ) ;

op=Lectura.leerInt ( ) ;

valor1=( int ) (1 + ( Math.random ( ) * 9 ) ) ;

valor2=( int ) (1 + ( Math.random ( ) * 9 ) ) ;
switch ( op ) {

case 1 :
resul1 = valor1 + valor2 ;
operacion = “Suma” ;
signo = ‘+’ ;
break ;

Pag. 78
Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgMenuOperaciones1

case 2 :
resul1 = valor1 - valor2 ;
operacion = “Resta” ;
signo = ‘-’ ;
break ;
case 3 :
resul1 = valor1 * valor2 ;
operacion = “Multiplicación” ;

signo = ‘*’ ;
break ;
case 4 :
resul1 = valor1 / valor2 ;
operacion = “División” ;

signo = ‘/’ ;
break ;
case 5 :
System.exit (0) ;
break ;
}

System.out.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 + “ ?” ) ;

do {

System.out.println ( “Ingresar resultado de la ” + operacion + “ :” ) ;

resul2 = Lectura.leerInt ( ) ;

if ( resul1 != resul2 )
System.out.println ( “No es, por favor trata otra vez” ) ;

} while ( resul1 != resul2 ) ;

System.out.println ( “Muy bien” ) ;

} while ( op != 5 ) ;
}
}

Pag. 79
Problema 199

Etapa 01 - Descripción del problema.

Modificar el programa del problema anterior, de tal forma que se muestre un menú
de opciones donde permita sumar, restar, multiplicar y dividir dos números al azar.
Mostrar la cantidad de preguntas correctas y la cantidad de preguntas incorrectas.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgMenuOperaciones2

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgMenuOperaciones2 {

public static void main ( String arg [ ] ) {

int valor1 = 0, valor2 = 0, resul1 = 0, resul2 = 0 ;

int op, cont1 = 0, cont2 = 0 ;
String operacion = “ ” ;
char opc, signo = ‘ ’ ;

do {

System.out.println ( “Menú de operaciones” ) ;

System.out.println ( “-----------------------------” ) ;
System.out.println ( “[1] Sumar ”);
System.out.println ( “[2] Restar ”);
System.out.println ( “[3] Multiplicar ” ) ;
System.out.println ( “[4] Dividir ”);
System.out.println ( “[5] Salir ”);

System.out.println ( “Elegir opcion : ” ) ;

op = Lectura.leerInt ( ) ;

valor1 = ( int ) (1 + ( Math.random ( ) * 9 ) ) ;

valor2 = ( int ) (1 + ( Math.random ( ) * 9 ) ) ;
switch ( op ) {

case 1 :
resul1 = valor1 + valor2 ;
operacion = “Suma” ;
signo = ‘+’ ;
break ;

Pag. 80
Continúa… Etapa 04 - Desarrollo de la Codificación.

Clase PrgMenuOperaciones2

case 2 :
resul1 = valor1 - valor2 ;
operacion = “Resta” ;
signo = ‘-’ ;
break ;
case 3 :
resul1 = valor1 * valor2 ;
operacion = “Multiplicación” ;
signo = ‘*’ ;
break ;
case 4 :
resul1 = valor1 / valor2 ;
operacion = “División” ;
signo = ‘/’ ;
break ;
case 5 :
System.exit (0) ;
break ;
}

System.out.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 + “ ?” ) ;

System.out.println ( “Ingresar resultado de la ” + operacion + “: ” ) ;

resul2 = Lectura.leerInt ( ) ;

if ( resul1 != resul2 ) {
System.out.println ( “No es, por favor trata otra vez” ) ;
cont1 ++ ;
} else {
System.out.println ( “Muy bien” ) ;
cont2 ++ ;
}

} while ( op != 5 ) ;

System.out.println ( “La cantidad de respuesta correctas fueron : ” + cont1 ) ;

System.out.println ( “La cantidad de respuestas incorrectas fueron : ” + cont2 ) ;

}
}

Pag. 81
Problema 200

Etapa 01 - Descripción del problema.

Elaborar un programa que permita adivinar cuál es el número entero generado al

azar entre 1 y 1000. El jugador ingresará una primera estimación, si la estimación
del jugador es incorrecta, el programa deberá indicar si el número ingresado fue
más grande o fué más pequeño que el número generado al azar. Cuando la
respuesta sea correcta se mostrará un mensaje de felicitaciones.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgAdivinarNumero1

package dominioDeLaAplicacion ;

import biblioteca.* ;

class PrgAdivinarNumero1 {

public static void main ( String arg [ ] ) {

int valor = 0, num = 0 ;

char opc = ‘ ’ ;
do {
System.out.println ( “Adivine el número” ) ;
valor = ( int ) (1 + ( Math.random ( ) * 1000 ) ) ;
do {
System.out.println ( “Ingresar número : ” ) ;
num = Lectura.leerInt ( ) ;
if ( num < valor )
System.out.println ( “El número es demasiado chico. Pruebe otra vez” ) ;
else
if ( num > valor )
System.out.println ( “El número es demasiado grande. Pruebe otra vez” ) ;
else
System.out.println ( “Felicidades adivinaste el número ” ) ;

} while (num != valor ) ;

System.out.println ( “Desea Continuar [s/n]: ” ) ;
opc = Lectura.leerChar ( ) ;

} while ( opc != ‘n’ ) ;

}
}

Pag. 82
Problema 201

Etapa 01 - Descripción del problema.

Modificar el programa del problema anterior, de tal forma que se pueda ingresar la
cantidad de intentos que se tiene para adivinar el número.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgAdivinarNumero2

package dominioDeLaAplicacion ;

Import biblioteca.* ;

class PrgAdivinarNumero2 {

public static void main ( String arg [ ] ) {

int valor = 0, num = 0, intentos, cont = 0 ;

char opc = ‘ ’ ;
do {
System.out.println ( “Adivine el número” ) ;
System.out.println ( “Ingrese la cantidad de intentos : ” ) ;
intentos=Lectura.leerInt ( ) ;
valor = ( int ) (1 + ( Math.random ( ) * 1000 ) ) ;

do {
System.out.println ( “Ingresar número : ” ) ;
num = Lectura.leerInt ( ) ;
if (cont >= intentos ) {
System.out.println ( “Deberías haberlo hecho mejor” ) ;
valor = num ;
}
else if ( num < valor )
System.out.println ( “El número es demasiado chico. Pruebe otra vez” ) ;

else if ( num > valor )

System.out.println ( “El número es demasiado grande. Pruebe otra vez ” ) ;
else
System.out.println ( “Felicidades adivinaste el número” ) ;
cont ++ ;
} while ( num != valor ) ;
System.out.println ( “Desea Continuar [s/n]: ” ) ;
opc=Lectura.leerChar ( ) ;
} while ( opc != ‘n’ ) ;
}
}

Pag. 83
Pag. 84
MANEJO DE CADENAS: CLASE STRING

INTRODUCCIÓN

Una cadena es un conjunto de caracteres, números y símbolos especiales

almacenados en una variable de tipo texto o cadena.

La clase String, es una clase que viene incorporada en el lenguaje de

programación Java, incluida en el paquete java.lang, la cual permite declarar y
manipular variables de tipo texto o cadena (en realidad no se declaran variables
de tipo texto o cadena, sino que se crean objetos de la clase String).

Ejemplo:
String nom = “Danae” ;

JERARQUÍA DE CLASES Y HERENCIA

java.lang.Object

java.lang.String

El paquete java.lang es el paquete principal del lenguaje Java por lo cual no se

necesita importar ninguna clase incluida en dicho paquete. En consecuencia, no
será necesario importar el paquete java.lang cada vez que se necesite utilizar la
clase String de Java.

La clase String permite manipular las variables de tipo texto o cadena a través
de los métodos que implementa (la clase String tiene métodos de instancia y
métodos de clase). La clase String incluye métodos que permiten examinar los
caracteres individuales de una cadena para compararlos, para ubicarlos, para
extraerlos como subcadenas, y para crear copias de una cadena convirtiendo
todos sus caracteres a letra mayúscula o minúscula.

Las conversiones son realizadas a través del método toString ( ), método

definido en la clase Object, el cual puede ser utilizado por todas las clases Java
a través de la herencia.

Pag. 85
MÉTODOS

La clase String presenta los siguientes métodos:

Métodos de instancia:

1. charAt( ).
2. compareTo( ).
3. concat( ).
4. endsWith( ).
5. equals( ).
6. equalsIgnoreCase( ).
7. indexOf( ).
8. lastIndexOf( ).
9. length( ).
10. matches( ).
11. replace( ).
12. split( ).
13. startsWith( ).
14. substring( ).
15. toCharArray( ).
16. toLowerCase( ).
17. trim( ).
18. toUpperCase( ).

Métodos de clase:
19. valueOf( ).

Para trabajar con los métodos de instancia de la clase String es necesario

previamente haber declarado y asignado un valor a una variable de tipo texto o
cadena. Para el caso de los métodos de clase esto no será necesario.

Para ejecutar un método de instancia de la clase String es necesario colocar el

nombre de la variable (que debe ser de tipo texto o cadena), el operador punto
(.) y el nombre del método de instancia que se desea ejecutar. Para el caso de
los métodos de clase deberá colocar la palabra String, el operador punto (.) y el
nombre del método de clase que se desea ejecutar.

Asimismo, para ejecutar cualquiera de los método de la clase String, se debe

tener en cuenta que si, el método necesita algunos datos, éstos deben ser
necesariamente proporcionados en la cantidad y tipos requeridos. En caso, que
el método devuelva un resultado, éste deberá almacenarse en una variable del
mismo tipo o mostrarse a través de la pantalla.

Pag. 86
A continuación se presenta una breve descripción del uso de cada uno de los
métodos de la clase String:

CLASE String

MÉTODOS DE
DESCRIPCIÓN USO
INSTANCIA

Devuelve el caracter que

encuentre en la posición indicada
String cad1 = “Hola Danae”;
por la variable entera o número
char x = cad1.charAt(5);
entero colocado como parámetro.
charAt(int)
Es importante mencionar que en
resultado:
Java, el primer caracter de una
x = ‘D’.
cadena se encuentra ubicado en la
posición 0 (cero).

Si la cadena es alfabéticamente
menor que la cadena colocada
como parámetro, el método String cad1 = “Hola Danae”;
devuelve un número entero menor String cad2 = “Hola Pedro”;
que cero. Si las dos cadenas son int x = cad1.compareTo(cad2);
compareTo(String)
alfabéticamente iguales devuelve
un número cero y si la cadena es Resultado:
alfabéticmente mayor que la x < 0 (cad1<cad2).
cadena colocada como parámetro,
el método devuelve un entero
mayor que cero.

String cad1, cad2, cadena;

cad1 = "Hola";
Este método permite juntar dos cad2 = " a todos";
concat(String) cadena = cad1.concat (cad2);
cadenas en una sola cadena.
Resultado :
cadena = "Hola a todos”

String cad1 = “Hola Danae”;

Devuelve true (verdadero) si el
String cad2 = “Danae”;
final de la cadena coincide con la
boolean x = cad1.endsWith(cad2);
endsWith(String) cadena colocada como parámetro.
Caso contrario devuelve false
Resultado:
(falso).
x = true.

String cad1 = “Danae”;

Devuelve true (verdadero) si la String cad2 = “Danae”;
cadena coincide con la cadena boolean x = cad1.equals(cad2);
equals(String)
colocada como parámetro. Caso
contrario devuelve false (falso). Resultado:
x = true.

Pag. 87
 MÉTODOS DE
DESCRIPCIÓN USO
INSTANCIA
String cad1 = “DANAE”;
Este método realiza la misma String cad2 = “Danae”;
función que el método equals ( ) boolean x;
equalsIgnoreCase(String) pero la comparación la realiza sin x = cad1.equalsIgnoreCase(cad2);
tener en cuenta las letras
minúscula y mayúscula. Resultado:
x = true.

String cad1 = “Hola Danae”;

int x = cad1.indexOf(‘D’);
indexOf(char)
Resultado:
x = 5.

String cad1 = “Hola Danae”;

int x = cad1.indexOf(‘a’,6);
indexOf(char,int) Devuelve la posición de la cadena
en la que aparece por primera vez Resultado:
el caracter colocado como x = 8.
parámetro.
También se puede especificar un
segundo parámetro a partir del String cad1 = “Hola Danae”;
cual se empieza a buscar hacia int x = cad1.indexOf( “ana” );
indexOf(String)
delante.
Resultado:
x = 6.

String cad1 = “Hola Danae”;

int x = cad1.indexOf( “Dan”,3 );
indexOf(String, int)
Resultado:
x = 5.

String cad1 = “Hola Danae”;

int x = cad1.lastIndexOf(‘a’);
lastIndexOf(char)
Resultado:
x = 8.
Devuelve la posición de la cadena
en la que aparece por última vez el String cad1 = “Hola Danae”;
caracter colocado como parámetro. int x = cad1.lastIndexOf(‘a’,5);
lastIndexOf(char,int) También se puede especificar un
segundo parámetro a partir del Resultado:
cual se empieza a buscar hacia x = 3.
atrás.
String cad1 = “Hola Danae”;
int x = cad1.lastIndexOf( “ana” );
lastIndexOf(String)
Resultado:
x = 8.

Pag. 88
 MÉTODOS DE
DESCRIPCIÓN USO
INSTANCIA
String cad1 = “Hola Danae”;
int x = cad1.lastIndexOf( “lo”,5 );
lastIndexOf(String,int)
Resultado:
x = 2.

String cad1 = “Hola Danae”;

Devuelve la longitud de una int x = cad1.length();
length() cadena. Es decir, el número de
caracteres que tiene la cadena. Resultado:
x = 10.

String nom = "Rodrigo Jose" ;

boolean x ;
Permite determinar si una cadena x = nom.matches("[a-zA-Z ]*") ;
matches() contiene solo los caracteres que se
han definido en un determinado
rango. Devuelve un valor lógico. Resultado:
x = true.

Permite reemplazar todos los String cad1 = “Hola Danae”;

caracteres iguales al caracter String x = cad1.replace(‘a’, ‘o’);
replace(char,char) colocado como primer parámetro
con el caracter colocado como Resultado:
segundo parámetro. x = “Holo Donoe”.

String nombre = "Rodrigo José”;

String[] palabras ;
Permite separar una cadena en palabras = nombre.split(" ");
varias subcadenas en base al
spit () separador indicado. Las
subcadenas se almacenan en un
arreglo de cadenas. Resultado:
palabras[0] = “Rodrigo”
palabras[1] = “José”

String cad1 = “Hola Danae”;

Devuelve un valor true (verdadero) String cad2 = “Hola”;
si el comienzo de la cadena boolean x;
startsWith(String) coincide con la cadena colocada x = cad1.startsWith(cad2);
como parámetro, caso contrario
devuelve false (falso). Resultado:
x = true.

Devuelve una subcadena a partir String cad1 = “Hola Danae”;

de la cadena especificada, String x = cad1.substring(5);
substring(int) empezando desde la posición
indicada en el primer parámetro
hasta el final o hasta una posición Resultado:
anterior a la indicada en el x = “Danae”.

Pag. 89
 MÉTODOS DE
DESCRIPCIÓN USO
INSTANCIA
segundo parámetro del método.
String cad1 = “Hola Danae”;
String x = cad1.substring(6,9);
substring(int,int)
Resultado:
x = “ana”.

String cad1 = “Hola Danae”;

Convierte una cadena específica
char[ ] x = cad1.toCharArray();
en un vector de caracteres. (Los
toCharArray()
vectores serán tratados en el
Resultado:
capítulo IV).
x = {‘H’,‘o’,‘l’,‘a’,‘ ’, ‘D’, ‘a’, ‘n’, ‘a’,‘e’}.

String cad1 = “Hola Danae”;

String x = cad1.toLowerCase();
Convierte las letras de una cadena
toLowerCase()
en letras minúsculas.
Resultado:
x = “hola danae”.

String cad1 = “ Hola Danae ”;

Permite eliminar los espacios en String x = cad1.trim();
trim() blanco del inicio y del final de una
cadena. Resultado:
x = “Hola Danae”.

String cad1 = “Hola Danae”;

String x = cad1.toUpperCase();
Convierte las letras de una cadena
toUpperCase()
en letras mayúsculas.
Resultado:
x = “HOLA DANAE”.

MÉTODO DE CLASE DESCRIPCIÓN USO

String.valueOf(boolean)
String.valueOf(int) double pi = 3.1416;
String.valueOf(long) Método de clase que permite String x = String.valueOf(pi);
String.valueOf(float) convertir los valores de otros tipos
String.valueOf(double) de datos o variables a una cadena.
String.valueOf(Object) resultado:
String.valueOf(char[ ]) x = “3.1416”.
String.valueOf(char[ ], int,int)

A continuación, con la finalidad de mejorar la comprensión del tema tratado, se

presentan algunas soluciones a problemas planteados utilizando algunos de los
métodos de la clase String. Analice cada una de las siguientes soluciones.

Pag. 90
Problema 202

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de un alumno.

Mostrar el nombre del alumno en letras mayúscula.

Etapa 04 – Desarrollo de la codificación.

Clase PrgConvertirMayuscula

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgConvertirMayuscula {

public static void main(String [ ] args) {

String nom ;

System.out.print ( “ Ingresar el nombre: ” ) ;

nom = Lectura.leerString( ) ;

nom = nom.toUpperCase( ) ;

System.out.println ( “ El nombre en Mayúscula es: ” + nom ) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método toUpperCase ( ) de la clase String:

nom.toUpperCase ( ) ;
Nombre del método.

Operador punto.

Nombre de la variable
(objeto).

El método toUpperCase ( ) se utiliza con variables de tipo String y permite convertir en letras
mayúsculas el contenido de la variable que antecede al nombre del método y al operador punto (en
nuestro caso la variable nom). Como el método toUpperCase ( ) nos devuelve un valor de tipo String
(el contenido de la variable en letra mayúscula), podemos mostrar el resultado utilizando

Pag. 91
System.out.println o almacenarlo en una variable (que puede ser la variable que contenía la cadena
original), tal y como lo hemos realizado en nuestro ejemplo:

nom = nom.toUpperCase ( ) ;

Es importante tener presente que el método toUpperCase ( ) es un método que solo podemos utilizar
con variables de tipo String y su función es convertir el contenido de una variable en letras mayúscula.

Pag. 92
Problema 203

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de un alumno.

Mostrar el nombre del alumno en letras minúsculas.

Etapa 04 – Desarrollo de la codificación.

Clase PrgConvertirMinuscula

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgConvertirMinuscula {

public static void main(String [ ] args) {

String nom ;

System.out.print ( “ Ingresar el nombre: ” ) ;

nom = Lectura.leerString( ) ;

nom = nom.toLowerCase( ) ;

System.out.println ( “ El nombre en Minúscula es: ” + nom ) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método toLowerCase ( ) de la clase String:

nom.toLowerCase ( ) ;
Nombre del método.

Operador punto.

Nombre de la variable
(objeto).

El método toLowerCase ( ) se utiliza con variables de tipo String y permite convertir en letras
minúsculas el contenido de la variable que antecede al nombre del método y al operador punto (en
nuestro caso la variable nom). Como el método toLowerCase ( ) nos devuelve un valor de tipo String
(el contenido de la variable en letra minúscula), podemos mostrar el resultado utilizando

Pag. 93
System.out.println o almacenarlo en una variable (que puede ser la variable que contenía la cadena
original), tal y como lo hemos realizado en nuestro ejemplo:

nom = nom.toLowerCase ( ) ;

Es importante tener presente que el método toLowerCase ( ) es un método que solo podemos utilizar
con variables de tipo String y su función es convertir el contenido de una variable en letras minúscula.

Pag. 94
Problema 204

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el primer nombre y el

segundo nombre de un alumno. Concatenar y Mostrar los nombres del alumno en
letras mayúsculas y letra minúsculas.

Etapa 04 – Desarrollo de la codificación.

Clase PrgConcatenarNombres

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgConcatenarNombres {

public static void main(String [ ] args) {

String nom1, nom2, nombre, espacio = “ ” ;

System.out.println ( “ Ingresar el primer nombre del alumno: ” ) ;

nom1 = Lectura.leerString( ) ;

System.out.println ( “ Ingresar el segundo nombre del alumno: ” ) ;

nom2 = Lectura.leerString( ) ;

nom1 = nom1.concat(espacio) ;
nombre = nom1.concat(nom2) ;

System.out.println ( “ El nombre en Mayúscula es: ”" + nombre.toUpperCase() ) ;

System.out.println ( “ El nombre en Minúscula es: ” + nombre.toLowerCase() ) ;
}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método concat ( ) de la clase String:

nom = nom.concat (espacio) ;

El método concat ( ) se utiliza para juntar o concatenar el contenido de dos variables de tipo String (la
misma función cumple el signo “+ “cuando trabaja con variables de tipo String).
Es decir, el contenido de la variable nom1 y el contenido de la variable espacio se juntan (o
concatenan) y el resultado se almacena en la variable que antecede al signo = (en nuestro caso la
misma variable nom1). Luego el contenido de la variable nom1 se junta con el contenido de la variable
nom2 y el resultado se almacena en la variable nombre.

nom1 = nom1.concat (espacio) ;

Pag. 95
 nombre = nom1.concat(nom2) ;

Esto permite juntar o concatenar los nombres del alumno con un espacio en blanco entre ellos en una
única variable de tipo String.
También podría visualizarse directamente el resultado de juntar o concatenar dos variables de tipo
String (cadenas) utilizando System.out.println, como se muestra a continuación:

System.out.println (nom1.concat (nom2) ) ;

Finalmente, se utilizan los métodos toUpperCase ( ) y toLowerCase ( ), explicados en los problemas

anteriores, directamente con System.out.println para mostrar el nombre del alumno en letra minúscula
y en letra mayúscula.

Pag. 96
Problema 205

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de un alumno.

Mostrar el número de caracteres del nombre ingresado por teclado. Consistenciar
el nombre del alumno al momento de ingresarlo.

Etapa 04 – Desarrollo de la codificación.

Clase PrgLongitudCadena

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgLongitudCadena {

public static void main(String [ ] args) {

int cant ;
String nom ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) < 2 ) ;

cant = nom.length( ) ;

System.out.println ( “ La cantidad de caracteres del nombre es: ” + cant ) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método trim ( ) de la clase String:

nom = nom.trim ( ) ;

El método trim ( ) permite eliminar los espacios en blanco que pueden existir al inicio y/o al final de una
cadena contenida en una variable (en nuestro caso la cadena contenida en la variable nom). Esto se
realiza como precaución, ya que el usuario puede haber presionado la barra espaciadora antes de
ingresar el nombre del alumno y esto se almacena en la variable como espacios en blanco.

También observe el uso del método length ( ) de la clase String:

Pag. 97
 cant = nom.length ( ) ;

El método length ( ) se utiliza con variables de tipo String y nos permite contar la cantidad de
caracteres que almacena una variable (en nuestro caso, la cantidad de caracteres que almacena la
variable nom). Como el método length ( ) devuelve la cantidad de caracteres que tiene una variable
(incluido los espacios en blanco), podemos mostrar el resultado utilizando System.out.println(),
utilizarlo en una condición lógica o almacenarlo en una variable. En nuestro ejemplo lo utilizamos como
condición lógica y para almacenarlo en una variable.

En la líneas de código mostradas a continuación, se consistencia el ingreso del nombre de tal forma
que no se permita ingresar un nombre que tenga menos de 2 caracteres (se asume que pueden haber
nombres de 2 caracteres o mas, como por ejemplo; Lu, Ana, José, Pedro, que tienen 2, 3, 4, y 5
caracteres respectivamente).

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim ( ) ;

if ( nom.length ( ) < 2 ) {
System.out.println ( “Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length ( ) < 2) ;

Pag. 98
Problema 206

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de un alumno.

Mostrar el nombre del alumno en letras mayúscula. Consistenciar el nombre del
alumno al momento de ingresarlo.

Etapa 04 – Desarrollo de la codificación.

Clase PrgConvertirMayuscula2

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgConvertirMayuscula2 {

public static void main(String [ ] args) {

String nom ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while ( nom.length( ) < 2 ) ;

nom = nom.toUpperCase( ) ;
System.out.println ( “ El nombre en Mayúscula es: ” + nom ) ;
}
}

Observe el uso de los métodos trim ( ), length ( ) y toUpperCase ( ) de la clase String.

En la codificación de este programa, se debe eliminar los espacios en blanco que la variable nom
pueda tener al inicio y al final del dato que contiene, luego se consistencia que tenga por lo menos 2
caracteres y luego se convierte el contenido de la variable nom en letra mayúscula, para finalmente
mostrar su contenido por pantalla.

En consecuencia, se puede afirmar que esta solución es más óptima que la solución presentada en el
problema 100.

Pag. 99
Problema 207

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de un alumno.

Mostrar el primer caracter del nombre ingresado en mayúsculas.

Etapa 04 – Desarrollo de la codificación.

Clase PrgPrimeroMayuscula

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgPrimeroMayuscula {

public static void main(String [ ] args) {

String nom, cadena1= “”, cadena2= “” ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) < 2 ) ;

cadena1 = nom.substring(0,1) ;
cadena1 = cadena1.toUpperCase( ) ;
cadena2 = nom.substring(1) ;

nom = cadena1.concat(cadena2) ;

System.out.println ( “ El nombre del alumno es: ” + nom ) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método substring ( ) de la clase String:

cadena1 = nom.substring(0,1) ;
cadena2 = nom.substring(1) ;

El método substring ( ) se utiliza de dos formas. La primera forma nos permite obtener una subcadena
desde una posición inicial hasta un caracter antes de la posición final indicada. La segunda forma nos
permite obtener una subcadena desde una posición determinada hasta el final de la cadena.

Pag. 100
Imagínese que la variable nom contiene el nombre “danae”, tal y como se muestra a continuación:

nom = “danae”.

Cuando manipulamos cadenas con el método substring ( ) debemos tener en cuenta que cada
caracter de la cadena tiene una determinada posición, empezando por la posición cero (0).

nom = “danae”.

posición 0

Entonces, si deseamos obtener la primera letra de la cadena utilizamos la siguiente sentencia:

cadena1 = nom.substring(0,1) ;

Donde, el primer número del método substring ( ) indica la posición de la cadena nom desde donde va
a empezar la subcadena y el segundo número indica la posición final de la cadena (es importante
mencionar que se debe incluir hasta un caracter antes de la posición final indicada). Esto nos permite
solo obtener el primer caracter de nom (la letra “d”).

Suponiendo que se desee obtener la subcadena “ana” de la cadena “danae” contenida en la variable
nom, utilizaríamos la siguiente sentencia:

cadena1 = nom.substring (1,4) ;

Continuando con nuestro ejemplo, una vez obtenida la primera letra del nombre se convierte a
mayúscula utilizando:

cadena1 = cadena1.toUpperCase ( ) ;

Ahora es necesario obtener el resto del contenido de la variable nom. Esto lo realizamos utilizando:

cadena2 = nom.substring (1) ;

Esta es la segunda forma de utilizar el método substring ( ), donde el número (en nuestro caso el
número 1), indica la posición de la cadena nom donde va a comenzar la subcadena (la primera letra
“a”) hasta el final de la cadena.

Ahora en la variable cadena1 tenemos almacenada la letra “D” y en la variable cadena2 tenemos
almacenadas las letras “anae”. Para finalizar solo será necesario juntar o concatenar ambas variables
en la variable original nom, utilizando el método concat ( ).

nom = cadena1.concat (cadena2) ;

El resultado que se obtiene es el nombre ingresado con la primera letra en mayúscula.

Pag. 101
Problema 208

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de un alumno.

Mostrar el primer caracter del nombre ingresado en mayúsculas y el resto en
minúscula.

Etapa 04 – Desarrollo de la codificación.

Clase PrgMayusculaMinuscula

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgMayusculaMinuscula {

public static void main(String [ ] args) {

int cant ;
String nom, cadena1 = “” , cadena2 = “” ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;
if ( nom.length( ) < 2) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) < 2 ) ;

cadena1 = nom.substring(0,1) ;
cadena1 = cadena1.toUpperCase( ) ;
cadena2 = nom.substring(1) ;
cadena2 = cadena2.toLowerCase( ) ;

nom = cadena1.concat(cadena2) ;
System.out.println ( “ El nombre del alumno es: ” + nom ) ;
}
}

Observe el uso de los métodos trim ( ), length ( ), substring ( ) en sus dos formas, toUpperCase ( ),
toLowerCase ( ) y concat ( ) de la clase String.

En la codificación de este programa, se convierte en mayúscula la primera letra del nombre y el resto
se convierte en minúscula. Esto como precaución de que se ingrese todo el nombre en mayúscula o en
forma combinada entre letras mayúsculas y minúsculas. Finalmente siempre el nombre tendrá la
primera letra en mayúscula y el resto en letra minúscula.

En consecuencia, se puede afirmar que esta solución es más óptima que la solución presentada en el
problema 104.

Pag. 102
Problema 209

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre completo de un

alumno (nombres y apellidos en una sola variable). Mostrar el primer caracter de
cada palabra del nombre en mayúsculas y el resto de cada palabra en minúscula.

Etapa 04 – Desarrollo de la codificación.

Clase PrgNombreCompleto

package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgNombreCompleto {
public static void main(String [ ] args) {
int cant ;
String nom, cadena1 = “”,cadena2 = “”, caracter ;
do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;
if ( nom.length( ) < 2) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) < 2) ;
cant = nom.length( ) ;
for (int x=0; x<cant; x++) {
if ( x==0) {
cadena1 = nom.substring(0,1) ;
cadena1 = cadena1.toUpperCase( ) ;
cadena2 = nom.substring(1) ;
cadena2 = cadena2.toLowerCase( ) ;
nom = cadena1.concat(cadena2) ;
} else {
caracter = nom.substring(x, x+1) ;
if (caracter.equals ( “ ” ) ) {
cadena1 = nom.substring(0,x+1) ;
caracter = nom.substring(x+1, x+2) ;
caracter = caracter.toUpperCase( );
cadena2 = nom.substring(x+2) ;
nom = cadena1 + caracter + cadena2 ;
}
}
}
System.out.println ( “ El nombre del alumno es: ” + nom ) ;
}
}

Pag. 103
¿Qué hay de nuevo en la codificación?

Observe el uso del método equals ( ) de la clase String:

if (caracter.equals (“ “)) {

El método equals ( ) se utiliza con variables de tipo String y nos permite comparar el contenido de dos
cadenas (en nuestro caso la variable caracter con un espacio en blanco). Si al comparar el contenido
de las dos cadenas resulta que ambas variables son iguales, el método equals ( ) nos devuelve un
valor verdadero (true), en caso contrario nos devuelve un valor falso (false). Este valor devuelto se
evalúa en la estructura de decisión if.

Imagínese que la variable nom contiene el siguiente nombre:

nom = “danae alessandra flores bertolotti” ;

Nosotros desearíamos que la primera letra de cada nombre y de cada apellido de un alumno este en
letra mayúscula, mientras que el resto de las letras estén en letra minúscula.

Al inicio utilizamos parte de la solución del problema 105. Después obtenemos caracter por caracter y
evaluamos si el caracter obtenido es un espacio en blanco. Si el caracter resulta ser un espacio en
blanco entonces se almacena y se convierte en letra mayúscula la letra siguiente al espacio en blanco.
El siguiente esquema muestra como se debe almacenar parcialmente el nombre del ejemplo en la
variable nom.

Danae a lessandra flores bertolotti.

cadena1 caracter cadena2

Después se concatenan las tres variables y se almacenan en la variable nom. El proceso se repite
hasta llegar al final de la cadena.

Ahora considere si entre los nombres existe más de un espacio en blanco. ¿Qué sucede? Modificando
la solución anterior para poder considerar la problemática anterior tendríamos la siguiente variación:

cant = nom.length( ) ;
sw = false ;
for (int x=0; x<cant; x++) {
if (x==0) {
cadena1 = nom.substring(0,1) ;
cadena1 = cadena1.toUpperCase( ) ;
cadena2 = nom.substring(1) ;
cadena2 = cadena2.toLowerCase( ) ;
nom = cadena1.concat(cadena2) ;
} else {

Pag. 104
 caracter = nom.substring(x, x+1) ;
if (caracter.equals( “ ” ) ) {
sw = true ;
} else {
if (sw) {
cadena1 = nom.substring(0,x) ;
caracter = nom.substring(x, x+1) ;
caracter = caracter.toUpperCase( );
cadena2 = nom.substring(x+1) ;
nom = cadena1 + caracter + cadena2 ;
sw = false ;
}
}
}
}

En esta parte modificada de la solución se utiliza un centinela (o flag) que nos permite indicar el
momento preciso para realizar la conversión de la primera letra del nombre o apellido a letra
mayúscula, sin preocuparnos de la cantidad de espacios en blanco que pueda existir entre dos
nombres.

Pag. 105
Problema 210

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los apellidos y nombres de

un obrero (en una sola variable). Mostrar el número de caracteres blancos o
espacios en blanco que existan.

Etapa 04 – Desarrollo de la codificación.

Clase PrgLongitudCadenaBlanco

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgLongitudCadenaBlanco {

public static void main(String [ ] args) {

int x,cant,cont=0 ;
String nom,caracter ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}

} while (nom.length( ) < 2 ) ;

cant = nom.length( ) ;

for (x=0;x<cant;x++) {
caracter = nom.substring(x,x+1) ;
if (caracter.equals ( “ ” ) ) {
cont ++ ;
}
}
System.out.println ( “ La cantidad de espacios: ” + cont ) ;
}
}

Observe el uso de los métodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String.

En la codificación de este programa, se evalúa caracter por caracter (de la variable nom). Si el caracter
es igual a un espacio en blanco (“ “), se le aumenta uno a la variable cont (que esta trabajando como
contador de espacios encontrados en la variable nom).

Pag. 106
Problema 211

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los apellidos y nombres de

un obrero (en una sola variable). Mostrar el número de caracteres del nombre
ingresado por teclado que no sean espacios en blanco.

Etapa 04 – Desarrollo de la codificación.

Clase PrgLongitudCadenaNoBlanco

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgLongitudCadenaNoBlanco {

public static void main(String [ ] args) {

int cant,x;
String nom, cadena = “”, caracter ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) < 2 ) ;

cant = nom.length( ) ;
for (x=0; x<cant; x++) {
caracter = nom.substring(x,x+1) ;
if ( !caracter.equals ( “ ” ) ) {
cadena = cadena.concat(caracter) ;
}
}
cant = cadena.length( ) ;
System.out.println ( “ La cantidad de caracteres sin contar espacios: ” + cant ) ;

}
}

Observe el uso de los métodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String.

En la codificación de este programa, se evalúa caracter por caracter (de la variable nom). Si el caracter
no es un espacio en blanco se junta o concatena con los caracteres de la variable cadena (al inicio no
contiene ningún caracter). Al final se obtiene la longitud de la variable cadena, que equivale a la
cantidad de caracteres de la variable nom diferentes a espacios en blanco.

Pag. 107
Problema 212

Etapa 01 – Descripción del problema.

Desarrollar una solución que permita ingresar los apellidos y nombres de un

obrero (en una sola variable). Mostrar el número de caracteres que no son
espacios en blanco y el número de caracteres que son espacios en blanco.

Etapa 04 – Desarrollo de la codificación.

Clase PrgLongitudCadenaBlancoNoBlanco

package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgLongitudCadenaBlancoNoBlanco {
public static void main(String [ ] args) {
int x, cant, cont = 0 ;
String nom, caracter ;
do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) < 2 ) ;
cant = nom.length( ) ;
fo r(x=0; x<cant; x++) {
caracter = nom.substring(x,x+1) ;
if (caracter.equals ( “ ” ) ) {
cont ++ ;
}
}
System.out.println ( “ La cantidad de espacios: ” + cont ) ;
System.out.println ( “ La cantidad de caracteres sin contar espacios: ” + ( cant - cont ) ) ;
}
}

En la codificación de este programa, se emplea la misma estrategia que la utilizada en la solución del
problema 108, para obtener el número de espacios en blanco contenidos en la variable nom. Al final se
obtiene la longitud total de la cadena nom y realizando una simple resta se obtiene el número de
caracteres de la variable nom que no son espacios en blanco.

Pag. 108
Problema 213

Etapa 01 – Descripción del problema.

Desarrollar una solución que permita ingresar el nombre de un alumno. Mostrar el

número de vocales que hay en el nombre ingresado.

Etapa 04 – Desarrollo de la codificación.

Clase PrgTotalVocales1

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgTotalVocales1 {

public static void main(String [ ] args) {

int cant, cont = 0, d = 0, x ;

String nom ;
char c = ‘ ’ ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) == 0 ) ;

cant = nom.length( ) ;
nom = nom.toLowerCase( ) ;

for (x=0; x<cant; x++) {

c = nom.charAt(x) ;
d = (int) (c) ;
switch (c) {
case 97 : // a
case 101 : // e
case 105 : // i
case 111 : // o
case 117 : cont ++ ; // u
}
}
System.out.println ( “ El Total de Vocales es: ” + cont ) ;
}
}

Pag. 109
¿Qué hay de nuevo en la codificación?

Observe el uso del método charAt ( ) de la clase String:

nom.charAt (x) ;

El método charAt ( ) se utiliza con variables de tipo String y nos permite obtener un caracter de una
cadena. En nuestro caso, obtenemos un caracter de la variable nom y lo almacenamos en una variable
de tipo char (el método charAt ( ) devuelve un caracter).

c = nom.charAt (x) ;

El caracter obtenido es evaluado para determinar si es o no una vocal. Esta evaluación se realiza a
través de los códigos ASC correspondientes a las vocales (es importante mencionar que la evaluación
de una variable de tipo char se puede realizar utilizando los códigos ASC equivalentes a los caracteres
especiales, letras y números).

Antes de iniciar la evaluación de cada uno de los caracteres de la variable nom, se utiliza el método
toLowerCase ( ) para asegurarnos de convertir a letras minúsculas todos los caracteres de la variable
nom y luego utilizar los códigos ASC equivalentes a las vocales en minúscula.

Modifique la solución anterior de tal forma que pueda determinar cuantas vocales almacenadas en la
variable son a, e, i, o y u (en forma independiente).

Pag. 110
Problema 214

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de un alumno.

Mostrar el número de vocales y el número de caracteres que no son vocales que
hay en el nombre ingresado.

Etapa 04 – Desarrollo de la codificación.

Clase PrgTotalVocalesNoVocales

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgTotalVocalesNoVocales {

public static void main(String [ ] args) {

int cant, cont = 0 , d = 0 , x ;

String nom ;
char c = ‘ ’ ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length( ) == 0 ) ;

cant = nom.length( ) ;
nom = nom.toLowerCase( ) ;

for (x=0; x<cant; x++) {

c = nom.charAt(x) ;
d = (int) (c) ;
switch (c) {
case 97 : // a
case 101 : // e
case 105 : // i
case 111 : // o
case 117 : cont ++ ; // u
}
}
System.out.println ( “ El Total de Vocales es: ” + cont ) ;
System.out.println ( “ El Total de caracteres que no son vocales es: ” + (cant – cont) ) ;
}
}

Pag. 111
Este programa es similar al programa desarrolado en el problema 111. La diferencia es que se obtiene
el total de caracteres que tiene la variable y se resta del total de vocales que tiene, para poder obtener
el total de caracteres que no son vocales.

Modifique la solución anterior de tal forma que pueda determinar cuántas vocales almacenadas en la
variable nom son mayúsculas y cuántas son minúsculas. También puede modificar la solución de tal
forma que permita determinar cuántas consonantes contiene la variable nom. Recuerde utilizar los
equivalentes en código ASC de las consonantes en letra minúscula o en letra mayúscula.

Pag. 112
Problema 215

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar dos cadenas. Contar y

mostrar cuantas veces se repite la segunda cadena en la primera cadena
ingresada.

Etapa 04 – Desarrollo de la codificación.

Clase PrgCadenaSubcadena

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgCadenaSubcadena {

public static void main(String [ ] args) {

String cad1, cad2, subcad ;
int total, i, cont = 0 ;

do {
System.out.println ( “ Ingresar una cadena: ” ) ;
cad1 = Lectura.leerString( ) ;
cad1 = cad1.trim( ) ;
if (cad1.length( ) == 0 ) {
System.out.println ( “ Cadena ingresada no válido... Reintente! ” ) ;
}
} while (cad1.length( ) == 0 ) ;
do {
System.out.println ( “ Ingresar una subcadena de la primera cadena: ” ) ;
cad2 = Lectura.leerString( ) ;
cad2 = cad2.trim( ) ;
if (cad2.length( ) == 0) {
System.out.println ( “ Cadena ingresada no válida... Reintente! ” ) ;
}
} while (cad2.length( ) == 0 ) ;

if (cad1.length( ) > cad2.length( ) ) {

total = cad1.length( ) - cad2.length( ) ;
for (i = 0; i <= total; i++) {
subcad = cad1.substring (i, i + cad2.length( ) ) ;
if (cad2.equals(subcad) ) {
cont ++ ;
}
}
System.out.println ( “ El número de veces que se repite ” ) ;
System.out.println ( “ la subcadena en la cadena es: ” + cont ) ;

Pag. 113
Continúa... Etapa 04 - Desarrollo de la codificación.

Clase PrgCadenaSubcadena

} else {
if (cad1.equals (cad2) ) {
System.out.println ( “ las cadenas son iguales ” ) ;
} else {
System.out.println ( “ la segunda cadena no debe tener una longitud ” ) ;
System.out.println ( “ mayor que la primera cadena ” ) ;
}
}
}
}

Observe el uso de los métodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String.

La parte central de la solución radica en las siguientes líneas de código:

if (cad1.length( ) > cad2.length( ) ) {

total = cad1.length( ) - cad2.length( ) ;
for (i = 0; i <= total; i++) {
subcad = cad1.substring(i, i + cad2.length( ) ) ;
if (cad2.equals (subcad)) {
cont ++ ;
}
}
System.out.println ( “ El número de veces que se repite ” );
System.out.println ( “ la subcadena en la cadena es: ” + cont ) ;
} else {
if (cad1.equals (cad2) ) {
System.out.println ( “ las cadenas son iguales ” ) ;
} else {
System.out.println ( “ la segunda cadena no debe tener una
longitud ” ) ;
System.out.println ( “ mayor que la primera cadena ” ) ;
}
}

En primer lugar, se verifica que la primera cadena (cad1) tenga una longitud mayor que la segunda
cadena (cad2). Luego, se obtiene la diferencia entre las longitudes de cad1 y cad2, y se almacena en
la variable total. El límite para la evaluación del número de veces que se repite cad2 en cad1, es el
caracter ubicado en la posición total de cad2. Después, empezando desde el primer caracter de cad1
se extrae una subcadena (subcad) del mismo tamaño que cad2 y se comparan para ver si son iguales
utilizando el método equals ( ). Si son iguales el contador cont aumenta en 1. Este proceso se repite
utilizando el siguiente caracter de cad1.

Como ejemplo utilizaremos las siguientes cadenas:

cad1 = “Danae” cad2 = “ana”

Pag. 114
En primer lugar determinamos que cad1 tiene una longitud mayor que cad2. Luego, calculamos
el valor de la variable total (total = 5-3 = 2).

Pag. 115
El límite para la evaluación del número de veces que se repite cad2 en cad1 es el caracter ubicado en
la posición 2 de cad2.

cad1 = “Danae”
0 12

Observe que cad2 tiene una

Límite para la longitud=3 por lo que la última
evaluación evaluación será:

cad2 = “ana” y subcad= “nae”

Primera evaluación:
cad2 = “ana” y subcad = “Dan”
Resultado: falso.

Segunda evaluación:
cad2 = “ana” y subcad = “ana”
Resultado: verdadero (cont =1).

Primera evaluación:
cad2 = “ana” y subcad = “nae”
Resultado: falso. Finalmente, se concluye que cad2
se repite una vez en cad1.

Pag. 116
Problema 216

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de dos alumnos.

Mostrar si los nombres ingresados son iguales o no.

Etapa 04 – Desarrollo de la codificación.

Clase PrgNombresIguales

package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgNombresIguales {
public static void main(String [ ] args) {
String nom1, nom2 ;
do {
System.out.println ( “ Ingresar el nombre del primer alumno: ” ) ;
nom1 = Lectura.leerString( ) ;
nom1 = nom1.trim( ) ;

if ( nom1.length( ) < 2 ) {
System.out.println("Nombre ingresado no válido… Reintente! ");
}
} while ( nom1.length( ) < 2 ) ;
do {
System.out.println ( “ Ingresar el nombre del segundo alumno: ” ) ;
nom2 = Lectura.leerString( ) ;
nom2 = nom2.trim( ) ;

if ( nom2.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while ( nom2.length( ) < 2 ) ;
if ( nom1.equals (nom2) ) {
System.out.println ( “ Los nombres ingresados son iguales ” ) ;
} else {
System.out.println ( “ Los nombres ingresados son diferentes ” ) ;
}
}
}

Observe el uso de los métodos trim ( ), length ( ) y equals ( ) de la clase String.

Se comparan dos variables de tipo cadena (nom1 y nom2 respectivamente) y se determinan si ambas
cadenas son iguales o no.

Pag. 117
Problema 217

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de dos

alumnos. Mostrar los nombres ordenados alfabéticamente.

Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados1

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgOrdenados1 {

public static void main(String [ ] args) {

String nombre1, nombre2, nombreMayor, nombreMenor;

System.out.println ( “ Ingrese el nombre de una persona: ” ) ;

nombre1 = Lectura.leerString( ) ;

System.out.println ( “ Ingrese el nombre de otra persona: ” ) ;

nombre2 = Lectura.leerString( ) ;

if (nombre1.compareTo(nombre2) < 0 ) {
nombreMenor = nombre1 ;
nombreMayor = nombre2 ;
} else {
nombreMenor = nombre2 ;
nombreMayor = nombre1 ;
}

System.out.println ( “ ------------------------------------------------- ” ) ;
System.out.println ( “ Nombres ordenados alfabéticamente ” ) ;
System.out.println ( “ ------------------------------------------------- ” ) ;
System.out.println (nombreMenor) ;
System.out.println (nombreMayor) ;
}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método compareTo ( ) de la clase String:

nombre1.compareTo (nombre2) ;

El método compareTo ( ) permite comparar dos variables de tipo String. El método permite compareTo
( ) nos devuelve un valor entero. Si el valor devuelto es igual a cero (0), entonces las cadenas son
iguales, es decir; las variables nombre1 y nombre2 contiene cadenas iguales. Si el valor devuelto es

Pag. 118
mayor que cero (0), entonces la variable nombre1 es mayor que la variable nombre2. Finalmente, si el
valor devuelto es menor que cero, entonces la variable nombre1 es menor que la variable nombre2.

Cuando se comparan dos cadenas, se realiza una comparación alfabética en la cual tienen significado
las letras mayúsculas, las letras minúsculas, los caracteres especiales y los espacios en blanco.

Por ejemplo; comparemos las siguientes cadenas:

nombre1 > nombre2

1. nombre1 = “Pedro” y nombre2 = “Luis”.

2. nombre1 = “Danae” y nombre2 = “Danae”. nombre1 = nombre2

3. nombre1 = “Carmen” y nombre2 = “Juan”. nombre1 < nombre2

En base a esto, mejore la solución de tal forma que se pueda realizar la consistencia de los nombres
ingresados.

Pag. 119
Problema 218

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de dos

alumnos (no permite el ingreso de solo espacios en blanco). Mostrar los nombres
ordenados alfabéticamente.

Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados2

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgOrdenados2 {

public static void main(String [ ] args) {

String nombre1, nombre2, nombreMayor, nombreMenor ;

do {
System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ;
nombre1 = Lectura.leerString( );
nombre1 = nombre1.trim( ) ;

if (nombre1.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while (nombre1.length( ) < 2 ) ;

do {
System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ;
nombre2 = Lectura.leerString( ) ;
nombre2 = nombre2.trim( ) ;

if ( nombre2.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while ( nombre2.length( ) < 2 ) ;

if ( nombre1.compareTo(nombre2) < 0 ) {
nombreMenor = nombre1 ;
nombreMayor = nombre2 ;
} else {
nombreMenor = nombre2 ;
nombreMayor = nombre1 ;
}

Pag. 120
Continúa... Etapa 04 - Desarrollo de la codificación.

Clase PrgOrdenados2

System.out.println ( “------------------------------------------------- ” ) ;
System.out.println ( “Nombres ordenados alfabéticamente ” ) ;
System.out.println ( “------------------------------------------------- ” ) ;
System.out.println (nombreMenor) ;
System.out.println (nombreMayor) ;
}
}

Mejore la codificación del programa, de tal forma que se contemple la posibilidad que los nombres
ingresados sean iguales.

Pag. 121
Problema 219

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de tres

alumnos (los nombres no deben ser iguales). Mostrar los nombres ordenados
alfabéticamente.

Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados3

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgOrdenados3 {

public static void main(String [ ] args) {

String nombre1, nombre2, nombre3 ;

String nom01 = “ ”, nom02 = “”, nom03 = “” ;

do {
System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ;
nombre1 = Lectura.leerString( ) ;
nombre1 = nombre1.trim( ) ;

if ( nombre1.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while ( nombre1.length( ) == 0 ) ;

do {
System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ;
nombre2 = Lectura.leerString( ) ;
nombre2 = nombre2.trim( ) ;

if ( nombre2.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while (nombre2.length( ) == 0 ) ;

do {
System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ;
nombre3 = Lectura.leerString( ) ;
nombre3 = nombre3.trim( ) ;

if ( nombre3.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while ( nombre3.length( ) == 0 ) ;

Pag. 122
Continúa... Etapa 04 - Desarrollo de la codificación.

Clase PrgOrdenados3

if (nombre1.compareTo(nombre2) < 0 && nombre1.compareTo(nombre3) < 0 ) {

nom01 = nombre1 ;
if (nombre2.compareTo(nombre3) < 0 ) {
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
}
if (nombre2.compareTo(nombre1) < 0 && nombre2.compareTo(nombre3) < 0) {
nom01 = nombre2 ;
if (nombre1.compareTo(nombre3) < 0 ) {
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
}
if (nombre3.compareTo(nombre1) < 0 && nombre3.compareTo(nombre2) < 0 ) {
nom01 = nombre3 ;
if (nombre1.compareTo(nombre2) < 0 ) {
nom02 = nombre1 ;
nom03 = nombre2 ;
} else {
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
System.out.println ( “ ------------------------------------------------- ” ) ;
System.out.println ( “ Nombres ordenados alfabéticamente ” ) ;
System.out.println ( “ ------------------------------------------------- ” ) ;
System.out.println (nom01) ;
System.out.println (nom02) ;
System.out.println (nom03) ;
}
}

Desarrolle la siguiente prueba:

1. Ejecute el programa, ingrese los siguientes datos y compruebe lo que sucede:

nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Beto”.

2. Luego ingrese los siguientes datos y compruebe nuevamente lo que sucede:

nombre1 = “Armando”. nombre2 = “Beto”. nombre3 = “Beto”.

3. Finalmente ingrese los siguientes datos. Compruebe lo que sucede:

nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Armando”.

Modifique la codificación de la solución de tal forma que pueda mejorarla.

Pag. 123
Pag. 124
Problema 220

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de tres

alumnos (los nombres pueden ser iguales). Mostrar los nombres ordenados
alfabéticamente.

Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados4

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgOrdenados4 {

public static void main(String [ ] args) {

String nombre1, nombre2, nombre3 ;

String nom01 = “”, nom02 = “”, nom03 = “”;

do {
System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ;
nombre1 = Lectura.leerString( ) ;
nombre1 = nombre1.trim( ) ;
if (nombre1.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while ( nombre1.length( ) == 0 ) ;

do {
System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ;
nombre2 = Lectura.leerString( ) ;
nombre2 = nombre2.trim( ) ;
if (nombre2.length( ) == 0) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while ( nombre2.length( ) == 0 ) ;

do {
System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ;
nombre3 = Lectura.leerString( ) ;
nombre3 = nombre3.trim( ) ;

if ( nombre3.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while (nombre3.length( ) == 0 ) ;

Pag. 125
Continúa... Etapa 04 - Desarrollo de la codificación.

Clase PrgOrdenados4

if ( nombre1.compareTo(nombre2) < 0 ) {
if ( nombre1.compareTo(nombre3) < 0 ) {
nom01 = nombre1 ;
if (nombre2.compareTo(nombre3) < 0 ) {
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre1 ;
nom03 = nombre2 ;
}
} else {
if ( nombre2.compareTo(nombre3) < 0 ) {
nom01 = nombre2 ;
if ( nombre1.compareTo(nombre3) < 0 ) {
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
System.out.println ( “ ------------------------------------------------- ” ) ;
System.out.println ( “ Nombres ordenados alfabéticamente ” ) ;
System.out.println ( “ ------------------------------------------------- ” ) ;
System.out.println (nom01) ;
System.out.println (nom02) ;
System.out.println (nom03) ;
}
}

Desarrolle la siguiente prueba:

Ingrese los nombres con letras mayúsculas y minúsculas, por ejemplo:

nombre1 = “armando”. nombre2 = “Beto”. nombre3 = “Armando”.

Compruebe lo que sucede. Se ordenarán primero los nombres que comiencen con mayúscula y luego
los nombres que comiencen con minúscula.

Modifique el programa de tal forma que se cambie la primera letra del nombre ingresado a mayúscula.

Pag. 126
Problema 221

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de tres

alumnos. Asegúrese que los nombres ingresados empiecen con una letra
mayúscula. Mostrar los nombres ordenados alfabéticamente.

Etapa 04 – Desarrollo de la codificación.

Clase PrgOrdenados5

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgOrdenados5 {

public static void main(String [ ] args) {

String nombre1, nombre2, nombre3, letra, resto ;

String nom01 = “”, nom02 = “”, nom03 = “” ;

do {
System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ;
nombre1 = Lectura.leerString( ) ;
nombre1 = nombre1.trim( ) ;
if ( nombre1.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
} else {
nombre1 =
((nombre1.substring(0, 1)).toUpperCase()).concat(nombre1.substring(1)) ;
}
} while ( nombre1.length( ) == 0 ) ;

do {
System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ;
nombre2 = Lectura.leerString( ) ;
nombre2 = nombre2.trim( ) ;
if ( nombre2.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
} else {
nombre2 =
((nombre2.substring(0, 1)).toUpperCase()).concat(nombre2.substring(1)) ;
}
} while ( nombre2.length( ) == 0 ) ;

do {
System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ;
nombre3 = Lectura.leerString( ) ;
nombre3 = nombre3.trim( ) ;

Pag. 127
Continúa... Etapa 04 - Desarrollo de la codificación.

Clase PrgOrdenados5

if ( nombre3.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
} else {
nombre3 =
((nombre3.substring(0, 1)).toUpperCase()).concat(nombre3.substring(1)) ;
}
} while ( nombre3.length( ) == 0 ) ;
if ( nombre1.compareTo(nombre2) < 0 ) {
if ( nombre1.compareTo(nombre3) < 0 ) {
nom01 = nombre1 ;
if ( nombre2.compareTo(nombre3) < 0 ) {
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre1 ;
nom03 = nombre2 ;
}
} else {
if ( nombre2.compareTo(nombre3) < 0 ) {
nom01 = nombre2 ;
if ( nombre1.compareTo(nombre3) < 0 ) {
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
System.out.println ( “ Nombres ordenados alfabéticamente ” ) ;
System.out.println (nom01) ;
System.out.println (nom02) ;
System.out.println (nom03) ;
}
}

Mejore la solución desarrollando un programa que permita ingresar tres nombres de alumnos.
Asegúrese que los nombres ingresados empiecen con una letra mayúscula y que el resto de las letras
de los nombres estén en minúscula. Muestre los nombres ordenados alfabéticamente.

Luego, complemente la solución permitiendo el ingreso de los nombres de todos los alumnos de un
determinado salón de clase.

Pag. 128
Problema 222

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de una persona,

un caracter que este contenido en el nombre ingresado y otro caracter por el cual
se reemplazará el primer caracter ingresado. Mostrar el nombre modificado.

Etapa 04 – Desarrollo de la codificación.

Clase PrgCadenaModifcada

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgCadenaModifcada {

public static void main(String [ ] args) {

int cant ;
String nom, dato1, dato2, caracter, cadena= “” ;

System.out.print ( “ Ingresar el nombre de una persona: ” ) ;

nom = Lectura.leerString( ) ;

System.out.print ( “ Ingrese el caracter que se va buscar: ” ) ;

dato1 = Lectura.leerString( ) ;

System.out.print ( “ Ingrese el caracter por el cual se va reemplazar: ” ) ;

dato2 = Lectura.leerString( ) ;

cant = nom.length( ) ;

for (x=0; x<cant; x++ ) {

caracter = nom.substring(x,x+1) ;
if ( dato1.equals(caracter) == true )
cadena = cadena + dato2 ;
else
cadena = cadena + caracter ;
}
System.out.println ( “ El resultado es: ” + cadena ) ;
}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método equals ( ) de la clase String:

Pag. 129
 nombre1.equals (nombre2) ;

El método equals ( ) devuelve true (verdadero) si la cadena coincide con la cadena colocada como
parámetro del método equals ( ), caso contrario devuelve false (falso).

Por lo que en este caso el método equals ( ) evalúa a la variable dato1 y a la variable caracter. La
variable caracter tuvo que declararse como String para poder ser utilizada por el método equals ( ) de
esta forma:

caracter = nom.substring (x , x+1) ;

Un punto muy importante es el análisis de la siguiente línea de código:

if ( dato1.equals (caracter) == true )

La sentencia if puede evaluar una condición lógica, una variable booleana o el resultado de una
operación. En nuestro caso, el método equals ( ) devuelve true (verdadero) o false (falso),
dependiendo del resultado de la comparación entre las variables dato1 y caracter.

En base a esto, podemos afirmar que las siguientes sentencias en Java son equivalentes:

if ( dato1.equals (caracter) == true )

if ( dato1.equals (caracter) )

Resulta evidente que no es necesario realizar comparaciones booleanas dentro de las condiciones
lógicas utilizadas en la sentencia if (esto se hace extensivo a las sentencias do, while y for).

Pag. 130
Problema 223

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar un número mayor de tres

dígitos. Convertir el número en cadena, luego intercambiar posiciones, el primer
digito pasarlo al último y el último digito pasarlo al primero. Mostrar el nuevo
número.

Etapa 04 – Desarrollo de la codificación.

Clase PrgIntercambioCadena

package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgIntercambioCadena {
public static void main(String [ ] args) {
int num, cant;
String dato1, dato2, dato3, cadena = "";
do {
System.out.print(" Ingresar un numero mayor de 3 dígitos: ");
num = Lectura.leerInt();

if (num < 100) {

System.out.println(" Número ingresado no válido… Reintente! ");
}
} while (num < 100);
cadena = String.valueOf(num);
cant = cadena.length();
dato1 = cadena.substring(0, 1);
dato2 = cadena.substring(1, cant - 1);
dato3 = cadena.substring(cant-1);
cadena = dato3 + dato2 + dato1;
System.out.println(" El resultado es: " + cadena);}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método valueOf ( ) de la clase String:

String.valueOf (num) ;

El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de
tipo String). Este método permite convertir una variable de cualquier tipo a una variable de
tipo String o cadena. En nuestra solución convertimos la variable num a String con la
finalidad de poder manipular el contenido de la variable con métodos de la clase String.
Una vez convertida la variable num, se utiliza el método substring ( ) para intercambiar las
posiciones deseadas.

Pag. 131
Problema 224

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar el nombre de un alumno.

Mostrar el nombre ingresado, de tal forma que se lea de izquierda a derecha
(nombre mostrado al revés).

Etapa 04 – Desarrollo de la codificación.

Clase PrgInvertirCadena

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgInvertirCadena {

public static void main(String [ ] args) {

int cant, x ;
String nom, caracter, cadena = “” ;

do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while ( nom.length( ) == 0 ) ;

cant = nom.length( );

for (x=cant-1; x>=0; x-- ) {

caracter = nom.substring(x,x+1) ;
cadena = cadena.concat(caracter) ;
}

System.out.println ( “ El nombre al revés es: ” + cadena ) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método concat ( ) de la clase String:

En este programa, declaramos la variable caracter como una cadena (String). Cada vez que se ejecuta
la sentencia for, se obtiene de la variable nom un caracter empezando desde el último y terminando en
el primero. Cada vez que se obtiene un caracter este se agrega a la variable cadena, de tal forma que

Pag. 132
al finalizar la ejecución de la sentencia for se tiene almacenado en la variable cadena el nombre
ingresado con los caracteres finales al inicio y los caracteres iniciales al final.

Otra manera de solucionar este problema es la siguiente:

for ( x = cant - 1; x >= 0; x - - ) {

caracter = nom.charAt (x) ;
cadena += caracter ;
}

Es importante indicar que para esta solución, la variable caracter debe declararse como char. Observe
como se utiliza el método charAt ( ) de la clase String, con la finalidad de obtener caracter por caracter
de la variable nom (empezando desde el último y terminando en el primero), para agregarlos a la
variable cadena utilizando el signo “+” (concatenación).

Pag. 133
Problema 225

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de 10 alumnos

y permita visualizar la cantidad de nombres que empiezan con la letra “P” y la
cantidad de nombres que terminan con la letra “a”.

Etapa 04 – Desarrollo de la codificación.

Clase PrgCuentaLetras1

package dominioDeLaAplicacion ;

import biblioteca.* ;
public class PrgCuentaLetras1 {

public static void main(String [ ] args) {

String nombre, letraIni = “”, letraFin = “” ;

int i, contP= 0, contA = 0 ;

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

do {
System.out.println ( “ Ingresar el nombre del alumno: ” ) ;
nombre = Lectura.leerString( ) ;
nombre = nombre.trim( ) ;
if ( nombre.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido... Reintente! ” ) ;
}
} while (nombre.length( ) == 0 ) ;
letraIni = nombre.substring(0,1) ;
letraFin = nombre.substring ( nombre.length( )-1,nombre.length( ) ) ;
if ( letraIni.equals( “P” ) ) {
contP++;
}
if ( letraFin.equals( “a” ) ) {
contA++;
}
}
System.out.println ( “ Nombres que comienzas con la letra P: ” + contP);
System.out.println ( “ Nombres que terminan con la letra a: ” + contA);
}
}

Mejore la solución desarrollando un programa que permita ingresar los nombres de todos los alumnos.
Utilice la estructura do… while. Asegúrese que los nombres ingresados empiecen con una letra
mayúscula y que el resto de las letras de los nombres estén en minúscula.

Pag. 134
Problema 226

Etapa 01 – Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de todos los
empleados de una empresa. Mostrar el número de vocales que existen en cada
uno de los nombres ingresados.

Etapa 04 – Desarrollo de la codificación.

Clase PrgTotalVocales2

package dominioDeLaAplicacion ;
import biblioteca.* ;
public class PrgTotalVocales2 {
public static void main(String [ ] args) {
int cant, cont=0, opc, d=0, x ;
String nom ;
char c = ‘ ’ ;
do {
do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = Lectura.leerString( ) ;
nom = nom.trim( ) ;

if ( nom.length( ) == 0 ) {
System.out.println ( “ Nombre no válido… Reintente! ” ) ;
}
} while ( nom.length( ) == 0 ) ;
cant = nom.length( ) ;
nom = nom.toLowerCase( ) ;
for ( x=0; x<cant; x++ ) {
c = nom.charAt(x) ;
d = (int) (c) ;
switch(c) {
case 97 : // a
case 101 : // e
case 105 : // i
case 111 : // o
case 117 : cont ++ ; // u
}
}
System.out.println ( “ El Total de Vocales del nombre ingresado es: ” + cont ) ;
System.out.println ( “ Desea ingresar otro nombre (Sí = 1, No = 2): ” ) ;
opc =Lectura.leerInt( ) ;
} while ( opc != 1 ) ;
}
}

Pag. 135
Mejore la solución desarrollando un programa que considere el conteo de las vocales acentuadas y las
vocales en letra mayúscula. Como sugerencia investigue los códigos ASCII de las vocales acentuadas
y las vocales en letra mayúscula, y agréguelos en la sentencia switch ( ).

Pag. 136
Problema 227

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de todos los
productos de una determinada tienda. Mostrar como resultado las posiciones
pares.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgProductosTienda

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgProductosTienda {

public static void main ( String arg [ ] ) {

int x, cantidad, cont = 0 ;
String producto, acum = “” ;

do {
System.out.println ( “ Ingresar la cantidad de productos: ” ) ;
cantidad = Lectura.leerInt( ) ;
if ( cantidad < 1 ) {
System.out.println ( “ Cantidad no válida… Reintente! ” ) ;
}
} while ( cantidad < 1 ) ;

do {

System.out.println ( “ Ingresar el nombre del producto: ” ) ;

producto = Lectura.leerString( ) ;

for ( x = 1; x <= producto.length(); x++ ) {

if ( x % 2 == 0 ) {
acum = acum + producto.substring(x - 1, x) ;
}

}
System.out.println ( “ Las posiciones pares del producto son: ” + acum ) ;

acum = “” ;
cont ++ ;

} while ( cantidad != cont ) ;

}
}

Pag. 137
Análisis de la solución

Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad, se valida el número de

alumnos ingresado, de tal forma que sea mayor a cero.

Luego, se utiliza una sentencia do para ingresar el nombre de cada uno de los productos y determinar
sus posiciones pares. Esto último se logra utilizando una sentencia for dentro de la sentencia do.

Observe el uso de los métodos length ( ) y substring ( ) de la clase String, y la forma como se utilizan
las estructuras lógicas para la solución del problema.

Pag. 138
Problema 228

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar los nombres de todos los
alumnos de un salón de clase. Mostrar la longitud de cada nombre ingresado, el
nombre que tiene la mayor longitud y el nombre que tiene la menor longitud.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgLongitudNombre

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgLongitudNombre {

public static void main ( String arg [ ] ) {

int cantidad, cont = 0, longMayor = 0, longMenor = 100 ;
String alumno, nomMayor = “”, nomMenor = “” ;

do {
System.out.println ( “ Ingresar la cantidad de alumnos: ” ) ;
cantidad = Lectura.leerInt( ) ;
if ( cantidad < 1 ) {
System.out.println ( “ Cantidad no válida… Reintente! ” ) ;
}
} while ( cantidad < 1 ) ;

do {
System.out.println ( “ Ingresar el nombre del alumno: ” ) ;
alumno = Lectura.leerString( ) ;
System.out.println ( “ La Longitud es: ” + alumno.length( ) ) ;
if ( longMayor < alumno.length( ) ) {
longMayor = alumno.length( ) ;
nomMayor = alumno ;
}
if ( longMenor > alumno.length( ) ) {
longMenor = alumno.length( ) ;
nomMenor = alumno ;
}
cont ++ ;
} while ( cantidad != cont ) ;

System.out.println ( nomMenor + “ tiene de longitud ” + longMenor ) ;

System.out.println ( nomMayor + “ tiene de longitud ” + longMayor ) ;
}
}

Pag. 139
Análisis de la solución

Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad, se valida el número de

alumnos ingresado, de tal forma que sea mayor a cero.

Luego, se utiliza una sentencia do para ingresar el nombre de cada uno de los alumnos, y se
determina la longitud de cada nombre ingresado, el nombre con la mayor longitud y el nombre con la
menor longitud.

Observe el uso de los métodos length ( ) de la clase String, y la forma como se utilizan las estructuras
lógicas para la solución del problema.

Pag. 140
Problema 229

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita ingresar una fecha con el siguiente
formato “dd-mm-aaaa” y validarla.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgFechaFormato

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgFechaFormato {

public static void main ( String arg [ ] ) {

String fecha, dia, mes, anio ;
int num1 = 0, num2 = 0 ;
System.out.println ( “ Formato de la fecha es : dd-mm-aaaa ” ) ;

System.out.println ( “ Ingresar la fecha actual: ” ) ;

fecha = Lectura.leerString( ) ;

if ( fecha.length( ) <= 10 ) {
dia = fecha.substring(0, 2) ;
num1 = Integer.parseInt(dia) ;
mes = fecha.substring(3, 5) ;
num2 = Integer.parseInt(mes) ;
anio = fecha.substring(6, 10) ;
if ( ( dia.length() != 2 ) || ( num1 < 31 ) ) {
System.out.println ( “ El dia ingresado es incorrecto ” ) ;
} else {
if ( (mes.length() != 2 ) || ( num2 < 12 ) ) {
System.out.println ( “ El mes ingresado es incorrecto ” ) ;
} else {
if ( anio.length( ) != 4 ) {
System.out.println ( “ El año ingresado esta incorrecto ” ) ;
} else {
System.out.println ( “ La fecha ingresada es correcta ” ) ;
}
}
}
}
}
}

Intente mejorar la solución validando la fecha, de tal forma que el mes ingresado sólo sea válido si es
que la variable dia contiene el número de días válidos para dicho mes. Incluya la posibilidad que el
mes de febrero sea bisiesto.

Pag. 141
Problema 230

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita completar por la izquierda

(utilizando asteriscos) una determinada cadena en base a una longitud
especificada.

Ejemplo:
Se ingresa:
Longitud = 10
Cadena = “Danae”
Resultado:
Cadena = “Danae*****”

Etapa 04 - Desarrollo de la Codificación.

Clase PrgCompletarCadenaIzq

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgCompletarCadenaIzq {

public static void main ( String arg [ ] ) {

String cadena ;
int longitud, tamaño, x ;

System.out.println ( “ La longitud especificada es: ” ) ;

longitud = Lectura.leerInt( ) ;

System.out.println ( “ Ingresar cadena: ” ) ;

cadena = Lectura.leerString( ) ;

if ( longitud > cadena.length( ) ) {

tamaño = longitud - cadena.length( ) ;
for ( x = 1; x <= tamaño; x++) {
cadena = cadena + “*” ;
}
}

System.out.println ( “ La nueva cadena es: ” + cadena ) ;

}
}

Pag. 142
Problema 231

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita completar por la derecha (utilizando

asteriscos) una determinada cadena en base a una longitud especificada.

Ejemplo:
Se ingresa:
Longitud = 10
Cadena = “Danae”
Resultado:
Cadena = “*****Danae”

Etapa 04 - Desarrollo de la Codificación.

Clase PrgCompletarCadenaDer

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgCompletarCadenaDer {

public static void main ( String arg [ ] ) {

String cadena ;
int longitud, tamaño, x ;

System.out.println ( “ La longitud especificada es: ” ) ;

longitud = Lectura.leerInt( ) ;

System.out.println ( “ Ingresar cadena: ” ) ;

cadena = Lectura.leerString( ) ;

if ( longitud > cadena.length( ) ) {

tamaño = longitud - cadena.length( ) ;

for ( x = 1; x <= tamaño; x++ ) {

cadena = “*” + cadena ;
}
}

System.out.println ( “ La nueva cadena es: ” + cadena ) ;

}
}

Pag. 143
Problema 232

Etapa 01 - Descripción del problema.

Desarrollar un programa en Java que permita transformar un arreglo de caracteres

en una cadena, especificando la posición del arreglo donde va ha comenzar la
cadena y su longitud. Analizar la solución.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgArregloCadena

package dominioDeLaAplicacion ;

import biblioteca.Lectura ;
class PrgArregloCadena {

public static void main ( String arg [ ] ) {

char arregloA = { ‘D’, ‘a’, ‘n’, ‘a’, ‘e’ } ;

String cadena = String.valueOf (arregloA, 1, 3) ;

System.out.println ( “ La cadena es: ” + cadena ) ;

}
}

¿Qué hay de nuevo en la codificación?

Observe el uso del método valueOf ( ) de la clase String:

String.valueOf ( char [ ], int, int ) ;

El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo String).
Este método permite convertir un arreglo de caracteres o parte de él, en una variable de tipo String o
cadena. En nuestra solución convertimos parte del arreglo arregloA a un String con la finalidad de
mostrar el contenido de dicha variable.

Observe que en este método, en primer lugar, se especifica el arreglo de tipo char del cual se va ha
obtener la cadena. En segundo lugar, se indica la posición del arreglo desde el cual se van a tomar los
datos y finalmente, se indica la longitud o el número de caracteres que se van a obtener del arreglo.
En el ejemplo, se muestra como resultado la cadena “ana”.

Los arreglos serán tratados en el siguiente capítulo.

Pag. 144
Ejemplos de uso del método matches de la clase String de Java

Problema 233

Ingreso desolo una letra. Puede ingresar la letra en mayúscula o minúscula.

String letras ;

do {
letras = LE.leerString ( “Ingrese 1 sola letra: ” ) ;

if ( ! letras.matches ( “[a-z-A-Z]” ) ) {
LE.mostrarError ( “Error; la letra ingresada es incorrecta; reintente” ) ;
}

} while ( ! letras.matches ( “[a-z-A-Z]” ) ) ;

Problema 234

Ingreso de varias letras.

String letras ;

do {
letras = LE.leerString ( “Ingrese varias letras: ” ) ;

if ( ! letras.matches ( “[a-z-A-Z]+” ) ) {
LE.mostrarError ( “Error; las letras ingresadas son incorrectas; reintente” ) ;
}
} while ( ! letras.matches ( “[a-z-A-Z]+” ) ) ;

Pag. 145
Problema 235

Ingreso de sólo 3 letras. Las llaves agregadas al argumento

más el número dentro indica el número de caracteres que deben ser ingresados.

String letras ;

do {
letras = LE.leerString ( “Ingrese 3 letras: ” ) ;

if ( ! letras.matches ( “[a-z-A-Z]{3}” ) ) {
LE.mostrarError ( “Error; las letras ingresadas son incorrectas; reintente” ) ;
}
} while ( ! letras.matches ( “[a-z-A-Z]{3}” ) ) ;

Problema 236

Ingreso de varias letras, un espaco en blanco y después varias letras.

String letras ;

do {
letras = LE.leerString ( “Ingrese sus dos nombres: ” ) ;

if ( ! letras.matches ( “[a-z]+[ ][a-z]+” ) ) {

LE.mostrarError ( “Error; no ha ingresado dos nombres; reintente ” ) ;
}
} while ( ! letras.matches ( “[a-z]+[ ][a-z]+” ) ) ;

Problema 237

Ingreso de un número de un dígito.

String numeros ;

do {
numeros = LE.leerString ( “Ingrese un número de un dígito: ” ) ;

if ( ! numeros.matches ( “[0-9]” ) ) {
LE.mostrarError ( “Error; el número ingresado es incorrecto; reintente” ) ;
}
} while ( ! numeros.matches ( “[0-9]” ) ) ;

Pag. 146
Problema 238

Ingreso de un número de varias cifras.

String numeros ;

do {
numeros = LE.leerString ( “Ingrese un número: ” ) ;

if ( ! numeros.matches ( “[0-9]+” ) ) {
LE.mostrarError ( “Error; el número ingresado es incorrecto; reintente" ) ;
}
} while ( ! numeros.matches ( “[0-9]+” ) ) ;

Problema 239

Ingreso de un número de 3 cifras.

String numeros ;

do {
numeros = LE.leerString ( “Ingrese un número: ” ) ;

if ( ! numeros.matches ( “[0-9]{3}” ) ) {
LE.mostrarError ( “Error; el número ingresado es incorrecto; reintente ” ) ;
}
} while ( ! numeros.matches ( “[0-9]{3}” ) ) ;

Problema 240

Ingreso de dos letras y un número de 5 cifras.

String cadena ;

do {
cadena = LE.leerString ( “Ingrese 2 letras y un número: ” ) ;

if ( ! cadena.matches ( “[a-z-A-Z]{2}[0-9]{5}” ) ) {
LE.mostrarError ( “Error; el dato ingresado es incorrecto; reintente” ) ;
}
} while ( ! cadena.matches ( “[a-z-A-Z]{2}[0-9]{5}” ) ) ;

Pag. 147
 Analizando la codificación, podemos deducir lo siguiente:
• 1er Argumento [a-z-A-Z]{2}
Permite el ingreso de 2 letras. Puede ser en mayúscula o en minúscula.
• 2do Argumento [0-9]{5}
Permite que posteriormente se ingresen 5 cifras de un número.

Problema 241

Validación de sexo (1).

String sexo ;

do {
sexo = LE.leerString ( “Ingrese el sexo: F: Femenino | M: Masculino” ) ;

if ( ! sexo.matches ( “[FMfm]” ) ) {
LE.mostrarError ( “Error; el dato ingresado es incorrecto; reintente” ) ;
}
} while ( ! sexo.matches ( “[FMfm]” ) ) ;

Problema 242

Validación de sexo (2).

String sexo ;

do {
sexo = LE.leerString ( “Ingrese el sexo: F: Femenino | M: Masculino” ) ;

if ( ! sexo.matches ( “[FMfm] {1}” ) ) {

LE.mostrarError ( “Error; el dato ingresado es incorrecto; reintente” ) ;
}
} while ( ! sexo.matches ( “[FMfm]{1}” ) ) ;

Pag. 148
Problema 243

Validación de sexo (3).

String sexo ;

do {
sexo = LE.leerString ( “Ingrese el sexo: F: Femenino | M: Masculino” ) ;
sexo = sexo.toUpperCase ( ) ;

if ( !sexo.matches ( “[FM] {1}” ) ) {

LE.mostrarError ( “Error; el dato ingresado es incorrecto; reintente” ) ;
}
} while ( ! sexo.matches ( “[FM]{1}” ) ) ;

Problema 244

Validación de número telefónico.

String numTelefono ;

do {
numTelefono = LE.leerString ( “Ingrese el número de teléfono” ) ;

if ( ! numTelefono.matches ( “[0-9]{7}” ) ) {
LE.mostrarError ( “Error; el Nro. ingresado es incorrecto; reintente” ) ;
}
} while ( ! numTelefono.matches ( “[0-9]{7}” ) ) ;

De la misma forma se pueden realizar las validaciones de:

• DNI.
• Número de teléfono celular.

Pag. 149
Problema 245

En este caso cabe recalcar que el argumento proporcionado para el funcionamiento del
método matches es para un tipo de correo que pueda poseer:

Ingreso de nombre de mail – Puede ser letras o números o ambos caracteres.

El mail puede poseer un “_” de carácter.
Ingreso de dominio de mail- Este solo puede contener caracteres de tipo texto.

String Email ;

do {
Email = LE.leerString ( “Ingrese su e-mail: ” ) ;
Email = Email.toLowerCase ( ) ;

if ( ! Email.matches ( “[a-z-0-9-_]+[@][a-z]+[.][a-z]{3}” ) ) {
LE.mostrarError ( “Error; el tipo de correo valido es [email protected]; reintente” ) ;
}
} while ( ! Email.matches ( “[a-z-0-9-_]+[@][a-z]+[.][a-z]{3}” ) ) ;

Pag. 150