Categoría: Java

Más ejercicios cadenas resueltos

static int contarLetra(String cadena, char letra) {
		int total = 0;
		for (int i = 0; i < cadena.length(); i++) {
			if (cadena.charAt(i) == letra) {
				total++;
			}
		}
		return total;
	}

	static int contarVocales(String cadena) {
		cadena = quitarAcentos(cadena.toLowerCase());
		String vocales = "aeiou";
		int total = 0;
		for (int i = 0; i < vocales.length(); i++) {
			total += contarLetra(cadena, vocales.charAt(i));
		}
		return total;
	}

	static String sinEspacios(String cadena) {
		cadena = cadena.trim();
		while (cadena.indexOf("  ") != -1) {
			cadena = cadena.replace("  ", " ");
		}
		return cadena;
	}

	static int contarChar(String cadena, char letra) {
		int total = 0;
		for (int i = 0; i < cadena.length(); i++) {
			if (cadena.charAt(i) == letra) {
				total++;
			}
		}
		return total;
	}

	static String eliminar(String cadena, String cadenaEliminar) {
		return cadena.replace(cadenaEliminar, "");
	}

	static String cambiar(String cadena, char antiguo, char nuevo) {
		return cadena.replace(antiguo, nuevo);
	}

Ejercicios cadenas resueltos

public static void main(String[] args) {
		// Escribir una función que invierta el orden de los caracteres 
		// de una cadena dada. invertir("hola")–>"aloh"
		String alreves=invertirCadena("cacahuete");
		System.out.println(alreves);
		if (esPalindromo("Isaac no ronca así")) {
			System.out.println("Es palindromo");
		}
		
		System.out.println(quitarAcentos("áéíóúàèìòùäëïöü"));
		// Saber si una cadena es un palíndromo
		// Se lee lo mismo al derecho que al revés
		// dabalearrozalazorraelabad
		// dabalearrozalazorraelabad
		// Sé dar la vuelta: Lo acabo de hacer
		// Sé quitar espacios: replace(" ", "")
		
		
		// quitar acentos que nos sustituya vocales acentuadas
		// por vocales sin acento
		// puedo reemplazar cada vocal acentuada por la sin acentuar
		
		
		// Tengo un problema: hay que encontrar el algoritmo
		// ¿Cómo lo hago yo?
		// Divide y vencerás: El problema grande se convierte
		// En problemas más pequeños
	}
	
	public static String quitarAcentos(String cadena) {
		String acentos="áéíóúàèìòùäëïöü";
		String sinacentos="aeiou";
		for(int i=0;i<acentos.length();i++) {
			cadena=cadena.replace(acentos.charAt(i),
					sinacentos.charAt(i%5)); // Aritmética modular
		}
		
		return cadena;
	}
	public static boolean esPalindromo(String cadena) {
		cadena=cadena.replace(" ","");
		cadena=quitarAcentos(cadena);
		return cadena.equalsIgnoreCase(invertirCadena(cadena));
	}
	public static String invertirCadena(String cadena) {
		// cacahuete -> eteuhacac
		// empiezo por el final, voy letra a letra y escribo cada letra
		// ¿Se empezar e ir letra a letra? Sí con un for
		// Se añadir esas letras a un resultado: sí, concatenando
		String res="";
		for(int i=cadena.length()-1;i>=0;i--) {
			res+=cadena.charAt(i);
		}
		return res;
	}

Strings en Java

// Definir cadenas
		String nombre="Ana";
		String departamento="marketing";
		System.out.println(nombre+" "+ departamento);
		nombre="Eva";
		System.out.println(nombre+" "+ departamento);
		// Estas tres cadenas valen lo mismo
		String alumno1="Ana";
		String alumno2=alumno1;
		String alumno3="Ana";
		Scanner sc=new Scanner(System.in);
		String alumno4=sc.next();
		if (alumno1==alumno2) {
			System.out.println("Alumno 1 es igual al 2");
		}
		if (alumno1==alumno3) {
			System.out.println("Alumno 1 es igual al 3");
		}
		if (alumno1==alumno4) {
			System.out.println("Alumno 1 es igual al 4");
		}
		// Todo este rollo es para que enendáis que si quiero
		// comprobar que dos cadenas son iguales
		// Tengo que usar equals
		if (alumno1.equals(alumno4)) {
			System.out.println("Alumno 1 es igual al 4");
		}
		
		// en un tipo primitivo el nombre es una caja
		// En la que meto el valor
		int edad=5;
		
		//En los que no son primitivos (casi todos)
		// El nombre es una caja donde está la
		// posición de memoria donde está el valor
		String aula="Mates";

		System.out.println("Dime tu ciudad");
		String ciudad=sc.next();
		// Comprobar si una cadena es igual a otra
		// siempre uso equals
		if (ciudad.equals("barcelona")) {
			System.out.println("Eres de Barcelona");
		}
		// length es una de las muchas funciones
		// de la clase string
		System.out.println(ciudad.length());
		
		// charAt(posicion) el caracter en esa posición
		String referencia="ABCDE";
		System.out.println(referencia.charAt(0)); // La A
		// Esto me recorre todas las letras de la cadena
		for (int i=0;i<referencia.length();i++) {
			System.out.println(referencia.charAt(i));
		}
		
		System.out.println(referencia.charAt(referencia.length()-1));// Último caracter
		
		for (int i=0;i<referencia.length();i++) {
			System.out.println(referencia.charAt(referencia.length()-i-1));
		}
		// Obtener subcadenas de una cadena
		// substring(int beginIndex, int endIndex)
		for (int i=0;i<referencia.length();i++) {
			System.out.println(referencia.substring(i));
		}
		for (int i=0;i<referencia.length();i++) {
			System.out.println(referencia.substring(0,i+1));
		}
		
		// Buscar una cadena dentro de otra
		// Si la encuentra nos devuelve la posición
		// Si no la encuentra nos devuelve -1
		
		String quijote="En un lugar de la mancha de cuyo nombre no quiero acordarme";
		System.out.println(quijote.indexOf(" mancha")); // 18
		System.out.println(quijote.indexOf("messi")); // -1 porque no lo ha encontrado
		System.out.println(quijote.indexOf("de")); // 12
		System.out.println(quijote.indexOf("de",13)); // 25
		int pos1=quijote.indexOf("de"); //12
		int pos2=quijote.indexOf("de", pos1+1); //25
		
		// Me busca todas las apariciones de la cadena buscar
		// Dentro de quijote
		String buscar="de";
		int pos=quijote.indexOf(buscar);
		while(pos!=-1) {
			System.out.println(pos);
			pos=quijote.indexOf(buscar, pos+1);
		}
		
		// Reemplazar una cadena por otra
		// replace(CharSequence target, CharSequence replacement)
		
		String censura=quijote.replace("mancha", "###");
		System.out.println(censura);
		String noespacios=quijote.replace(" ", "");
		System.out.println(noespacios);
		
		// Convertir a mayúsculas y a minúsculas
		// toUpperCase() y toLowerCase()
		
		System.out.println(quijote.toUpperCase());
		System.out.println(quijote.toLowerCase());
		ciudad="  barcelona";
		if (ciudad.trim().toLowerCase().equals("barcelona")) {
			System.out.println("Eres de Barcelona");
		}
		if (ciudad.equalsIgnoreCase("barcelona")) {
			System.out.println("Eres de Barcelona");
		}
		ciudad.endsWith("a"); //Acaba en la letra a
		ciudad.startsWith("a"); // Empieza con a
		ciudad.trim(); // Elimina los espacios del principio y del final

Ejercicio Hibernate

Con lo que hemos visto del enlace anterior vamos a crear en esa misma aplicación una api REST para dar mantenimiento a los países de la bd de trifulcas. Campos:

country_id
country
last_update

El last_update es de la base de datos, lo podemos obviar en nuestro POJO.

Una vez funcione la API podemos crear un mantenimiento web usando MVC. El controlador será un servlet que pasará los datos a una página JSP. Si en la página JSP usamos JSTL (https://github.com/juanpfuentes/Java/blob/main/src/java/jstl.md) todo irá mejor.
¡Ánimo!

Crear la API

Añadimos la siguiente dependencia:

<dependency>
			<groupId>org.json</groupId>
			<artifactId>json</artifactId>
			<version>20220924</version>
		</dependency>

Mapeamos el servlet, creamos un actorDAO para acceder a los datos e implementamos el get:

@WebServlet("/Api/*")
public class Api extends HttpServlet {
	private static final long serialVersionUID = 1L;
	private ActorDAO actorDAO;

	/**
	 * @see HttpServlet#HttpServlet()
	 */
	public Api() {
		super();
		actorDAO = new ActorDAO();
	}

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
	 *      response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		try {
			String id = request.getPathInfo();
			System.out.println(id);
			if (id == null) {
				List<Actor> actores = actorDAO.getActors();
				JSONArray actoresJSON = new JSONArray(actores);
				response.getWriter().append(actoresJSON.toString());
			} else {
				int idActor = Integer.parseInt(id.substring(1));
				Actor actor = actorDAO.getActor(idActor);
				JSONObject actorJSON = new JSONObject(actor);
				response.getWriter().append(actorJSON.toString());
			}
		} catch (Exception ex) {
			JSONObject mensaje = new JSONObject();
			mensaje.put("Mensaje", "Error en la petición");
			mensaje.put("Error", ex);
			response.getWriter().append(mensaje.toString());
		}
	}

EL POST:

protected void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// Me mandarán los valores del actor en formato JSON
		// Tendré que insertarlo en la BD
		JSONObject mensaje = new JSONObject();
		try {
			String data = request.getReader().lines().collect(Collectors.joining());
			JSONObject actorJSON = new JSONObject(data);

			Actor actor = new Actor(0, actorJSON.getString("first_name"), actorJSON.getString("last_name"), null);

			if (actorDAO.addActor(actor)) {
				mensaje.put("Mensaje", "Actor insertado con éxito");
			} else {
				mensaje.put("Mensaje", "Error en la inserción");
			}
			response.getWriter().append(mensaje.toString());
		} catch (Exception ex) {
			mensaje.put("Mensaje", "Error en la petición");
			mensaje.put("Error", ex);
			response.getWriter().append(mensaje.toString());
		}
	}

DAO Actor

Para tener acceso a datos tenemos que tener un POJO que nos represente la entidad y un DAO para las operaciones comunes.

package com.trifulcas.dao;

import java.sql.Date;

public class Actor {

	private int actor_id;
	private String first_name;
	private String last_name;
	private Date last_update;
	
	public Actor(int actor_id, String first_name, String last_name, Date last_update) {
		this.actor_id = actor_id;
		this.first_name = first_name;
		this.last_name = last_name;
		this.last_update = last_update;
	}
	
	/**
	 * @return the actor_id
	 */
	public int getActor_id() {
		return actor_id;
	}
	/**
	 * @param actor_id the actor_id to set
	 */
	public void setActor_id(int actor_id) {
		this.actor_id = actor_id;
	}
	/**
	 * @return the first_name
	 */
	public String getFirst_name() {
		return first_name;
	}
	/**
	 * @param first_name the first_name to set
	 */
	public void setFirst_name(String first_name) {
		this.first_name = first_name;
	}
	
	/**
	 * @return the last_name
	 */
	public String getLast_name() {
		return last_name;
	}
	/**
	 * @param last_name the last_name to set
	 */
	public void setLast_name(String last_name) {
		this.last_name = last_name;
	}
	/**
	 * @return the last_update
	 */
	public Date getLast_update() {
		return last_update;
	}
	/**
	 * @param last_update the last_update to set
	 */
	public void setLast_update(Date last_update) {
		this.last_update = last_update;
	}
	
	public String toString() {
		return actor_id+" | "+first_name+" | "+last_name+" | "+last_update;
	}
	
}

Para acceder a los datos:

public class ActorDAO {

	private Connection con;
	private int max_records = 1000;

	public ActorDAO() {
		try {
			Class.forName("com.mysql.cj.jdbc.Driver");
			con = DriverManager.getConnection("jdbc:mysql://localhost:3306/sakila", "root", "");

		} catch (Exception ex) {
			System.out.println(ex);
		}
	}

	public Actor getActor(int id) {
		Actor res = null;
		try {
			String sql = "select * from actor where actor_id=?";
			PreparedStatement stmt = con.prepareStatement(sql);

			stmt.setInt(1, id);

			ResultSet rs = stmt.executeQuery();
			if (rs.next()) {
				res = new Actor(rs.getInt("actor_id"), rs.getString("first_name"), rs.getString("last_name"),
						rs.getDate("last_update"));
			}

		} catch (Exception ex) {
			System.out.println(ex);
		}
		return res;
	}

	public List<Actor> getActors(int limite) {
		List<Actor> res = new ArrayList<Actor>();
		try {
			String sql = "select * from actor limit ?";
			PreparedStatement stmt = con.prepareStatement(sql);
			stmt.setInt(1, limite);
			ResultSet rs = stmt.executeQuery();
			while (rs.next()) {
				Actor temp = new Actor(rs.getInt("actor_id"), rs.getString("first_name"), rs.getString("last_name"),
						rs.getDate("last_update"));
				res.add(temp);
			}

		} catch (Exception ex) {
			System.out.println(ex);
		}
		return res;
	}
	
	/**
	 * Devuelve un arraylist de actores cuyo apellido contenga la cadena que le pasamos
	 * @param cad cadena a buscar
	 * @return ArrayList de actores
	 */
	public List<Actor> getActors(String cad) {
		List<Actor> res = new ArrayList<Actor>();
		try {
			String sql = "select * from actor where last_name like ?";
			PreparedStatement stmt = con.prepareStatement(sql);
			stmt.setString(1, '%'+cad+'%');
			ResultSet rs = stmt.executeQuery();
			while (rs.next()) {
				Actor temp = new Actor(rs.getInt("actor_id"), rs.getString("first_name"), rs.getString("last_name"),
						rs.getDate("last_update"));
				res.add(temp);
			}

		} catch (Exception ex) {
			System.out.println(ex);
		}
		return res;
	}

	public List<Actor> getActors() {
		return getActors(max_records);
	}

	public boolean addActor(Actor actor) {
		try {
			String sql = "insert into actor (first_name, last_name) values (?,?)";
			PreparedStatement stmt = con.prepareStatement(sql);
			stmt.setString(1, actor.getFirst_name());
			stmt.setString(2, actor.getLast_name());
			int res = stmt.executeUpdate();
			return res == 1;
		} catch (Exception ex) {
			System.out.println(ex);
		}
		return false;
	}

	public boolean updateActor(Actor actor) {
		try {
			String sql = "update actor set first_name=?, last_name=? where actor_id=?";
			PreparedStatement stmt = con.prepareStatement(sql);
			stmt.setString(1, actor.getFirst_name());
			stmt.setString(2, actor.getLast_name());
			stmt.setInt(3, actor.getActor_id());
			int res = stmt.executeUpdate();
			return res == 1;
		} catch (Exception ex) {
			System.out.println(ex);
		}
		return false;
	}

	public boolean deleteActor(Actor actor) {
		try {
			if (actor != null) {
				return deleteActor(actor.getActor_id());
			}
		} catch (Exception ex) {
			System.out.println(ex);
		}
		return false;
	}

	public boolean deleteActor(int actor_id) {
		try {
			String sql = "delete from actor where actor_id=?";
			PreparedStatement stmt = con.prepareStatement(sql);
			stmt.setInt(1, actor_id);
			int res = stmt.executeUpdate();
			return res == 1;
		} catch (Exception ex) {
			System.out.println(ex);
		}
		return false;
	}

}

Podemos probarlo en el main de una clase cualquiera:

public static void main(String[] args) {
         
        // He abstraído la base de datos
        ActorDAO bd=new ActorDAO();
         
        Actor penelope=bd.getActor(1);
         
        System.out.println(penelope.getFirst_name());
 
        List<Actor> actores=bd.getActors();
        for(Actor actor:actores) {
            System.out.println(actor);
        }
         
        Actor nuevo=new Actor(1,"w","e",null);
    }

Crear una página web dinámica que use un servlet

1.- Creo un proyecto Maven con el arquetipo webapp
2.- Añado las siguientes dependencias en el POM:

	<dependency>
			<groupId>jakarta.servlet</groupId>
			<artifactId>jakarta.servlet-api</artifactId>
			<version>6.0.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
		<dependency>
			<groupId>jakarta.servlet.jsp.jstl</groupId>
			<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
			<version>2.0.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.glassfish.web/jakarta.servlet.jsp.jstl -->
		<dependency>
			<groupId>org.glassfish.web</groupId>
			<artifactId>jakarta.servlet.jsp.jstl</artifactId>
			<version>3.0.1</version>
		</dependency>

3.- Dentro de la carpeta ‘src/main’ creo una carpeta java
4.- Al crear esa carpeta nos sale arriba ‘Java Resources’
5.- Creamos ahí un paquete para poner nuestras clases. Por ejemplo ‘com.trifulcas.controller’
6.- Dentro de este paquete botón derecho ‘New->Servlet’
7.- Ponemos el enrutamiento con ‘@WebServlet(“/ruta_del_servlet”)’
8. Ejecutamos en servidor y al poner la ruta debería escribirse un mensaje que es el que tiene el servlet por defecto.

Dependencias Servlet

Tenemos que poner esto en el POM:

	<dependency>
			<groupId>jakarta.servlet</groupId>
			<artifactId>jakarta.servlet-api</artifactId>
			<version>6.0.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
		<dependency>
			<groupId>jakarta.servlet.jsp.jstl</groupId>
			<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
			<version>2.0.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.glassfish.web/jakarta.servlet.jsp.jstl -->
		<dependency>
			<groupId>org.glassfish.web</groupId>
			<artifactId>jakarta.servlet.jsp.jstl</artifactId>
			<version>3.0.1</version>
		</dependency>

https://github.com/juanpfuentes/Java/blob/main/src/java/servlet.md

JSTL:

https://www.javatpoint.com/jstl

Ejercicio mini web

Vamos a crear una miniweb con lo siguiente:

Al entrar nos aparecerá una página de login con usuario y contraseña:

Usuario:[ ]
Password:[ ]
[Enviar]

Si el usuario no es ‘admin’ ‘admin’ nos vuelve a la página de login.
Si es ‘admin’ ‘admin’ nos sale una página con estos enlaces:

Tabla de multiplicar
Numero mayor

Si pinchan en tabla de multiplicar nos sale una página con lo siguiente:
Número[ ]
[Enviar]

Si nos introducen un número en esta misma página se mostrará la tabla de multiplicar de ese número

Si pinchan en mayor nos sale una página con lo siguiente:
Número 1 [ ] Número 2 [ ]
[Enviar]
Al darle a enviar nos dice cual es el número mayor de los dos

Mejoras: que tanto en la tabla de multiplicar como en los números ya estén por defecto los valores que hemos enviado en vez de quedarse en blanco.