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; }
Categoría: Java
HashMap
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); } }
Ejemplos ArrayList
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; }
ArrayList
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);
Colecciones
Ejercicios Strings y Fechas
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()); }
MiniminiEjercicio
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"; } }
Ejemplos de LocalDate, LocalTime y LocalDateTime
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(); }
LocalDate, LocalTime y LocalDateTime
https://www.javatpoint.com/java-date
https://www.baeldung.com/java-8-date-time-intro
https://javautodidacta.es/tiempo-en-java-localdate-localtime/
Formatos:
Symbol | Meaning | Presentation | Examples |
---|---|---|---|
G | era | text | AD; Anno Domini; A |
u | year | year | 2004; 04 |
y | year-of-era | year | 2004; 04 |
D | day-of-year | number | 189 |
M/L | month-of-year | number/text | 7; 07; Jul; July; J |
d | day-of-month | number | 10 |
g | modified-julian-day | number | 2451334 |
Q/q | quarter-of-year | number/text | 3; 03; Q3; 3rd quarter |
Y | week-based-year | year | 1996; 96 |
w | week-of-week-based-year | number | 27 |
W | week-of-month | number | 4 |
E | day-of-week | text | Tue; Tuesday; T |
e/c | localized day-of-week | number/text | 2; 02; Tue; Tuesday; T |
F | day-of-week-in-month | number | 3 |
a | am-pm-of-day | text | PM |
h | clock-hour-of-am-pm (1-12) | number | 12 |
K | hour-of-am-pm (0-11) | number | 0 |
k | clock-hour-of-day (1-24) | number | 24 |
H | hour-of-day (0-23) | number | 0 |
m | minute-of-hour | number | 30 |
s | second-of-minute | number | 55 |
S | fraction-of-second | fraction | 978 |
A | milli-of-day | number | 1234 |
n | nano-of-second | number | 987654321 |
N | nano-of-day | number | 1234000000 |
V | time-zone ID | zone-id | America/Los_Angeles; Z; -08:30 |
v | generic time-zone name | zone-name | Pacific Time; PT |
z | time-zone name | zone-name | Pacific Standard Time; PST |
O | localized zone-offset | offset-O | GMT+8; GMT+08:00; UTC-08:00 |
X | zone-offset ‘Z’ for zero | offset-X | Z; -08; -0830; -08:30; -083015; -08:30:15 |
x | zone-offset | offset-x | +0000; -08; -0830; -08:30; -083015; -08:30:15 |
Z | zone-offset | offset-Z | +0000; -0800; -08:00 |
p | pad next | pad modifier | 1 |
‘ | escape for text | delimiter | |
» | single quote | literal | ‘ |
[ | optional section start | ||
] | optional section end | ||
# | reserved for future use | ||
{ | reserved for future use | ||
} | reserved for future use |
MiniEjercicio
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(",", ""); } }