Ejemplos de Código Java para Tareas Comunes
Método para Invertir una Cadena en Java
Este método toma una cadena de texto y devuelve una nueva cadena con los caracteres en orden inverso.
public String invertirCadena(String s) {
String resultado = "";
if (s == null) {
return null; // O manejar como se prefiera
}
for (int i = s.length() - 1; i >= 0; i--) {
resultado = resultado + s.charAt(i);
}
return resultado;
}
Método para Invertir un Array en Java
Este método invierte los elementos de un array de cadenas in situ (modifica el array original).
public void invertirArray(String[] a) {
if (a == null) {
return; // No se puede invertir un array nulo
}
String auxiliar;
for (int i = 0; i < a.length / 2; i++) {
auxiliar = a[i];
a[i] = a[a.length - 1 - i];
a[a.length - 1 - i] = auxiliar;
}
}
Combinar Sets de Enteros Positivos en Java
Este método recibe dos conjuntos (Sets) de enteros y devuelve una lista con los enteros que están presentes en ambos conjuntos y son mayores que cero.
import java.util.*;
public class Ejercicio01A {
public List<Integer> enterosEnAmbos(Set<Integer> s1, Set<Integer> s2) {
List<Integer> resultado = new ArrayList<>();
if (s1 == null || s2 == null) {
return null; // O devolver lista vacía: return new ArrayList<>();
}
for (Integer i : s1) {
if (i != null && i > 0 && s2.contains(i)) {
resultado.add(i);
}
}
// Opcionalmente, ordenar el resultado
// Collections.sort(resultado);
return resultado;
}
}
Calcular Importe Total desde Arrays en Java
Este método calcula un importe total basado en arrays paralelos de materiales y cantidades. Asume que existe una clase Material con un método getPrecio().
import java.util.*;
// Asumiendo que existe una clase Material como esta:
/*
class Material {
private double precio;
// constructor, otros campos...
public double getPrecio() {
return precio;
}
}
*/
public class Ejercicio01B {
public double calcularImporte(Material[] materiales, int[] cantidades) {
double resultado = 0;
if (materiales == null || cantidades == null) {
return -1; // Error: arrays nulos
}
if (materiales.length != cantidades.length) {
return -2; // Error: arrays de diferente longitud
}
for (int i = 0; i < materiales.length; i++) {
if (materiales[i] != null) { // Comprobar si el material no es nulo
resultado += materiales[i].getPrecio() * cantidades[i];
} else {
// Decidir cómo manejar materiales nulos (¿ignorar? ¿error?)
// return -3; // Ejemplo: Error si hay material nulo
}
}
return resultado;
}
}
Uso de GregorianCalendar en Java
Este ejemplo lee una fecha del usuario, la representa con GregorianCalendar y luego muestra las tres fechas siguientes, incrementando de 10 en 10 días.
import java.io.*;
import java.util.*;
public class Ejercicio01C {
public void run() throws Exception {
final String[] nombreMes = {"Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"};
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int dia, mes, anno;
String entrada;
GregorianCalendar fecha = null;
System.out.print("Dame una fecha [dd/mm/aaaa]: ");
entrada = in.readLine();
try {
// Opción 1: Usando Scanner
/*
Scanner sc = new Scanner(entrada).useDelimiter("/");
dia = sc.nextInt();
mes = sc.nextInt();
anno = sc.nextInt();
sc.close();
*/
// Opción 2: Usando split (más robusto si hay espacios)
String[] partes = entrada.split("/");
if (partes.length == 3) {
dia = Integer.parseInt(partes[0].trim());
mes = Integer.parseInt(partes[1].trim()); // Mes es 1-based aquí
anno = Integer.parseInt(partes[2].trim());
// GregorianCalendar usa mes 0-based (0=Enero, 1=Febrero...)
fecha = new GregorianCalendar(anno, mes - 1, dia);
} else {
System.out.println("Formato de fecha incorrecto.");
return;
}
} catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
System.out.println("Error al parsear la fecha: " + e.getMessage());
return;
}
System.out.println("Fechas incrementadas en 10 días:");
for (int i = 1; i <= 3; i++) {
fecha.add(Calendar.DATE, 10);
System.out.format("%d de %s de %d%n",
fecha.get(Calendar.DATE),
nombreMes[fecha.get(Calendar.MONTH)],
fecha.get(Calendar.YEAR));
}
}
// Para poder ejecutarlo
public static void main(String[] args) throws Exception {
new Ejercicio01C().run();
}
}
Ejemplo de Encapsulamiento con Sprites en Java
Una clase simple Sprite que demuestra encapsulamiento con coordenadas (x, y) y un límite estático (maxX).
public class Sprite {
private double x, y;
private static double maxX = 500; // Valor inicial por defecto
// Bloque estático opcional para inicializar maxX si es necesario
// static {
// maxX = 500;
// }
public Sprite() {
this.x = 0;
this.y = 0;
}
public Sprite(double x, double y) {
// Se podría añadir validación aquí si x > maxX
this.x = x;
this.y = y;
}
public static double getMaxX() {
return maxX;
}
public static void setMaxX(double maxX) {
// Se podría añadir validación para maxX (e.g., > 0)
Sprite.maxX = maxX;
}
public double getX() {
return x;
}
public void setX(double x) {
// Se podría añadir validación aquí si x > maxX
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
/**
* Mueve el sprite.
* @param ix incremento de x
* @param iy incremento de y
* @return nueva posición [x, y], o null si el nuevo valor de x excede el máximo permitido.
*/
public double[] mover(double ix, double iy) {
double nuevaX = x + ix;
if (nuevaX > maxX) {
return null; // O lanzar una excepción, o no mover
}
x = nuevaX;
y += iy;
return new double[]{x, y};
}
}
Filtrar Lista de Cadenas con ‘F’ en Java
Este programa lee cadenas de texto del usuario hasta que introduce “fin”, las almacena en una lista y luego crea una nueva lista que contiene solo las cadenas originales que incluyen la letra ‘F’ (mayúscula o minúscula).
import java.util.*;
import java.io.*;
public class App08A04 {
BufferedReader in;
public App08A04() {
in = new BufferedReader(new InputStreamReader(System.in));
}
public List<String> queContengaUnaF(List<String> unaLista) {
List<String> listaResultado = new ArrayList<>();
if (unaLista == null) return listaResultado; // Devolver lista vacía si la entrada es nula
for (String s : unaLista) {
if (s != null && s.toUpperCase().contains("F")) { // contains es más idiomático que indexOf >= 0
listaResultado.add(s);
}
}
return listaResultado;
}
public void run() throws Exception {
List<String> miLista = new ArrayList<>();
List<String> listaDeCadenasConF;
boolean esElCentinela;
System.out.println("Dame cadenas, y termina con \"fin\" cuando te canses");
do {
System.out.print("Cadena: ");
String s = in.readLine();
if (s == null) { // Manejar fin de stream inesperado
esElCentinela = true;
} else {
esElCentinela = s.equalsIgnoreCase("fin"); // Ignorar mayúsculas/minúsculas para "fin"
if (!esElCentinela) {
miLista.add(s);
}
}
} while (!esElCentinela);
System.out.print("La lista original: ");
for (int i = 0; i < miLista.size(); i++) {
System.out.print(miLista.get(i) + (i < miLista.size() - 1 ? ", " : ""));
}
System.out.println(); // Nueva línea
listaDeCadenasConF = queContengaUnaF(miLista);
System.out.print("La lista filtrada (contiene 'F'): ");
for (int i = 0; i < listaDeCadenasConF.size(); i++) {
System.out.print(listaDeCadenasConF.get(i) + (i < listaDeCadenasConF.size() - 1 ? ", " : ""));
}
System.out.println(); // Nueva línea
}
public static void main(String[] args) throws Exception {
new App08A04().run();
}
}
Invertir Array Devolviendo Copia en Java
Este método crea y devuelve una nueva copia invertida de un array de cadenas, sin modificar el original.
public String[] invertirArrayInvertido(String[] a) {
if (a == null) {
return null; // No se puede invertir un array nulo
}
String[] resultado = new String[a.length];
for (int i = 0; i < a.length; i++) {
resultado[i] = a[a.length - 1 - i];
}
return resultado;
}
Validación de Parentización con Pilas en Java
Este programa utiliza una pila (Deque) para verificar si una expresión dada por el usuario tiene los paréntesis, corchetes y llaves correctamente balanceados y anidados.
import java.util.*;
import java.io.*;
public class AppParentizacion {
public boolean estaBienParentizado(String expr) {
if (expr == null) return true; // O false, según la definición
Deque<Character> pila = new ArrayDeque<>();
boolean bienParentizado = true;
int indice = 0;
while (bienParentizado && indice < expr.length()) {
char c = expr.charAt(indice);
if (c == '(' || c == '[' || c == '{') {
pila.push(c);
} else if (c == ')') {
if (pila.isEmpty() || pila.pop() != '(') {
bienParentizado = false;
}
} else if (c == ']') {
if (pila.isEmpty() || pila.pop() != '[') {
bienParentizado = false;
}
} else if (c == '}') {
if (pila.isEmpty() || pila.pop() != '{') {
bienParentizado = false;
}
}
// Ignorar otros caracteres
indice++;
}
// Al final, la pila debe estar vacía para que esté bien parentizado
return bienParentizado && pila.isEmpty();
}
public void run() throws Exception {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String expr;
boolean esElCentinela;
System.out.println("Introduce expresiones para verificar parentización (o 'fin' para salir):");
do {
System.out.print("Expresión: ");
expr = in.readLine();
if (expr == null) {
esElCentinela = true;
} else {
esElCentinela = expr.equalsIgnoreCase("fin");
if (!esElCentinela) {
System.out.println(expr + (estaBienParentizado(expr) ? " --> OK" : " --> INCORRECTO"));
}
}
} while (!esElCentinela);
System.out.println("Adiós");
}
public static void main(String[] args) throws Exception {
new AppParentizacion().run();
}
}
Uso de Map para Contar Ciudades en Java
Este programa lee nombres de ciudades introducidos por el usuario y utiliza un Map para contar cuántas veces se introduce cada nombre, hasta que el usuario escribe “fin”.
import java.util.*;
public class MainCiudades {
public static void main(String[] args) { // Firma estándar de main
Scanner in = new Scanner(System.in);
Map<String, Integer> mapas = new HashMap<>();
String nombre;
boolean centinela;
System.out.println("Dame el nombre de las ciudades (escribe 'fin' para terminar):");
do {
System.out.print("Ciudad: ");
nombre = in.nextLine();
centinela = nombre.equalsIgnoreCase("fin");
if (!centinela) {
if (!nombre.trim().isEmpty()) { // Evitar contar entradas vacías
// Incrementar el contador para la ciudad
// Opción 1: getOrDefault
// mapas.put(nombre, mapas.getOrDefault(nombre, 0) + 1);
// Opción 2: containsKey
if (!mapas.containsKey(nombre)) {
// System.out.println("El nombre no está, introduciéndolo."); // Mensaje opcional
mapas.put(nombre, 1);
} else {
// System.out.println("El nombre está en el Map, incrementando contador."); // Mensaje opcional
mapas.put(nombre, mapas.get(nombre) + 1);
}
} else {
System.out.println("Nombre vacío ignorado.");
}
}
} while (!centinela);
System.out.println("Adiós");
System.out.println("Recuento final de ciudades:");
// Imprimir el map de forma más legible
if (mapas.isEmpty()) {
System.out.println("No se introdujo ninguna ciudad.");
} else {
for (Map.Entry<String, Integer> entry : mapas.entrySet()) {
System.out.format(" %s: %d veces%n", entry.getKey(), entry.getValue());
}
}
// System.out.format("Contenido del Map: %s%n", mapas); // Imprime el map directamente
in.close(); // Cerrar el Scanner
}
}
Clasificar Palabras con Sets en Java
Este programa lee palabras del usuario. Utiliza conjuntos (Set) predefinidos de frutas y verduras para clasificar cada palabra. Las palabras no clasificadas se almacenan en otro conjunto y al final se comprueba si alguna de las desconocidas contiene la letra ‘z’.
import java.io.*;
import java.util.*;
public class App08D03 {
public void run() throws Exception {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
boolean esElCentinela;
boolean encontradoZ = false; // Renombrado para claridad
// Usar Sets para búsqueda eficiente (contains es O(1) en promedio)
Set<String> frutas = new HashSet<>(Arrays.asList("pera", "manzana", "naranja"));
Set<String> verduras = new HashSet<>(Arrays.asList("tomate", "pepino", "apio", "lechuga"));
Set<String> desconocidas = new HashSet<>();
System.out.println("Introduzca palabras seguidas de ENTER. Termine con 'fin':");
do {
System.out.print("Palabra: ");
String s = in.readLine();
if (s == null) {
esElCentinela = true; // Fin de stream
} else {
s = s.trim().toLowerCase(); // Normalizar entrada
esElCentinela = s.equals("fin");
if (!esElCentinela && !s.isEmpty()) {
if (frutas.contains(s)) {
System.out.println("--> fruta");
} else if (verduras.contains(s)) {
System.out.println("--> verdura");
} else {
System.out.println("--> desconocida");
desconocidas.add(s);
}
}
}
} while (!esElCentinela);
System.out.print("--> Introdujiste las siguientes palabras desconocidas: ");
if (desconocidas.isEmpty()) {
System.out.println("(ninguna)");
} else {
// Imprimir lista de desconocidas
StringJoiner sj = new StringJoiner(", ");
for (String d : desconocidas) {
sj.add(d);
}
System.out.println(sj.toString());
// Buscar 'z' en las desconocidas
Iterator<String> iter = desconocidas.iterator();
while (iter.hasNext() && !encontradoZ) {
String desconocida = iter.next();
if (desconocida.contains("z")) { // contains es más simple que indexOf >= 0
encontradoZ = true;
}
}
}
System.out.format("%s he encontrado una palabra desconocida que tenga una 'z'.%n",
encontradoZ ? "Sí," : "No,");
}
public static void main(String[] args) throws Exception {
new App08D03().run();
}
}
Ejemplo Básico de Javadoc
Un comentario Javadoc simple describiendo parámetros y valor de retorno.
/**
* Descripción breve del método.
*
* @param datosDeEntrada Descripción del parámetro de entrada.
* @return Descripción de lo que devuelve el método.
*/
public int miMetodo(String datosDeEntrada) {
// ... código del método ...
return 0; // Valor de ejemplo
}