UNIVERSIDAD CENTRAL DEL ECUADOR

FACULTAD DE INGENIERÍA Y CIENCIAS APLICADAS

CARRERA DE INGENIERÍA EN COMPUTACIÓN

Java
String, Math, Wrappers, Boxing y Unboxing

Nombre:
Jose Isaac Zapata Buenaño

Docente:
Alex Soldado

Fecha:
14 de julio de 2025

1
Universidad Central del Ecuador Programación Orientada a Objetos

Índice

1. Introducción 3

2. Clase String 3
2.1. Definición y Caracterı́sticas . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2. Métodos Esenciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3. Ejemplo Práctico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3. Clase Math 4
3.1. Definición y Caracterı́sticas . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2. Métodos Esenciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.3. Ejemplo Práctico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

4. Clases Wrapper 5
4.1. Definición y Propósito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.2. Métodos Clave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4.2.1. Conversiones Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4.2.2. Validación de Caracteres . . . . . . . . . . . . . . . . . . . . . . . . 6

5. Boxing y Unboxing 7
5.1. Conceptos Fundamentales . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
5.2. Ejemplos Prácticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

6. Consideraciones Importantes 8
6.1. Rendimiento y Buenas Prácticas . . . . . . . . . . . . . . . . . . . . . . . . 9

7. Conclusión 10

8. Bibliografı́a 10

2
Universidad Central del Ecuador Programación Orientada a Objetos

1 Introducción
Java es un lenguaje de programación orientado a objetos que proporciona clases fun-
damentales para diversas operaciones. En este documento exploraremos:

String: Manejo de texto

Math: Operaciones matemáticas
Wrappers: Representación de tipos primitivos como objetos
Boxing/Unboxing: Conversión automática entre primitivos y objetos

Estos elementos son esenciales en la programación Java diaria y forman la base para
conceptos más avanzados como colecciones y genéricos.

2 Clase String
2.1 Definición y Caracterı́sticas
La clase String representa secuencias de caracteres inmutables. Una vez creado un
objeto String, su contenido no puede modificarse. Esta inmutabilidad ofrece:

Seguridad en entornos multihilo

Optimización de memoria mediante String Pool
Mayor seguridad en aplicaciones

Importante

String Pool: Área especial de memoria donde Java almacena literales de String.
Cuando se crea un nuevo String, Java verifica si ya existe en el pool para reutilizarlo.

2.2 Métodos Esenciales

Método Descripción y Ejemplo

length() "Hola".length() → 4
charAt(index) "Java".charAt(2) → ’v’
substring(inicio,"Hola Mundo".substring(0,4) → ”Hola”
fin)
equals(otro) "texto".equals("TEXTO") → false
toUpperCase() .abc".toUpperCase() → .ABC”
trim() "hola ".trim() → ”hola”
split(separador) .a,b,c".split(",") → [.a”,”b”,ç”]

Cuadro 1: Métodos esenciales de String

3
 Universidad Central del Ecuador Programación Orientada a Objetos

2.3 Ejemplo Práctico

1 public class EjemploString {
2 public static void main ( String [] args ) {
3 // Validar formato de email
4 String email = " usuario@dominio . com " ;
5 if ( email . contains ( " @ " ) && email . indexOf ( " @ " ) > 0) {
6 System . out . println ( " Email v l i d o " ) ;
7 }
8

9 // Procesar datos CSV

10 String datos = " Juan ,25 , Ingeniero " ;
11 String [] campos = datos . split ( " ," ) ;
12 System . out . println ( " Nombre : " + campos [0]) ;
13 System . out . println ( " Edad : " + Integer . parseInt ( campos [1])
);
14

15 // Normalizar entrada de usuario

16 String input = " PruebA " ;
17 String normalizado = input . trim () . toLowerCase () ;
18 System . out . println ( normalizado ) ; // " prueba "
19 }
20 }
Listing 1: Manejo de Strings en aplicaciones reales

3 Clase Math
3.1 Definición y Caracterı́sticas
La clase Math proporciona métodos estáticos para operaciones matemáticas comunes.
Sus caracterı́sticas clave incluyen:

Todos los métodos son static (no requiere instancia)

Manejo de constantes matemáticas ([Link], Math.E)

Optimización para rendimiento y precisión

4
 Universidad Central del Ecuador Programación Orientada a Objetos

3.2 Métodos Esenciales

Método Descripción y Ejemplo

abs(x) [Link](-7.5) → 7.5
pow(base, exp) [Link](2, 3) → 8.0
sqrt(x) [Link](25) → 5.0
round(x) [Link](4.6) → 5
min(a, b) [Link](10, 20) → 10
max(a, b) [Link](10, 20) → 20
random() [Link]() → 0.548 (entre 0.0 y 1.0)

Cuadro 2: Métodos esenciales de Math

3.3 Ejemplo Práctico

1 public class EjemploMath {
2 public static void main ( String [] args ) {
3 // Calcular distancia entre dos puntos
4 double x1 = 3 , y1 = 4;
5 double x2 = 7 , y2 = 1;
6 double distancia = Math . sqrt ( Math . pow ( x2 - x1 , 2) + Math .
pow ( y2 - y1 , 2) ) ;
7 System . out . println ( " Distancia : " + distancia ) ; // 5.0
8

9 // Generar n m e r o s aleatorios en rango

10 int min = 10 , max = 20;
11 int aleatorio = min + ( int ) ( Math . random () * (( max - min )
+ 1) ) ;
12 System . out . println ( " N m e r o aleatorio : " + aleatorio ) ;
13

14 // Calcular i n t e r s compuesto
15 double capital = 1000;
16 double tasa = 0.05; // 5 %
17 int a o s = 5;
18 double monto = capital * Math . pow (1 + tasa , a o s ) ;
19 System . out . printf ( " Monto final : $ %.2f %n " , monto ) ; //
$1276 .28
20 }
21 }
Listing 2: Aplicaciones matemáticas en Java

4 Clases Wrapper
4.1 Definición y Propósito
Las clases Wrapper encapsulan tipos primitivos en objetos. Son esenciales para:

5
 Universidad Central del Ecuador Programación Orientada a Objetos

Usar tipos primitivos en colecciones (ArrayList<Integer>)

Representar valores nulos (null)

Proporcionar métodos de utilidad para conversiones

Primitivo Wrapper
int Integer
double Double
char Character
boolean Boolean
byte Byte
short Short
long Long
float Float

Cuadro 3: Correspondencia entre primitivos y wrappers

4.2 Métodos Clave

4.2.1 Conversiones Básicas

1 // String a primitivo
2 int edad = Integer . parseInt ( " 25 " ) ;
3 double precio = Double . parseDouble ( " 15.99 " ) ;
4 boolean activo = Boolean . parseBoolean ( " true " ) ;
5

6 // Primitivo a String
7 String texto = Integer . toString (42) ;
8 String decimal = Double . toString (3.1416) ;
9

10 // String a wrapper
11 Integer num = Integer . valueOf ( " 100 " ) ;
12 Double d = Double . valueOf ( " 3.14 " ) ;
13

14 // Constantes tiles
15 System . out . println ( " M x i m o int : " + Integer . MAX_VALUE ) ; //
2147483647
16 System . out . println ( " M n i m o double : " + Double . MIN_VALUE ) ; // 4.9
E -324
Listing 3: Conversiones entre tipos

4.2.2 Validación de Caracteres

6
 Universidad Central del Ecuador Programación Orientada a Objetos

1 public class ValidarPassword {

2 public static void main ( String [] args ) {
3 String password = " Passw0rd ! " ;
4 boolean tieneMayus = false ;
5 boolean tieneNumero = false ;
6 boolean tieneEspecial = false ;
7

8 for ( char c : password . toCharArray () ) {

9 if ( Character . isUpperCase ( c ) ) tieneMayus = true ;
10 if ( Character . isDigit ( c ) ) tieneNumero = true ;
11 if (! Character . isLetterOrDigit ( c ) ) tieneEspecial =
true ;
12 }
13

14 if ( tieneMayus && tieneNumero && tieneEspecial ) {

15 System . out . println ( " Password v l i d o " ) ;
16 } else {
17 System . out . println ( " Password no cumple requisitos " ) ;
18 }
19 }
20 }
Listing 4: Validación con Character

5 Boxing y Unboxing
5.1 Conceptos Fundamentales
Boxing: Conversión automática de primitivo a wrapper

Unboxing: Conversión automática de wrapper a primitivo

Operación Ejemplo
Boxing Integer num = 42;
Unboxing int valor = num;
Boxing en colecciones [Link](10);
Unboxing en operaciones int suma = [Link](0) + 5;

5.2 Ejemplos Prácticos

1 import java . util . ArrayList ;
2

3 public class EjemploBoxing {

4 public static void main ( String [] args ) {
5 // Boxing a u t o m t i c o en asignaciones
6 Integer numero = 100; // int -> Integer
7

7
 Universidad Central del Ecuador Programación Orientada a Objetos

8 // Unboxing a u t o m t i c o en operaciones
9 int resultado = numero + 50; // Integer -> int
10

11 // Boxing en colecciones
12 ArrayList < Integer > calificaciones = new ArrayList < >() ;
13 calificaciones . add (85) ; // Boxing : int -> Integer
14 calificaciones . add (90) ;
15 calificaciones . add (78) ;
16

17 // Unboxing para calcular promedio

18 double suma = 0;
19 for ( Integer calif : calificaciones ) {
20 suma += calif ; // Unboxing : Integer -> int
21 }
22 double promedio = suma / calificaciones . size () ;
23 System . out . printf ( " Promedio : %.2f %n " , promedio ) ;
24 }
25 }
Listing 5: Boxing y Unboxing en aplicaciones reales

Importante
¡Cuidado con NullPointerException!
1 Integer valorNulo = null ;
2 int valor = valorNulo ; // Error en tiempo de e j e c u c i n

Solución:
1 if ( valorNulo != null ) {
2 int valor = valorNulo ;
3 } else {
4 // Manejar caso nulo
5 }

6 Consideraciones Importantes

8
Universidad Central del Ecuador Programación Orientada a Objetos

6.1 Rendimiento y Buenas Prácticas

Consejo
String vs StringBuilder Para concatenación frecuente:
1 // Ineficiente ( crea m l t i p l e s objetos )
2 String resultado = " " ;
3 for ( int i = 0; i < 1000; i ++) {
4 resultado += i ;
5 }
6

7 // Eficiente
8 StringBuilder sb = new StringBuilder () ;
9 for ( int i = 0; i < 1000; i ++) {
10 sb . append ( i ) ;
11 }
12 String resultado = sb . toString () ;

Consejo

Rendimiento de Boxing/Unboxing En bucles intensivos:

1 // Ineficiente ( boxing en cada i t e r a c i n )
2 List < Integer > lista = new ArrayList < >() ;
3 for ( int i = 0; i < 100000; i ++) {
4 lista . add ( i ) ;
5 }
6

7 // Eficiente ( evitar boxing )

8 int [] arreglo = new int [100000];
9 for ( int i = 0; i < 100000; i ++) {
10 arreglo [ i ] = i ;
11 }

Consejo
Comparación de Wrappers Usar equals() en lugar de ==:
1 Integer a = 1000;
2 Integer b = 1000;
3

4 System . out . println ( a == b ) ; // false ( compara

referencias )
5 System . out . println ( a . equals ( b ) ) ; // true ( compara valores )

9
Universidad Central del Ecuador Programación Orientada a Objetos

7 Conclusión
Los conceptos explorados son fundamentales en Java:

String: Manipulación eficiente de texto con métodos clave

Math: Operaciones matemáticas esenciales

Wrappers: Puente entre primitivos y objetos

Boxing/Unboxing: Conversión automática para simplificar código

Consejo
Consejos:

1. Usa equals() para comparar Strings, no ==

2. Verifica null antes de unboxing

3. Emplea StringBuilder para concatenación frecuente

4. Prefiere primitivos en código crı́tico de rendimiento

5. Conoce los lı́mites de los tipos ([Link] VALUE)

Dominar estos conceptos permite escribir código más eficiente y robusto, preparando
el camino para temas avanzados como colecciones, genéricos y programación funcional.

8 Bibliografı́a
Referencias
[1] Oracle. Java SE 17 & JDK 17 Documentation. 2023. Disponible en:
[Link]

[2] Horstmann, C. S. Core Java Volume I: Fundamentals. 12th Edition. Prentice Hall,
2021.

[3] Bloch, J. Effective Java. 3rd Edition. Addison-Wesley Professional, 2018.

[4] Oracle. The Java Tutorials. 2023. Disponible en:

[Link]

10