public static void main(String[] args) {
// Crear una función a la que le pasamos un hashmap
// De cadenas y números y nos elimine los elementos
// que tengan un valor impar
HashMap<String, Integer> numeros = new HashMap<String, Integer>();
numeros.put("a", 1);
numeros.put("b", 2);
numeros.put("c", 3);
numeros.put("d", 4);
HashMap<String, Integer> res = fueraPares(numeros);
System.out.println(numeros);
System.out.println(res);
System.out.println(fueraParesSin(numeros));
}
public static HashMap<String, Integer> fueraPares(HashMap<String, Integer> lista) {
HashMap<String, Integer> temp = (HashMap<String, Integer>) lista.clone();
for (Entry<String, Integer> par : lista.entrySet()) {
if (par.getValue() % 2 == 0) {
temp.remove(par.getKey());
}
}
return temp;
}
public static HashMap<String, Integer> fueraParesSin(HashMap<String, Integer> lista) {
HashMap<String, Integer> temp = new HashMap<String, Integer>();
for (Entry<String, Integer> par : lista.entrySet()) {
if (par.getValue() % 2 != 0) {
temp.put(par.getKey(),par.getValue());
}
}
return temp;
}
Ejemplos Collections
ArrayList<String> alumnos= new ArrayList<String>();
alumnos.add("Ana");
alumnos.add("Eva");
alumnos.add("Pep");
// Añadir elementos a mi colección de una manera rápida
Collections.addAll(alumnos, "Rosa","Juan","María");
System.out.println(alumnos);
// Sustituye todos los elementos existentes con el que pones
//Collections.fill(alumnos, "Ana");
// Puedo ordenar desde la colección
Collections.sort(alumnos);
// Si le doy la vuelta, tengo de mayor a menor
Collections.reverse(alumnos);
System.out.println(alumnos);
// Desordenar una colección
Collections.shuffle(alumnos);
System.out.println(alumnos);
Collections.reverse(alumnos);
System.out.println(alumnos);
// Intercambiar elementos
Collections.swap(alumnos, 0, 2);
System.out.println(alumnos);
alumnos.add("Ana");
// Veces que aparece un elemento en la colección
System.out.println(Collections.frequency(alumnos, "Ana"));
// Máximo y mínimo
System.out.println(Collections.max(alumnos));
System.out.println(Collections.min(alumnos));
Ejemplos hashSet
HashSet<String> palabras = new HashSet<String>();
palabras.add("perro");
palabras.add("gato");
palabras.add("ratón");
System.out.println(palabras);
palabras.add("ratón");
System.out.println(palabras);
LinkedList<Integer> lista = new LinkedList<Integer>(Arrays.asList(1, 2, 4, 14, 3, 4, 5, 6, 7, 3, 1, 1, 7));
HashSet<Integer> res = new HashSet<Integer>();
res.addAll(lista);
System.out.println(res);
res.retainAll(new ArrayList<Integer>(Arrays.asList(1,2,3,40)));
System.out.println(res);
Ejemplos HashMap
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];
}