public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
// Añadir elementos al HashMap
map.put("one", 1);
map.put("two", 2);
map.put("three", 3);
System.out.println(map);
map.put("three", 30);
System.out.println(map);
System.out.println(map.get("three"));
HashMap<Integer, String> mapa = new HashMap<>();
mapa.put(1, "one");
mapa.put(2, "two");
mapa.put(3, "three");
System.out.println(mapa);
mapa.put(30, "three");
System.out.println(mapa);
mapa.put(30, "treinta");
System.out.println(mapa);
mapa.remove(3); // Elimino por la clave
System.out.println(mapa);
mapa.remove(30, "three");
System.out.println(mapa);
// Recorrer los valores del hashmap
for (String valor : mapa.values()) {
System.out.println(valor);
}
// Recorrer las claves
for (Integer valor : mapa.keySet()) {
System.out.println(valor);
}
// Recorrerlo todo: a partir de la clave obtenemos el valor
for (Integer valor : mapa.keySet()) {
System.out.println(valor + "-" + mapa.get(valor));
}
// Recorrerlo con el tipo 'Entry'
for (Entry<Integer, String> par : mapa.entrySet()) {
System.out.println(par.getKey()+"-"+par.getValue());
}
// Métodos para saber si hay una clave o hay un valor
System.out.println(mapa.containsKey(2));
System.out.println(mapa.containsValue("two"));
}
HashMap<String, Integer> clase = new HashMap<>();
ArrayList<String> alumnos = new ArrayList<String>();
alumnos.add("Ana");
alumnos.add("Eva");
ArrayList<Integer> notas = new ArrayList<Integer>();
notas.add(6);
notas.add(7);
notas.add(17);
for(int i=0;i<alumnos.size();i++) {
clase.put(alumnos.get(i), notas.get(i));
}
System.out.println(clase);
Ejercicios ArrayList resueltos
public static void main(String[] args) {
LinkedList<Integer> lista=new LinkedList<Integer>(Arrays.asList(1,2,4,14,3,4,5,6,7,3,1,1,7));
System.out.println(eliminarDuplicadosSin(lista));
}
public static int contarNumero(LinkedList<Integer> numeros, int numero) {
int total = 0;
for (int n : numeros) {
if (n == numero) {
total++;
}
}
return total;
}
public static LinkedList<Integer> listaFibonacci(int limite) {
if (limite <= 0) {
return null;
}
LinkedList<Integer> fibo = new LinkedList<Integer>();
fibo.add(1);
if (limite == 1) {
return fibo;
}
fibo.add(1);
for (int i = 2; i < limite; i++) {
fibo.add(fibo.get(i - 1) + fibo.get(i - 2));
}
return fibo;
}
public static LinkedList<String> listaRellena(int cantidad, String cadena) {
LinkedList<String> res = new LinkedList<String>();
for (int i = 0; i < cantidad; i++) {
res.add(cadena);
}
return res;
}
public static LinkedList<Integer> eliminarDuplicados(LinkedList<Integer> lista){
LinkedList<Integer> resultado=(LinkedList<Integer>) lista.clone();
resultado.sort(null);
for(int i=resultado.size()-1;i>0;i--) {
if (resultado.get(i)==resultado.get(i-1)) {
resultado.remove(i);
}
}
return resultado;
}
public static LinkedList<Integer> eliminarDuplicadosSin(LinkedList<Integer> lista){
LinkedList<Integer> resultado=new LinkedList<Integer>();
for(int numero:lista) {
if(!resultado.contains(numero)) {
resultado.add(numero);
}
}
return resultado;
}
Ejemplos ArrayList
public static void main(String[] args) {
ArrayList<Integer> numeros=rellenarRandom(10,10);
System.out.println(numeros);
System.out.println(sumaLista(numeros));
System.out.println(filtrarListaPares(numeros));
}
// Un método al que le paso una cantidad y nos devuelve
// un arraylist de ese tamaño con numeros aleatorios
public static ArrayList<Integer> rellenarRandom(int tam, int rango){
ArrayList<Integer> resultado=new ArrayList<Integer>();
for(int i=0;i<tam;i++) {
resultado.add((int) (Math.random()*rango+1));
}
return resultado;
}
public static int sumaLista(ArrayList<Integer> numeros) {
int res=0;
for(int n:numeros) {
res+=n;
}
return res;
}
public static ArrayList<Integer> filtrarListaPares(ArrayList<Integer> numeros){
ArrayList<Integer> resultado=new ArrayList<Integer>();
for(int n:numeros) {
if (n%2==0) {
resultado.add(n);
}
}
return resultado;
}
Ejemplos LinkedList
public static void main(String[] args) {
// La declaración de un LinkedList es igual que un arraylist
LinkedList<Integer> numbers = new LinkedList<>();
numbers.add(5);
numbers.add(0, 8); // Más eficiente en un linkedlist
for (int n : numbers) {
System.out.println(n);
}
numbers.add(3);
numbers.add(27);
// Añade al principio
numbers.addFirst(1);
// Devuelve el primero
System.out.println(numbers.getFirst());
System.out.println(numbers.reversed());
numbers.sort(null);
System.out.println(numbers);
// Obtiene el primer elemento y lo elimina
int primero = numbers.poll();
System.out.println(primero);
System.out.println(numbers);
// Obtiene el último elemento y lo elimina
int ultimo = numbers.pollLast();
System.out.println(ultimo);
System.out.println(numbers);
;
}
Ejemplos ArrayList
public static void main(String[] args) {
// Definir un ArrayList
// Pongo ArrayList porque es el tipo general (arraylist)
// Pongo <..> para especificar el tipo del
// contenido del ArrayList (<String> <LocalDate>...)
// Muy importante, si quiero de valores primitivos
// no pongo el valor primitivo sino la clase que lo envuelve
// int->Integer double->Double...
// Lo tengo que crear con la palabra clave 'new'
ArrayList<String> lista = new ArrayList<String>();
ArrayList<String> lista2 = new ArrayList<String>();
ArrayList<Integer> numeros=new ArrayList<Integer>();
// Una vez hemos construído el ArrayList ya podemos
// trabajar con él
lista.add("Ana");
lista.add("eva");
lista.add("pep");
System.out.println(lista.size());
lista2.add("Ana");
lista2.add("eva");
lista2.add("pep");
System.out.println(lista.size());
// Recorrer el arraylist
for(int i=0;i<lista.size();i++) {
System.out.println(lista.get(i));
}
for(String nombre:lista) {
System.out.println(nombre);
}
// Añadiendo elementos sueltos a través de la utilidad
// de Arrays 'asList' que convierte elementos
// en una lista
lista.addAll(Arrays.asList("Juan","rosa"));
// Añado una lista ya existente
lista.addAll(lista2);
// Elimina el elemento que esté en la posición 1
lista.remove(1);
// Elimina el elemento
lista.remove("Ana");
System.out.println(lista);
lista.remove("ruth");
// eliminar todos los elementos de una colección
lista.removeAll(Arrays.asList("Ana"));
// Arrays.asList nos convierte una serie de elementoss
// En una lista y lo puedo utilizar para inicializar
ArrayList<String> alumnos = new ArrayList<String>(Arrays.asList("Ana","Eva"));
System.out.println(alumnos);
// Añadir en una posición determinada
alumnos.add(1,"Rigoberta");
System.out.println(alumnos);
// Modifico el elemento que está en la posición 0
alumnos.set(0, "Ana Pi");
System.out.println(alumnos);
// Elimina el primero
alumnos.removeFirst();
System.out.println(alumnos);
// Métodos para buscar elementos
System.out.println(alumnos.contains("Eva"));
System.out.println(alumnos.contains("Evar"));
// El indexOf funciona parecido al String
System.out.println(alumnos.indexOf("Eva"));
System.out.println(alumnos.indexOf("Evar"));
int pos=lista.indexOf("pep");
int lastPos=lista.lastIndexOf("pep");
System.out.println(pos+"-"+lastPos);
lista.add("Zacarías");
// Ordenamos alfabeticamente pero ojo mayúsculas primero
lista.sort(null);
System.out.println(lista);
}
Rotar Derecha, Paridad array y Duplicados
public static void main(String[] args) {
int[] numeros= {1,2,3,4,5};
System.out.println(Arrays.toString(rotarDerecha(numeros,2)));
System.out.println(Arrays.toString(numeros));
}
/*
* Crear una función rotarDerecha a la que la pasamos un
* array de enteros y nos devuelve el array con los elementos
* desplazados a la derecha (el último va al principio)
rotarDerecha([1,2,3,4]) -> [4,1,2,3]
*/
public static int[] rotarDerecha(int[] array, int pos) {
int longitud=array.length;
int[] nuevo=new int[longitud];
// En el primero pongo el último
// En los siguientes del nuevo pongo el que está en
// la posición anterior del que me pasan
//nuevo[0]=array[array.length-1];
for(int i=0;i<longitud;i++) {
nuevo[i]=array[(i-pos+longitud) % longitud];
}
return nuevo;
}
public static int paridadArray(int[] numeros) {
// Dos contadores: pares e impares
int pares = 0;
int impares = 0;
for (int numero : numeros) {
if (numero % 2 == 0) {
pares++;
} else {
impares++;
}
}
switch (Integer.compare(pares, impares)) {
case -1:
return 1;
case 1:
return 2;
default:
return 0;
}
}
public static boolean hayDuplicados(int[] numeros) {
int[] ordenado=numeros.clone();
Arrays.sort(ordenado);
// { 1, 2, 3, 4, 6,5,1 }->{1,1,2,3,4,5,6}
for(int i=0;i<ordenado.length-1;i++) {
if (ordenado[i]==ordenado[i+1]) {
return true;
}
}
return false;
}
// Sin ordenar la receta es lo que haría yo
public static boolean hayDuplicadosSin(int[] numeros) {
for(int i=0;i<numeros.length;i++) {
int numero=numeros[i];
for(int j=i+1;j<numeros.length;j++) {
if(numeros[j]==numero) {
return true;
}
}
}
return false;
}
Dos maneras de encontrar el menor y probar cual tarda más
public static void main(String[] args) {
// Vamos a crear un array con 10000 números aleatorios
// Y vamos a comprobar cronómetro en mano cuanta diferencia hay
// Entre usar un método y otro
int[] numeros=new int[10000];
for (int i=0;i<numeros.length;i++) {
numeros[i]=(int) (Math.random()*100+1);
}
//System.out.println(Arrays.toString(numeros));
LocalTime ahora=LocalTime.now();
System.out.println(menorElemento(numeros));
LocalTime despues=LocalTime.now();
Duration tiempo=Duration.between(ahora, despues);
System.out.println(tiempo);
ahora=LocalTime.now();
System.out.println(menorElementoOrden(numeros));
despues=LocalTime.now();
tiempo=Duration.between(ahora, despues);
System.out.println(tiempo);
}
// Devolver el menor elemento de un array
public static int menorElemento(int[] numeros) {
// Almacenar el elemento menor
int menor=numeros[0];
// Recorrer el array
for(int numero:numeros) {
// Comparo cada valor con el que ya tengo
if(numero<menor) {
menor=numero;
}
}
return menor;
}
// Los arrays se pueden modificar en las funciones
// pero no SE DEBEN MODIFICAR por defecto
public static int menorElementoOrden(int[] numeros) {
int[] copia=numeros.clone();
Arrays.sort(copia);
return copia[0];
}
Resolución ejercicios fechas java
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.TextStyle;
import java.util.Arrays;
import java.util.Locale;
import java.util.Scanner;
public class FechasHoras {
public static void main(String[] args) {
// La función esViernes me devuelve...
for (LocalDate fecha : diasLaborablesArray(1, 11, 2023)) {
System.out.println(fecha);
}
System.out.println(Arrays.toString(diasLaborablesArray(1, 11, 2023)));
}
public static boolean esViernes() {
// Fecha de hoy
LocalDate hoy = LocalDate.now();
// Si hoy es viernes
return hoy.getDayOfWeek() == DayOfWeek.FRIDAY;
}
public static int hastaelFinde() {
// Fecha de hoy
LocalDate hoy = LocalDate.now();
// Cogemos el día numérico de la sema 1-lunes...7 domingo
int dia = hoy.getDayOfWeek().getValue();
// Si es sábado o domingo devolvemos 0
if (dia >= 6) {
return 0;
} else {
// Devolvemos 6 menos el valor
return 6 - dia;
}
}
public static int hastaelFindeNinja() {
// Obtenemos el día numérico de la semana
int dia = LocalDate.now().getDayOfWeek().getValue();
// Operador ternario para devolver 0 o la resta de días como
// En el ejemplo anterior
// Operador ternario if comprimido
// condicion ? valor si cierto : valor si falso
return dia >= 6 ? 0 : 6 - dia;
}
public static LocalDate vencimiento(LocalDate fecha, int dias) {
// Añado los días a la fecha
return fecha.plusDays(dias);
}
public static String diaCumple(int mes, int dia) {
// Creo la fecha de cumpleaños de este año
LocalDate cumple = LocalDate.of(LocalDate.now().getYear(), mes, dia);
// Obtengo el día de la semana en formato string
return cumple.getDayOfWeek().getDisplayName(TextStyle.FULL, Locale.of("es", "es"));
}
public static String diaCumpleOtro(int mes, int dia) {
LocalDate cumple = LocalDate.of(LocalDate.now().getYear(), mes, dia);
// Lo mismo pero usando un formateador
return cumple.format(DateTimeFormatter.ofPattern("EEEE"));
}
public static int numFestivos(int anyo, int mes) {
// Pongo la fecha del dia uno de mes
LocalDate fecha = LocalDate.of(anyo, mes, 1);
// Defino un contador
int festivos = 0;
// Mientras sigamos en este mes
while (fecha.getMonthValue() == mes) {
// Comparo con sábado y domingo
if (fecha.getDayOfWeek() == DayOfWeek.SATURDAY || fecha.getDayOfWeek() == DayOfWeek.SUNDAY) {
festivos++;
}
// Sumo uno al día para recorrer todos los días del mes
fecha = fecha.plusDays(1);
}
return festivos;
}
public static String diasLaborables(int dia, int mes, int anyo) {
// Creo la fecha que me han pasado
LocalDate fecha = LocalDate.of(anyo, mes, dia);
// Aquí acumularé las fechas
String resultado = "";
// Contador días laborables
int cont = 0;
while (cont < 15) {
// Si el día es laborable
if (fecha.getDayOfWeek().getValue() < 6) {
// Lo añado a la cadena
resultado += fecha.toString() + " - ";
// Sumo uno al contador
cont++;
}
// Siempre sumo uno a la fecha
fecha = fecha.plusDays(1);
}
return resultado;
}
public static LocalDate[] diasLaborablesArray(int dia, int mes, int anyo) {
return diasLaborablesArray(dia,mes,anyo,15);
}
public static LocalDate[] diasLaborablesArray(int dia, int mes, int anyo, int numDias) {
// Creo la fecha que me han pasado
LocalDate fecha = LocalDate.of(anyo, mes, dia);
// Aquí acumularé las fechas
LocalDate[] resultado = new LocalDate[15];
// Contador días laborables
int cont = 0;
while (cont < numDias) {
// Si el día es laborable
if (fecha.getDayOfWeek().getValue() < 6) {
// Lo añado a la cadena
resultado[cont] = fecha;
// Sumo uno al contador
cont++;
}
// Siempre sumo uno a la fecha
fecha = fecha.plusDays(1);
}
return resultado;
}
}
Ejemplos fechas en Java
LocalDate fecha = LocalDate.now();
System.out.println(fecha);
System.out.println(fecha.getDayOfMonth());
System.out.println(fecha.getDayOfYear());
System.out.println(fecha.getYear());
// Crear una fecha específica
LocalDate specificDate = LocalDate.of(2023, 5, 14);
System.out.println(specificDate.getDayOfWeek().getValue());
LocalDate juevesproximo=fecha.plusWeeks(1);
System.out.println(juevesproximo);
// En temp cojo la fecha de hoy
LocalDate temp=LocalDate.now();
temp=LocalDate.of(2023, 1, 1);
// Miro el mes en el que estamos
int mes=temp.getMonthValue();
// Mientras la fecha siga siendo del mismo mes
while(temp.getMonthValue()==mes) {
// Si es sábado, imprimo la fecha
if (temp.getDayOfWeek()==DayOfWeek.SATURDAY) {
System.out.println("Este día es sábado:"+temp);
temp=temp.plusDays(7);
}else {
temp=temp.plusDays(1);
}
// Sumo un día a la fecha
}
temp=LocalDate.of(2023, 8, 15);
// Formatear
System.out.println(temp.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")));
// Parsear
LocalDate fechaParseada = LocalDate.parse("2022-12-03");
System.out.println("Fecha parseada: " + fechaParseada);
// Parsear con un formato determinado
LocalDate fechaParseada2 = LocalDate.parse("03/12/2023",DateTimeFormatter.ofPattern("dd/MM/yyyy"));
System.out.println("Fecha parseada: " + fechaParseada2);
// Crear una hora específica
LocalTime specificTime = LocalTime.of(14, 30,50);
System.out.println(specificTime);
// Momento actual
LocalTime ahora=LocalTime.now();
System.out.println(ahora);
// Obtener partes de la hora
System.out.println(ahora.getHour());
System.out.println(ahora.getMinute());
System.out.println(ahora.getNano());
// Añadir o restar partes de tiempo
LocalTime momento=ahora.plusHours(2);
System.out.println(momento);
// Podemos parsear una cadena de caracteres
LocalTime cita=LocalTime.parse("10:00:00");
System.out.println(cita);
// Crear una fecha y hora específica
LocalDateTime specificDateTime = LocalDateTime.of(2023, 5, 15, 14, 30);
System.out.println(specificDateTime);
// Obtener partes de la fecha/hora
LocalDateTime esteMomento=LocalDateTime.now();
System.out.println(esteMomento);
System.out.println(esteMomento.getMonthValue());
System.out.println(esteMomento.getHour());
System.out.println(esteMomento.getSecond());
System.out.println(esteMomento.getDayOfYear());
// Sumar y restar partes de tiempo
esteMomento=esteMomento.plusDays(1);
esteMomento=esteMomento.plusHours(1);
System.out.println(esteMomento);
// Parsear una fecha y una hora
LocalDateTime fechahora=LocalDateTime.parse("2023-11-17T21:12:10");
System.out.println(fechahora);
Más ejemplos arrays
public static void main(String[] args) {
// Resolver el problema de rellenar un array de string
// Con puntos que se incrementan
String[] puntos = new String[10];
String cadena = ".";
for (int i = 0; i < puntos.length; i++) {
puntos[i] = ".".repeat(i + 1);
cadena += ".";
}
System.out.println(Arrays.toString(puntos));
int[] a = { 1, 20, 200, 3, 40, 50 };
int[] b = { 1, 2, 3 };
int[] c = a;
// Nos comprueba si dos arrays diferentes tienen
// los mismos valores
System.out.println(Arrays.equals(a, b));
//Arrays.sort(a);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(c));
// Rellena un array con un valor repetido
// Arrays.fill(c, 9);
System.out.println(Arrays.toString(a));
// Copia los n primeros elementos de un array
int[] j = Arrays.copyOf(a, 2);
System.out.println(Arrays.toString(j));
// Esto copia un rango de un array en otro
int[] k = Arrays.copyOfRange(a, 1, 2);
System.out.println(Arrays.toString(k));
// Compara los valores de un array y devuelve
// 1 si el primero es mayor, 0 si son iguales y -1
// Si el segundo es mayor
System.out.println(Arrays.compare(a, b));
// Hace una búsqueda binaria pero el arraytiene
// que estar ordenado previamente
int pos = Arrays.binarySearch(a, 10);
System.out.println(pos);
System.out.println(mayorArray(a));
System.out.println(Arrays.toString(a));
}
// Devuelvo el elemento mayor de un array
static int mayorArray(int[] numeros) {
// Copio (clono) el array para que no se modifique en el main
int[] temp=numeros.clone();
// Lo ordeno
Arrays.sort(temp);
// Devuelvo el ultimo
return temp[temp.length - 1];
}