Categoría: Java

	public static void main(String[] args) {

		// Me creo un map con alumnos
		Map<String, Alumno> alumnos = new HashMap<String, Alumno>();
		alumnos.put("Ana", new Alumno("Ana Pi", 7));
		alumnos.put("Eva", new Alumno("Eva González", 8));
		alumnos.put("Pep", new Alumno("José Bou", 6));
		alumnos.put("Rosa", new Alumno("Rosa", 3));
		alumnos.put("Juan", new Alumno("Juan", 4));

		System.out.println(mejorAlumno(alumnos));
		System.out.println(aprobados(alumnos));
	}

	// Paso como parámetro un hashmap y devuelvo un resultadop
	public static Alumno mejorAlumno(Map<String, Alumno> alumnos) {
		Alumno res = null;
		for (Alumno alumno : alumnos.values()) {
			if (res == null || alumno.getNota() > res.getNota()) {
				res = alumno;
			}
		}
		return res;
	}

	// Paso como parámetro un hashmap y devuelvo otro hashmap
	// Filtrando los aprobados
	public static Map<String, Alumno> aprobados(Map<String, Alumno> alumnos) {
		Map<String, Alumno> res = new HashMap<String, Alumno>();
		// Recorrer el mapa en un par clave valor y filtrar los alumnos
		for (Map.Entry<String, Alumno> alumno : alumnos.entrySet()) {
			if (alumno.getValue().getNota() >= 5) {
				res.put(alumno.getKey(), alumno.getValue());
			}
		}
		return res;
	}

https://www.javatpoint.com/java-hashmap

https://guru99.es/working-with-hashmaps/

https://www.geeksforgeeks.org/java-util-hashmap-in-java-with-examples/

https://www.baeldung.com/java-hashmap

public static void main(String[] args) {
		
		// Especificar los tipos de los dos cmapos, la clave y el valor
		// Defino por la intefaz 'Map' y no pr HashMap
		Map<Integer, String> map = new HashMap<Integer, String>();// Creating HashMap
		// Otra manera
		HashMap<Integer, String> mapita = new HashMap<Integer, String>();// Creating HashMap
		
		// Los valores se añaden con 'put'
		// En formato clave, valor
		map.put(1, "Eva"); // Put elements in Map
		map.put(2, "Juan");
		map.put(3, "Ana");
		map.put(4, "Pep"); //{1=Eva, 2=Juan, 3=Ana, 4=Rosa}

		System.out.println(map);
		
		// Recorrer un HashMap
		for (Map.Entry<Integer, String> m : map.entrySet()) {
			System.out.println(m.getKey() + " " + m.getValue());
		}
		
		// Añado un valor que ya existe	
		// Lo sustituye
		map.put(4, "Rosa");
		
		for (Map.Entry<Integer, String> m : map.entrySet()) {
			System.out.println(m.getKey() + " " + m.getValue());
		}
		
		// Función especial para añadir sólo si no existe
		map.putIfAbsent(4, "Pepe");
		System.out.println(map);
		map.putIfAbsent(5, "Pepe");
		System.out.println(map);
		
		// Nos elimina el elemento con la clave '2'
		map.remove(2);
		System.out.println(map);
		
		// Aquí la clave es una cadena y el valor es de tipo alumno
		Map<String,Alumno> mapa=new HashMap<String,Alumno>();
		Map<Alumno,String> mapaalreves=new HashMap<Alumno,String>();
		
		// Los añado creando alumnos al vuelo
		mapa.put("Ana", new Alumno("Ana Pi",7));
		mapa.put("Eva", new Alumno("Eva González",8));
		mapa.put("Pep", new Alumno("José Bou",6));
		
		// Obtener un valor concreto de una clave
		System.out.println(mapa.get("Ana"));
		
		System.out.println(mapa);
		for (Map.Entry<String, Alumno> m : mapa.entrySet()) {
			System.out.println(m.getKey() + " " + m.getValue().getNombre());
		}
		
		// Elimino por la clave
		mapa.remove("Ana");
		// Recorrer por valores, porque no me interesa la clave
		for(Alumno al:mapa.values()) {
			System.out.println(al);
		}
		
		// Muestra las claves de mi HashMap
		for(String key:mapa.keySet()) {
			System.out.println(key);
		}
	}

public static void main(String[] args) {
		List<String> alumnos=new ArrayList<String>();

		alumnos.add("Eva");
		alumnos.add("");
		alumnos.add("María");
		alumnos.add("Rosa");
		
		Collections.addAll(alumnos, "juan","","Pep");
		
		System.out.println(alumnos);
		
		List<String> alumnosTrim=arrayTrim(alumnos);
		
		System.out.println(alumnosTrim);
		Collections.shuffle(alumnosTrim);
		System.out.println(alumnosTrim);
		Collections.sort(alumnosTrim);
		System.out.println(alumnosTrim);
	}

	// Tanto lo que devuelvo como el parámetro es de tipo List
	public static List<String> arrayTrim(List<String> lista){
		List<String> res=new ArrayList<String>();
		for(String el:lista) {
			if (el!="") {
				res.add(el);
			}
		}
		return res;
	}

Otro ejemplo:

	public static void main(String[] args) {
		// ArrayList de Alumnos, es decir de una clase propia
		List<Alumno> alumnos=new ArrayList<Alumno>();

		// Añadir creandolos al vuelo
		alumnos.add(new Alumno("Eva",6));
		alumnos.add(new Alumno("Rosa",7));
		alumnos.add(new Alumno("Pep",3));
		alumnos.add(new Alumno("Ana",4));
		
		// Añadir creando una variable y añadiendo esa variable
		Alumno foo=new Alumno("Rosa",8);
		alumnos.add(foo);
		
		// Si he sobreescrito el toString lo puedo ver todo con un
		// simple print
		System.out.println(alumnos);
		List<Alumno> aprobados=aprobados(alumnos);
		System.out.println(aprobados);
	}

	public static List<Alumno> aprobados(List<Alumno> alumnos){
		List<Alumno> res=new ArrayList<Alumno>();
		for(Alumno al:alumnos) {
			if (al.getNota()>=5) {
				res.add(al);
			}
		}
		return res;
	}

https://www.w3schools.com/java/java_arraylist.asp

https://www.arquitecturajava.com/java-arraylist-for-y-sus-opciones/

https://www.geeksforgeeks.org/arraylist-in-java/

https://www.programiz.com/java-programming/arraylist

https://www.javatpoint.com/java-arraylist

// Definición de ArrayList
		// Lo que está entre '<' y '>' es un tipo genérico
		// Esto es correcto y lo preferido
		List<String> lista = new ArrayList<String>();

		// Esto es completamente correcto
		ArrayList<String> otraLista = new ArrayList<String>();

		// Para añadir 'add'. Si no especificamos posición, se añade al final
		// Si especificamos posición se añade en esa posición
		lista.add("Eva"); // ['Eva']
		lista.add("Juan"); // ['Eva','Juan']
		lista.add(1, "Ana");// ['Eva','Ana','Juan']
		lista.add(0, "Pep");// ['Pep','Eva','Ana','Juan']

		// Al imprimir se muestra de una manera bastante visual
		System.out.println(lista);

		// Con get obtenemos el elemnto en esa posición
		System.out.println(lista.get(0));

		// Cambiar el elemento que está en una posición determinada
		lista.set(1, "Pep"); // ['Pep','Pep','Ana','Juan']

		System.out.println(lista);

		// Nos elimina el elemento en la posición 1
		lista.remove(1); // ['Pep','Ana','Juan']
		System.out.println(lista);
		// Nos elimina el elemento que vale "Ana"
		lista.remove("Ana"); // ['Pep','Juan']
		System.out.println(lista);
		lista.add("Eva");
		lista.add("Juan");
		lista.add(1, "Ana");
		
		// Recorrer con un foreach
		for (String l : lista) {
			System.out.println(l);
		}
		
		// Recorrer con un for normal
		for(int i=0;i<lista.size();i++) {
			System.out.println(lista.get(i));
		}
		
		// contains nos dice si un elemento está o no está en el arraylist
		// true or false
		System.out.println(lista.contains("Eva")); // true
		// indexOf nos dice la posición del elemento en el arraylist
		System.out.println(lista.indexOf("Juan")); // 2
		System.out.println(lista.indexOf("Rosa")); // -1
		// Podemos ordenar usando la utilidad sort de la clase Collections
		Collections.sort(lista);
		System.out.println(lista);

https://beginnersbook.com/java-collections-tutorials/

https://www.geeksforgeeks.org/collections-in-java-2/

https://www.journaldev.com/1260/collections-in-java-tutorial

https://howtodoinjava.com/

https://stackoverflow.com/questions/21974361/which-java-collection-should-i-use

Vamos a crear las siguientes clases

Una clase llamada ManipularCadenas que sólo tendrá una variable String privada que se incializa en el contructor.

Tendrá los siguientes métodos públicos:

String getCadena()-> Getter de la cadena (pero no setter)

void repetir(String cadena)

Si nuestra cadena tiene dentro la cadena que le pasamos, la repite. Si no, no hace nada.
Ejemplo: Si mi cadena es ‘hola que tal’
repetir(«cacahuete»)-> No modifica la cadena
repetir(‘que’)-> Mi cadena pasa a valer ‘hola queque tal’
Sólo la primera aparición

void erosionar()

Nos elimina el primer y el último carácter de la cadena si tiene una longitud mayor o igual a 2

Si mi cadena es ‘hola que tal’->’ola que ta’

void agujero

Nos elimina el caracter que están en el medio. Si la longitud es par, los dos que están en el medio

Si mi cadena es ‘hola que tal’->’hola e tal’

Todas estas funciones modifican el valor de la cadena dentro de la clase. Ni imprimen por pantalla ni devuelven nada. Si queremos ver si funcionan necesitaremos llamar al getter para ver el valor.

Estamos dentro de una clase, que tendrá su propio archivo. Para probarla vamos a crear en otra parte un Main y crearemos una instancia de la clase.

Vamos a crear una clase CitasMedico que va a tener como propiedades un array de Fechas.

Vamos a tener un constructor sobrecargado de tres maneras:
Sin parámetros
Parámetro String
Parámetro LocalDate

En este último crearemos en el array de fechas 12 fechas de la manera siguiente:
El primer elemento es la fecha que nos pasan.
El segundo elemento es la fecha que nos pasan mas 15 días.
El tercero lo mismo más 15 días.
Y así sucesivamente.

Si alguno de los elementos cae en fin de semana se pasa al lunes siguiente.
Imaginemos que lo hacemos con la fecha de hoy. Tendríamos las siguientes fechas:
6/4/2021
21/4/2021
6/5/2021
21/5/2021
5/6/2021–> Es sábado, así que pasa a ser 7/6/2021
20/5/2021–>Es domingo, así que pasa a ser 21/5/2021

El constructor con un string parsea el string a fecha y llama al constructor de fecha.
EL constructor sin parámetros llama al constructor de fecha con fecha de hoy.

Además crearemos un método público próxima cita que nos devuelva, de nuestro array de fechas, la siguiente que nos tocaría.

LocalDate proximaCita()

La clase ManipulaCadena:

package com.trifulcas.ejercicio01;

public class ManipulaCadenas {
	private String cadena;

	public ManipulaCadenas(String cadena) {
		this.cadena = cadena;
	}

	public String getCadena() {
		return cadena;
	}

	/**
	 * Busca la cadena dentro de la propiedad de la clase Y si está, la repite
	 * 
	 * @param cad La cadena a buscar
	 * 
	 */
	public void repetir(String cad) {
		// Averiguar si la cadena que me pasan como parámetro
		// Está dentro de la cadena de la clase
		// Si no está no hago nada
		// Si está inserto la cadena que me pasan en la posición
		// de la cadena
		int pos = cadena.indexOf(cad);
		if (pos != -1) {
			// '123456789' y busco '34' está en la posición '2'
			// Yo tengo que insertar '34' en la posición 2
			// Manera 1 usando insert de StringBuilder
			StringBuilder temp = new StringBuilder(cadena);
			temp.insert(pos, cad); // '12343456789'
			// cadena = temp.toString();
			// Manera 2 lo mismo pero compacto
			cadena = new StringBuilder(cadena).insert(pos, cad).toString();

			// Manera 3 usando substring
			// cadena = cadena.substring(0, pos) + cad + cadena.substring(pos);
		}

	}

	/**
	 * Elimina el primer carácter y el último de la cadena si su longitud es mayor a
	 * 2
	 */
	public void erosionar() {
		// Compruebo si tiene longitud>2
		// Si es así quito el caracter 1º y último
		if (cadena.length() >= 2) {
			// No me complico y uso substring
			// cadena = cadena.substring(1, cadena.length() - 1);

			// Me aprovecho de las funcionalidades de StringBuilder
			cadena = new StringBuilder(cadena).deleteCharAt(cadena.length() - 1).deleteCharAt(0).toString();
		}
	}

	/**
	 * Elimina los carcateres centrales Si la longitud de la cadena es par, los dos
	 * del medio Si es impar el carácter central
	 */
	public void agujero() {
		if (cadena.length() > 0) {
			// Par o impar
			// Si es par quitar los caracteres del medio
			// Si es impar quitar el carácter del medio
			if (cadena.length() % 2 == 0) {
				// Es par: los dos del medio
				// 'abcdef' 2,3 longitud: 6 6/2-1
				// 'abcd' 1,2 longitud 4 4/2-1
				// 'abcdefgh' 3,4 longitud 8 8/2-1
				int pos = cadena.length() / 2 - 1;
				cadena = new StringBuilder(cadena).delete(pos, pos + 2).toString();

			} else {
				// Es impar: el del medio
				// 'abcde' 2 longitud 5 5/2->2
				// 'abcdefg' 3 longitud es 7/2 ->3
				int pos = (cadena.length() - 1) / 2;
				cadena = new StringBuilder(cadena).deleteCharAt(pos).toString();
			}
		}
	}
}

Probar esta clase:

package com.trifulcas.ejercicio01;

public class Test {

	public static void main(String[] args) {
		ManipulaCadenas temp=new ManipulaCadenas("Hola que tal");
	
		ManipulaCadenas numeros=new ManipulaCadenas("123456789");

		temp.repetir("que");
		System.out.println(temp.getCadena());
		temp.erosionar();
		System.out.println(temp.getCadena());
		temp.agujero();
		System.out.println(temp.getCadena());
		numeros.agujero();
		System.out.println(numeros.getCadena());
	}

}

package com.trifulcas.ejercicio01;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.util.Arrays;

public class CitasMedico {
	private LocalDate[] fechas;

	public CitasMedico() {
		// LLamo al constructor con parámetro fecha con la fecha de hoy
		this(LocalDate.now());
	}

	public CitasMedico(String fecha) {
		// Parseo la fecha y llamo al constructor con parámetro fecha
		this(LocalDate.parse(fecha));
	}

	public CitasMedico(LocalDate fecha) {
		// Crearé el array con un tamaño de 12
		// Voy a ir añadiendo las fechas sumando 15 días
		// Hay que comprobar que no sea fin de semana
		this(fecha, 15);
	}

	public CitasMedico(LocalDate fecha, int dias) {
		// Crearé el array con un tamaño de 12
		// Voy a ir añadiendo las fechas sumando 15 días
		// Hay que comprobar que no sea fin de semana
		fechas = new LocalDate[12];
		fechas[0] = siguienteLaborable(fecha);
		for (int i = 1; i < fechas.length; i++) {
			fechas[i] = siguienteLaborable(fechas[i - 1].plusDays(dias));
		}
	}

	/**
	 * Busca el siguiente día laborable. Si la fecha es sábado o domingo pasa al
	 * lunes
	 * 
	 * @param fecha La fecha a comprobar
	 * @return El siguiente día laborable a la fecha
	 */
	private LocalDate siguienteLaborable(LocalDate fecha) {

		// Si es sábado pasamos al lunes sumando dos días
		if (fecha.getDayOfWeek() == DayOfWeek.SATURDAY) {
			fecha = fecha.plusDays(2);
		}
		// Si es domingo pasamos al lunes sumando 1 día
		if (fecha.getDayOfWeek() == DayOfWeek.SUNDAY) {
			fecha = fecha.plusDays(1);
		}
		return fecha;
	}

	public LocalDate proximaCita() {
		// Devolveremos la próxima cita a partir de hoy	
		for(int i=0;i<fechas.length;i++) {
			if (fechas[i].isAfter(LocalDate.now())) {
				return fechas[i];
			}
		}
		return null;
	}

	public LocalDate proximaCitaFeten() {
		// Devolveremos la próxima cita a partir de hoy	
		LocalDate res=null;
		for(int i=0;i<fechas.length;i++) {
			if (fechas[i].isAfter(LocalDate.now())) {
				res=fechas[i];
				break;
			}
		}
		return res;
	}
	
	public LocalDate proximaCitaDesordenada() {
		// Devolveremos la próxima cita a partir de hoy	
		LocalDate res=null;
		for(int i=0;i<fechas.length;i++) {
			if (fechas[i].isAfter(LocalDate.now())) {
				if (res==null || res.isAfter(fechas[i]))
				res=fechas[i];
			}
		}
		return res;
	}
	public String toString() {
		return Arrays.toString(fechas);
	}
}

Probar la clase:

public static void main(String[] args) {
		CitasMedico temp = new CitasMedico(LocalDate.now());
		CitasMedico temp2 = new CitasMedico("2021-03-02");
		CitasMedico temp3=new CitasMedico();

		CitasMedico temp4 = new CitasMedico(LocalDate.now(),20);

		System.out.println(temp2);
		System.out.println(temp2.proximaCita());
	}

Haced una función a la que le pasemos una fecha y nos diga si es un día par o impar.

public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		
		
		System.out.println("Introduce fecha para saberlo");
		String f=in.next();
		LocalDate fecha=LocalDate.parse(f);
		System.out.println(esDiaPar(fecha));
		System.out.println(esDiaPar(LocalDate.parse("2020-01-09")));
		System.out.println(esDiaPar(LocalDate.parse("2020-01-10")));
	}
	
	// Función que nos diga si un día concreto es un fin de semana
	
	public static boolean finDeSemana(LocalDate fecha) {
		return fecha.getDayOfWeek()==DayOfWeek.SATURDAY ||
				fecha.getDayOfWeek()==DayOfWeek.SUNDAY;
	}
	public static int dia(LocalDate fecha) {
		return fecha.getDayOfMonth();
	}
	
	
	public static String esDiaPar(LocalDate fecha) {
		// Obtener el día
		int dia=fecha.getDayOfMonth();
		if (dia%2==0) {
			return "Par";
		} else {
			return "Impar";
		}
	}

public static void main(String[] args) {
Scanner in=new Scanner(System.in);
System.out.println("Introduce tu fecha de cumpleaños en formato ISO");
String f=in.next();
LocalDate fecha = LocalDate.parse(f);

System.out.println("Naciste en "+fecha.getDayOfWeek());
fecha=LocalDate.now();
System.out.println("Mañana será "+fecha.plusDays(1));
System.out.println("La semana que viene será "+fecha.plusWeeks(1));
System.out.println("El año que viene será "+fecha.plusYears(1));
System.out.println("Hoy es el dia "+dia(LocalDate.now())+" del mes");


}

public static int dia(LocalDate fecha) {
return fecha.getDayOfMonth();
}

public static void main(String[] args) {

// Para crear una variable que permita guardar una fecha usamos
// LocalDate
// fecha Tiene el día de hoy LocalDate tiene algunos métodos estáticos
// Y uno de ellos es now() que nos devuelve la fecha de hoy
LocalDate fecha = LocalDate.now();
// Otra manera de crear una fecha es utilizar of
// Usa de parámetros: año, mes y día
LocalDate fecha2 = LocalDate.of(2019, 02, 20);
// Otra manera más es utilizar parse que intenta convertir
// Una cadena en una fecha
LocalDate fecha3 = LocalDate.parse("2015-08-10");

System.out.println(fecha);
// Imprimir en formato ISO (estándar, como el mysql)
System.out.println(fecha.format(DateTimeFormatter.ISO_DATE));
System.out.println(fecha.format(DateTimeFormatter.ISO_LOCAL_DATE));
// Formatear con un patrón definido (dd-MM-yyy)
System.out.println(fecha.format(DateTimeFormatter.ofPattern("dd-MM-yyy")));
// Formatear como lo tengamos configurado en el sistema (y tenemos largo, medio
// o corto)
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)));

System.out.println(fecha2);
System.out.println(fecha3);

// A una fecha le puedo añadir o quitar días, meses, semanas y años
LocalDate manyana = LocalDate.now().plusDays(1);
LocalDate ayer = LocalDate.now().minusDays(1);
LocalDate semana_que_viene = LocalDate.now().plusWeeks(1);
System.out.println(manyana);
System.out.println(ayer);
System.out.println(semana_que_viene);

// Puedo añadir o restar unidades de tiempo
LocalDate mesAnterior = LocalDate.now().minus(1, ChronoUnit.MONTHS);
// Podemos añadir Periodos que es parecido: permite añadir
// meses, dias, años o combinaciones
LocalDate finalDate = manyana.plus(Period.ofDays(5));

System.out.println(finalDate);
System.out.println(mesAnterior);

// Puedo obtener de una fecha cualquier valor que me interese
// El día de la semana es una clase que nos permite obtener el nombre
// Y el número
DayOfWeek dia = LocalDate.parse("2016-06-12").getDayOfWeek();
// El día del mes es un entero
int mes = LocalDate.parse("2016-06-12").getDayOfMonth();

// En el caso de los meses
int m = LocalDate.parse("2016-06-12").getMonthValue();
Month mon = LocalDate.parse("2016-06-12").getMonth();

// Las clases DayOfWeek y Month nos permiten recuperar el nombre
// Del día de la semana y del mes (en inglés) pero también
// Su número
System.out.println(dia);
System.out.println(dia.ordinal());
System.out.println(mes);
System.out.println(m);
System.out.println(mon);
System.out.println(mon.ordinal());

// Saber si un año es bisiesto
boolean bisiesto = LocalDate.now().isLeapYear();
System.out.println(bisiesto);
boolean antes = LocalDate.parse("2016-06-12").isBefore(LocalDate.parse("2016-06-11"));
System.out.println(antes);
boolean despues = LocalDate.parse("2016-06-12").isAfter(LocalDate.parse("2016-06-11"));
System.out.println(despues);
// El with nos permite obtener el primer día y el último del mes
LocalDate primerDiaMes = LocalDate.parse("2016-06-12").with(TemporalAdjusters.firstDayOfMonth());
System.out.println(primerDiaMes);

// Formato de fecha Y hora
LocalDateTime fechaHora = LocalDateTime.parse("2016-06-12T10:00");
System.out.println(fechaHora);
System.out.println(fechaHora.format(DateTimeFormatter.ofPattern("dd-MM-yyy HH:mm")));
System.out.println(fechaHora.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM)));
System.out.println(fechaHora.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT)));
LocalDateTime inicioDia = LocalDate.parse("2016-06-12").atStartOfDay();
System.out.println(inicioDia);

// También tenemos la clase sólo para la hora
LocalTime ahora = LocalTime.now();
System.out.println(ahora);
// Podemos obtenerla de una cadena
LocalTime seisYMedia = LocalTime.parse("06:30");
System.out.println(seisYMedia);
// Podemos indicar hora, minutos y segundos
LocalTime seisYMedia2 = LocalTime.of(6, 30);
System.out.println(seisYMedia2);
LocalTime seisYMedia3 = LocalTime.of(6, 30,15);
System.out.println(seisYMedia3);
//Podemos añadir Cronounidades
LocalTime sieteYMedia = LocalTime.parse("06:30").plus(1, ChronoUnit.HOURS);
System.out.println(sieteYMedia);

// Podemos añadir duraciones, lo que en Date es Period
LocalTime siete = seisYMedia.plus(Duration.ofMinutes(30));
System.out.println(siete);

}

public static void main(String[] args) {
Scanner in=new Scanner(System.in);

// ¿En qué día caen los primeros de cada mes este año?
for(int i=1;i<12;i++) {
LocalDate fecha= LocalDate.of(2021, i, 1);
System.out.println(fecha.getDayOfWeek());
System.out.println(finDeSemana(fecha));
}

System.out.println("Introduce fecha factura");
String f=in.next();
System.out.println("El vencimiento es dentro de 15 días:");
LocalDate fecha=LocalDate.parse(f).plusDays(15);
System.out.println(fecha.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)));
if (finDeSemana(fecha)) {
System.out.println("Que cae en fin de semana");
}

}

// Función que nos diga si un día concreto es un fin de semana

public static boolean finDeSemana(LocalDate fecha) {
return fecha.getDayOfWeek()==DayOfWeek.SATURDAY ||
fecha.getDayOfWeek()==DayOfWeek.SUNDAY;
}
public static int dia(LocalDate fecha) {
return fecha.getDayOfMonth();
}

https://www.campusmvp.es/recursos/post/como-manejar-correctamente-fechas-en-java-el-paquete-java-time.aspx

https://www.javatpoint.com/java-date

https://www.baeldung.com/java-8-date-time-intro

https://javautodidacta.es/tiempo-en-java-localdate-localtime/

Formatos:

Crear una función esPalindromo que nos diga si una cadena es palíndroma:

boolean esPalindromo(String cadena)

esPalindromo(«Viva la paella»)->false
esPalindromo(«Sara Baras»)->true

public static void main(String[] args) {
		String[] cadenas= {"No subas, abusón","Yo dono rosas, oro no doy","No traces en ese cartón"};
		System.out.println(esPalindromo("Viva la paella"));
		System.out.println(esPalindromo("Sara Baras"));
		System.out.println(esPalindromo("Isaac no ronca así"));
		for(String cadena:cadenas) {
			System.out.println(esPalindromo(cadena));
		}
		System.out.println("Con clase");
		Palindromo pal=new Palindromo("Dábale arroz a la zorra el abad");
		System.out.println(pal.esPalindromo());

	}

	// Una cadena es palíndromo si es igual a ella misma invertida
	public static boolean esPalindromo(String cadena) {
		cadena = normalizar(cadena);
		StringBuilder foo = new StringBuilder(cadena);
		return cadena.equals(foo.reverse().toString());
	}
	
	// He creado una función normalizar para otros caracteres
	public static String normalizar(String cadena) {
		return cadena.toLowerCase().replace("á", "a").replace("é", "e").replace("í", "i").replace("ó", "o")
				.replace("ú", "u").replace("ü","u").replace(" ", "").replace(".", "").replace(",", "");
	}
	
	// La estructura if (condicion) return true else return false es igual a:
	// return condicion

public class Palindromo {
	private String cadena;
	
	public Palindromo(String cadena) {
		this.cadena=cadena;
	}
	
	public boolean esPalindromo() {
		String cad = normalizar(cadena);
		StringBuilder foo = new StringBuilder(cad);
		return cad.equals(foo.reverse().toString());
	}
	private String normalizar(String cadena) {
		return cadena.toLowerCase().replace("á", "a").replace("é", "e").replace("í", "i").replace("ó", "o")
				.replace("ú", "u").replace("ü","u").replace(" ", "").replace(".", "").replace(",", "");
	}
}