Ejercicio JAVA
1. Explíqueme cómo funciona el tipo Map en java y póngame un ejemplo de
uso.
R= Map es una interfaz que nos ayuda a representar una estructura de datos para almacenar pares
“clave/valor”; en la cual cada clave tiene asociado un único valor.
Ejemplo:
import [Link];
import [Link];
public class Ejercicio1 {
public static void main(String[] args) {
// Declaración de un Map (un HashMap) con clave "Integer" y valor "String"
Map<Integer, String> colorMap = new HashMap<>();
// Añadir elementos al Map "clave/valor"
[Link](1, "Azul");
[Link](2, "Verde");
[Link](3, "Rojo");
// Acceder a un valor, en este caso al valor asociado a la clave 2
String color = [Link](2);
[Link]("color asociado a la clave 2: " + color);
// Borrar un elemento, en este caso el elemento con clave 1
[Link](1);
// Comprobar si el Map contiene la clave 3
boolean contieneClave3 = [Link](3);
[Link]("¿Contiene la clave 3? " + contieneClave3);
// Imprimir todos los valores del Map
[Link]("Valores en el Map:");
for (String valor : [Link]()) {
[Link](valor);
2. Explíqueme cómo funciona el patrón Singleton en java.
R= Dentro del Diseño de Software existen diversos tipos de patrones; el patrón Singleton se utiliza
para la restricción de la creación de objetos de una clase a una instancia única; para garantizar que
una clase tenga sólo una instancia y proporciona un acceso global a ella.
3. Implemente la clase puntoImpl, de tal manera que pueda reutilizarse
para diferentes casos, tenga en cuenta todos los métodos genéricos que
suelen crearse para un tipo, como la representación por cadena(String) o el
criterio de igualdad.
R=
// Definimos una la interfaz genérica Punto
interface Punto<T> {
double distancia(Punto<T> otroPunto);
String representacionCadena();
boolean esIgual(Punto<T> otroPunto);
}
// Implementamos la clase PuntoImpl
class PuntoImpl<T> implements Punto<T> {
private T x;
private T y;
public PuntoImpl(T x, T y) {
this.x = x;
this.y = y;
@Override
public double distancia(Punto<T> otroPunto) {
// Cálculo de la distancia entre dos puntos, asumiendo ambos T
return 0.0;
@Override
public String representacionCadena() {
return "(" + x + ", " + y + ")";
@Override
public boolean esIgual(Punto<T> otroPunto) {
// Comparación de igualdad entre dos puntos
return false;
// Ejemplo
public class Main {
public static void main(String[] args) {
Punto<Integer> punto1 = new PuntoImpl<>(3, 4);
Punto<Integer> punto2 = new PuntoImpl<>(6, 8);
[Link]("Punto 1: " + [Link]());
[Link]("Punto 2: " + [Link]());
[Link]("Distancia entre los puntos: " + [Link](punto2));
[Link]("¿Son iguales los puntos? " + [Link](punto2));
4. Créeme la clase puntoHijoImpl que herede de puntoImpl, siendo siempre
puntoHijo un punto con los atributos x=1 e y =1
R=
// Definimos una la interfaz genérica Punto
interface Punto<T> {
double distancia(Punto<T> otroPunto);
String representacionCadena();
boolean esIgual(Punto<T> otroPunto);
}
// Implementamos de la clase PuntoImpl
class PuntoImpl<T> implements Punto<T> {
private T x;
private T y;
public PuntoImpl(T x, T y) {
this.x = x;
this.y = y;
@Override
public double distancia(Punto<T> otroPunto) {
// Cálculo de la distancia entre dos puntos, asumiendo ambos T
return 0.0;
@Override
public String representacionCadena() {
return "(" + x + ", " + y + ")";
@Override
public boolean esIgual(Punto<T> otroPunto) {
// Comparación de igualdad entre dos puntos
return false;
}
}
// Implementamos la clase PuntoHijoImpl
class PuntoHijoImpl extends PuntoImpl<Integer> {
public PuntoHijoImpl() {
super(1, 1); // Siempre x=1 e y=1 para PuntoHijo
// Ejemplo de uso
public class Main {
public static void main(String[] args) {
Punto<Integer> puntoHijo = new PuntoHijoImpl();
[Link]("PuntoHijo: " + [Link]());
}
5. Busque el fallo o fallos y responda a la siguiente pregunta ¿Qué añadiría a
la declaración para que se convirtiesen en constantes?
String cadena = "Abc";
Integer entero = 50;
String nulo = null;
Boolean verdadero = true;
Character caracter = 'x';
Double real = 50.5;
Long real2 = 1; cambiar tipo de dato a int
Float real3 = 0.1; agregar f al final del la sentencia, Float real3 = 0.1f;
R=Se encuentran diversos errores:
En referencia a la Línea “Long real2 = 1; cambiar tipo de dato a int”; ahí se observa un
error de conversión de tipo no válida, al intentar asignar un valor de tipo long a una
variable de tipo int, para que este error no ocurra se debe convertir el valor a int antes de
asignarlo.
En las penúltimas líneas antes de las palabras cambiar y agregar se debe poner // para
indicar que son comentarios dentro de la línea de código.
En la última línea, no se agrega la f al final de la sentencia, “Float real3 = 0.1f”, de acuerdo
con el comentario.
Para convertir las variables en constantes, se debe agregar la palabra clave “final”:
final String cadena = "Abc";
final Integer entero = 50;
final String nulo = null;
final Boolean verdadero = true;
final Character caracter = 'x';
final Double real = 50.5;
final Long real2 = 1; //cambiar tipo de dato a int
final int real2Int = (int) real2;
final Float real3 = 0.1f; //agregar f al final de la sentencia, Float real3 = 0.1f
6. Escriba una expresión lógica que sea cierta si un número entero ‘num’
está comprendido entre 1 y 5 (ambos inclusive) o bien es igual a 9.
R=
int num = /* Asigna aquí el valor del número */;
boolean condicion = (num >= 1 && num <= 5) || num == 9; [respuesta]
7. Explique la diferencia entre igualdad e identidad, ponga ejemplos.
R=
La diferencia entre igualdad (método equals()) e identidad (operador ==); la primera se refiere a
dos objetos que tienen los mismos valores o contenido, estos son iguales cuando sus atributos o
propiedades son idénticos; mientras que identidad se refiere a si dos referencias apuntan al mismo
objeto en memoria; es decir dos referencias son idénticas si apuntan al mismo objeto en la
memoria, se dice que son idénticas.
Ejemplos:
public class IgualdadIdentidad {
public static void main(String[] args) {
// Creamos dos objetos String con el mismo contenido
String p1 = new String("Hola");
String p2 = new String("Hola");
// Igualdad: Verificamos si los contenidos son iguales
boolean igual = [Link](p2);
[Link]("¿p1 es igual a p2? " + igual); // Debería ser true
// Identidad: Verificamos si las referencias son idénticas
boolean identico = (p1 == p2);
[Link]("¿p1 es idéntico a p2? " + identico); // Debería ser false
// Creación de dos referencias al mismo objeto
String p3 = "Hola";
String p4 = p3;
// Identidad: Verificamos si las referencias son idénticas
identico = (p3 == p4);
[Link]("¿p3 es idéntico a p4? " + identico); // Debería ser true
8. Cree un método estático que calcule el máximo de tres números enteros
dados.
R=
public class Maximo {
public static int calcularMaximo(int num1, int num2, int num3) {
// Comparamos num1 con num2 y nos quedamos con el máximo
int maximo = [Link](num1, num2);
// Luego comparamos el máximo anterior con num3 y nos quedamos con el máximo final
maximo = [Link](maximo, num3);
// Retornamos el máximo de los tres números
return maximo;
public static void main(String[] args) {
// Ejemplo de uso del método calcularMaximo
int max = calcularMaximo(10, 5, 8);
[Link]("El máximo de los tres números es: " + max);
9. Añada al método anterior una captura de excepción con
IllegalArgumentException en el caso de que uno de los enteros sea mayor
que 10.
R=
public class Maximo {
public static int calcularMaximo(int num1, int num2, int num3) {
// Comprobamos si alguno de los enteros es mayor que 10
if (num1 > 10 || num2 > 10 || num3 > 10) {
throw new IllegalArgumentException("Los números no pueden ser mayores que 10");
// Comparamos num1 con num2 y nos quedamos con el máximo
int maximo = [Link](num1, num2);
// Luego comparamos el máximo anterior con num3 y nos quedamos con el máximo final
maximo = [Link](maximo, num3);
// Retornamos el máximo de los tres números
return maximo;
public static void main(String[] args) {
try {
// Ejemplo de uso del método calcularMaximo
int max = calcularMaximo(10, 5, 8);
[Link]("El máximo de los tres números es: " + max);
} catch (IllegalArgumentException e) {
[Link]("Error: " + [Link]());
10. ¿Explíqueme que es una variable estática y póngame el ejemplo de una?
R=Una variable estática, es una variable que pertenece a la clase a ala que se declara y se
inicializan solamente una vez al inicio de la ejecución del programa; no están asociadas a objetos
específicos (instancias), sino que son compartidas por todas las instancias de la clase; en síntesis,
una variable estática pertenece a la clase y no al objeto y se puede acceder a ella directamente por
el nombre de la clase, sin necesidad de crear un objeto.
Ejemplo:
public class VariablesMetodosEstaticos {
static int contador = 0; // Variable estática
public static void main(String[] args) {
incrementarContador();
[Link]("Contador: " + contador);
// Creación de dos objetos de la clase MiClase
MiClase objeto1 = new MiClase();
MiClase objeto2 = new MiClase();
[Link]();
[Link]();
[Link]("Valor de instancia en objeto1: " + [Link]);
[Link]("Valor de instancia en objeto2: " + [Link]);
static void incrementarContador() {
contador++;
class MiClase {
int valorInstancia = 0; // Variable de instancia
void incrementarInstancia() {
valorInstancia++;
}
11. Escriba el método public static SortedMap cuentaPalabras(String frase)
Escriba el método public static SortedMap cuentaPalabras(String frase) ue
recibe una cadena de caracteres que representa una frase y devuelve una
función ordenada que hace corresponder a cada palabra de la frase (una vez
convertida a minúsculas) la frecuencia de aparición de esa palabra en la frase.
Las claves (las palabras del texto) siguen el orden natural de las palabras.
Utilícese la cadena " " como delimitador en el método split de String. Por
ejemplo, si la cadena de entrada es "El estribillo de una chirigota de Cádiz es
Como como como como estoy como estoy" la función devuelta debe ser:
{chirigota=1, como=5, cádiz=1, de=2, el=1, es=1, estoy=2, estribillo=1,
una=1} Obsérvese que las palabras están en orden alfabético (las vocales con
tilde van detrás de las vocales sin tilde en el orden alfabético de las cadenas
en Java).
R=
import [Link].*;
import [Link];
import [Link];
import [Link];
public class Main{
public static SortedMap<String, Integer> cuentaPalabras(String frase) {
// Convertir la frase a minúsculas y dividir en palabras usando espacios como delimitador
String[] palabras = [Link]().split(" ");
// Crear un mapa para almacenar el conteo de palabras
Map<String, Integer> conteoPalabras = new HashMap<>();
// Recorrer cada palabra
for (String palabra : palabras) {
// Verificar si la palabra ya está en el mapa
if ([Link](palabra)) {
// Si existe, incrementar su conteo
[Link](palabra, [Link](palabra) + 1);
} else {
// Si no existe, agregarla al mapa con conteo 1
[Link](palabra, 1);
// Convertir el mapa en un SortedMap ordenado por clave (alfabéticamente)
SortedMap<String, Integer> palabrasOrdenadas = new TreeMap<>(conteoPalabras);
// Devolver el SortedMap con el conteo de palabras
return palabrasOrdenadas;
public static void main(String[] args) {
String frase = "El estribillo de una chirigota de Cádiz es Como como como como estoy como
estoy";
SortedMap<String, Integer> conteoPalabras = cuentaPalabras(frase);
for ([Link]<String, Integer> entrada : [Link]()) {
[Link]([Link]() + ": " + [Link]());
}
}
12. Dado el siguiente código, ¿podrías explicar con tus palabras cómo funciona el tipo
“ParameterTable”?
R=
En los fragmentos de códigos anteriores, mi perspectiva es que el ParameterTable actúa como una
interfaz, la cual en el primer fragmento de código ayuda a obtener la información (de Personas) de
un arreglo en forma de listado en una tabla y posteriormente en el segundo fragmento de código
mapea y estructura la información para que sea insertada en “UUAAT099” mediante un arreglo en
forma de lista y evalúa si el valor es nulo o está vacío para posteriormente insertar la información.