Categoría: Java

package com.trifulcas.colecciones;

import java.util.ArrayList;
import java.util.Collections;

public class EjemplosCollection {

	public static void main(String[] args) {
		ArrayList<String> nombres = new ArrayList<String>();
		nombres.add("Juan");
		nombres.add("María");

		Collections.addAll(nombres, "Pedro", "Luis");
		System.out.println("Hemos añadido elementos sueltos en una sola línea");
		System.out.println(nombres); // [Juan, María, Pedro, Luis]
		System.out.println("Invertimos el arrayList");
		Collections.reverse(nombres);
		System.out.println(nombres); // [Luis, Pedro, María, Juan]
		System.out.println("Ordenamos el arrayList");
		Collections.sort(nombres);
		System.out.println(nombres); // [Juan, Luis, María, Pedro]
		System.out.println("Si está ordenado podemos usar binarySearch");
		System.out.println(Collections.binarySearch(nombres, "Pedro"));
		System.out.println("Desordenamos el arrayList");
		Collections.shuffle(nombres);
		System.out.println(nombres); //

		// Intercambiamos los valores de dos posiciones
		Collections.swap(nombres, 1, 2);
		System.out.println("Intercambiar posición 1 y 2");
		System.out.println(nombres); //

		System.out.println("Podemos obtener el máximo");
		System.out.println(Collections.max(nombres)); //Pedro
		System.out.println("Y el mínimo");
		System.out.println(Collections.min(nombres)); //Juan
		System.out.println("Rellenar toda la lista con un valor");
		Collections.fill(nombres, "Ana");
		System.out.println(nombres);
		ArrayList<Integer> numeros=new ArrayList<>();
		Collections.addAll(numeros, 1,2,2,3,3,3,4,4,4,4);
		System.out.println("Frecuencia (numero de apariciones) de un elemento en una lista");
		System.out.println(numeros);
		
		System.out.println(Collections.frequency(numeros, 3));
	}

}

package com.trifulcas.colecciones;

public class EjemplosGenericos {

	public static void main(String[] args) {
		// Al ser tipo int llama a la primera función
		System.out.println(mayor(4,3));
		// Al ser tipo dobule llama a la segunda
		System.out.println(mayor(4.6,3.5));
		// Llamo a la función con parámetros de tipo double
		System.out.println(mayorG(4.6,3.5));
		// Llamo a la función con parámetros de tipo int
		System.out.println(mayorG(3,4));
		// Llamo a la función con parámetros de tipo String
		System.out.println(mayorG("ana","pep"));

	}
	// Esta función tiene de tipo int
	static int mayor(int a, int b) {
		if (a>b) { 
			return a;
		}
		return b;
	}
	// Esta función es una sobrecarga con double
	static double mayor(double a, double b) {
		if (a>b) { 
			return a;
		}
		return b;
	}
	// Aquí utilizo un tipo genérico, puedo llamar a la función
	// Con cualquier tipo (siempre que se pueda comparar, que eso es lo que significa extends Comparable<T>)
	static <T extends Comparable<T>> T mayorG(T a, T b){
		if (a.compareTo(b)>0) { 
			return a;
		}
		return b;
	}
}

package com.trifulcas.colecciones;

import java.util.HashSet;

public class EjemplosHashSet {

	public static void main(String[] args) {
		// Lo creamos con HashSet igual que cualquier colección
		HashSet<String> alumnos = new HashSet<>();
		// añado los elementos con add
		alumnos.add("Ana");
		alumnos.add("Eva");
		alumnos.add("Pep");
		System.out.println("Imprimo el conjunto entero");

		System.out.println(alumnos);
		// Si añado un elemento que ya existe es como si no hiciera nada
		alumnos.add("Ana");
		System.out.println("Al añadir Ana no cambia porque ya estaba");

		System.out.println(alumnos);
		System.out.println("Contains me devuelve true porque Ana está en el conjunto");

		System.out.println(alumnos.contains("Ana"));
		System.out.println("Recorro los elementos del conjunto");

		for (String alumno : alumnos) {
			System.out.println(alumno);
		}
		System.out.println("Elimino el valor de Ana");

		alumnos.remove("Ana");
		System.out.println(alumnos);

	}

}

package com.trifulcas.colecciones;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

public class UsosHashMap {

	public static void main(String[] args) {
		ArrayList<String> usuarios=new ArrayList<>();
		Collections.addAll(usuarios, "Ana","Eva","Juan","Rosa","Pep","Sara");
		System.out.println(generaClaves(usuarios));
		HashMap<String,ArrayList<Integer>> hash02=new HashMap<>();
		hash02.put("Ana", new ArrayList<>());
		hash02.get("Ana").add(5);
		hash02.get("Ana").add(7);
		hash02.get("Ana").add(9);
		hash02.put("Eva", new ArrayList<>());
		hash02.get("Eva").add(6);
		hash02.get("Eva").add(8);
		hash02.get("Eva").add(10);
		System.out.println(getMedias(hash02));
	}
	// Una función a la que le pasamos un arraylist de nombres y nos genera
	// Un diccionario con la clave el nombre y un valor que será una contraseña
	// basada en el nombre, la primera letra del nombre, el índice del arraylist 
	// y la última letra del nombre
	// generaClaves(ArrayList)
	static HashMap<String,String> generaClaves(ArrayList<String> usuarios){
		HashMap<String,String> res=new HashMap<String,String>();
		for (int i=0;i<usuarios.size();i++) {
			String usuario=usuarios.get(i);
			String password=usuario.substring(0,1)+i+usuario.substring(usuario.length()-1);
			res.put(usuarios.get(i), password);
		}
		return res;
	}
	// Una función a la que le pasamos un diccionario con el nombre de un alumno
	// Y el valor un arraylist de notas y nos devuelve el hashmap con las medias
	static HashMap<String,Double> getMedias(HashMap<String,ArrayList<Integer>> notas){
		HashMap<String,Double> res=new HashMap<String,Double>();
		for(String alumno:notas.keySet()) {
			double suma=0;
			for(int nota: notas.get(alumno)) {
				suma+=nota;
			}
			res.put(alumno, suma/notas.get(alumno).size());
		}
		return res;
	}
	
}

package com.trifulcas.colecciones;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;

public class EjemplosHashMap {

	public static void main(String[] args) {
		// Creo un hashmap de clave cadena y valor integer
		HashMap<String, Integer> diccionario = new HashMap<String, Integer>();
		// Añado valores
		diccionario.put("Ana", 7);
		diccionario.put("Eva", 8);
		diccionario.put("Rosa", 6);
		// Recupero valores
		System.out.println(diccionario.get("Ana"));
		System.out.println(diccionario.get("Pep"));
		// Compruebo si existe una clave (en este caso no)
		System.out.println(diccionario.containsKey("Pep"));
		// Recorro las claves
		for (String clave : diccionario.keySet()) {
			// COn la clave tengo el valor vía get
			System.out.println(clave + " - " + diccionario.get(clave));
		}
		// Recorro solo los valores
		for (Integer valor : diccionario.values()) {
			System.out.println(valor);
		}
		// Recorro el par clave valor con entryset
		for (Entry<String, Integer> entrada : diccionario.entrySet()) {
			System.out.println(entrada.getKey()+" - "+entrada.getValue());
		}
		
		// Eliminar elementos
		diccionario.remove("Rosa");
		System.out.println(diccionario);
		// Cambio un valor
		diccionario.put("Ana",9);
		System.out.println(diccionario);
		// Borro todo el hasmap
		diccionario.clear();
		System.out.println(diccionario);
		
		// Yo puedo hacer hashmap de cualquier cosa
		HashMap<Integer,String> hash01=new HashMap<>();
		hash01.put(27, "Hola");
		hash01.put(19, "Adios");
		System.out.println(hash01);
		
		// Un hashmap que tiene como valores un arraylist
		HashMap<String,ArrayList<Integer>> hash02=new HashMap<>();
		hash02.put("Ana", new ArrayList<>());
		hash02.get("Ana").add(5);
		hash02.get("Ana").add(7);
		hash02.get("Ana").add(9);
		hash02.put("Eva", new ArrayList<>());
		hash02.get("Eva").add(6);
		hash02.get("Eva").add(8);
		hash02.get("Eva").add(10);
		System.out.println(hash02);
		for(String alumno:hash02.keySet()) {
			System.out.println(alumno);
			for(int nota:hash02.get(alumno)) {
				System.out.println(nota);
			}
		}
		// El primer elemento del alumno "Ana"
		System.out.println(hash02.get("Ana").get(0));
	}

}

package com.trifulcas.colecciones;

import java.util.ArrayList;
import java.util.LinkedList;

public class SolucionesEjercicios {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(tablaMultiplicar(7));
		System.out.println(menoresQue(new int[] { 1, 2, 3, 4, 5, 6 }, 4));
		System.out.println(menoresQue(new String[] { "hola","que","tal","estamos" }, 4));
		LinkedList<Integer> a=new LinkedList<Integer>();
		a.add(1);
		a.add(2);
		a.add(3);
		a.add(4);
		LinkedList<Integer> b=new LinkedList<Integer>();
		b.add(3);
		b.add(4);
		b.add(5);
		b.add(6);
		System.out.println(diferencia(a,b));
	}

	/*
	 * Crear una función tablaMultiplicar(numero) a la que le pasamos un número y
	 * nos devuelve un arraylist con la tabla de multiplicar de ese número
	 * tablaMultiplicar(5)->[5,10,15,20,25,30,35,40,45,50]
	 */
	static ArrayList<Integer> tablaMultiplicar(int numero) {
		ArrayList<Integer> res = new ArrayList<Integer>();
		for (int i = 1; i <= 10; i++) {
			res.add(i * numero);
		}
		return res;
	}

	/*
	 * Crear una función menoresQue a la que le pasamos un array de enteros y un
	 * entero y nos devuelve un arraylist con los números menores o iguales a ese
	 * entero menoresQue([1,2,3,4,5,6],4)->[1,2,3,4]
	 */
	static ArrayList<Integer> menoresQue(int[] lista, int limite) {
		ArrayList<Integer> res = new ArrayList<Integer>();
		for (int numero : lista) {
			if (numero <= limite) {
				res.add(numero);
			}
		}
		return res;
	}

	/*
	 * Crear una sobrecarga con String que nos devuelva las cadenas de longitud
	 * menor o igual al entero menoresQue(["Eva","Ana","Jaimito"],4)->["Eva","Ana"]
	 */
	static ArrayList<String> menoresQue(String[] lista, int limite) {
		ArrayList<String> res = new ArrayList<String>();
		for (String cadena : lista) {
			if (cadena.length() <= limite) {
				res.add(cadena);
			}
		}
		return res;
	}
	/*
	 * Crear una función diferencia a la que le pasamos dos 
	 * linkedlist de enteros y nos devuelve un linkedlist 
	 * con los elementos del primer linkedlist que no están
	 *  en el segundo
		diferencia([1,2,3,4],[3,4,5,6])->[1,2]
	 */
	static LinkedList<Integer> diferencia(LinkedList<Integer> a, LinkedList<Integer> b){
		LinkedList<Integer> res=new LinkedList<Integer>();
		for (int numero:a) {
			if (!b.contains(numero)) {
				res.add(numero);
			}
		}
		return res;
	}
}

package com.trifulcas.colecciones;

import java.util.LinkedList;

public class FuncionesLinkedList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(creaLista(6));
		LinkedList<Integer> numeros=new LinkedList<Integer>();
		numeros.add(1);
		numeros.add(2);
		numeros.add(3);
		System.out.println(numeros);
		System.out.println(invertir(numeros));
		String[] alumnos= {"Ana","Eva","Pepe","Rosa"};
		System.out.println(alumnosPares(alumnos));
	}
	// Crear una función a la que le pasamos un limite y nos crea una lista
	// de la forma 1 2 3 4 5 4 3 2 1
	static LinkedList<Integer> creaLista(int limite){
		LinkedList<Integer> res=new LinkedList<Integer>();
		res.add(limite);
		for(int i=limite-1;i>0;i--) {
			res.addFirst(i);
			res.addLast(i);
		}
		return res;
	}
	// Crear una función a la que le pasamos un linkedList y nos devuelve
	// una linkedlist con los elementos invertidos
	static LinkedList<Integer> invertir(LinkedList<Integer> lista){
		LinkedList<Integer> res=new LinkedList<Integer>();
		for(int i:lista) {
			res.push(i);
		}
		return res;
	}
	
	// Crear una función a la que le pasamos un array de alumnos (Strings)
	// y nos devuelve un linkedlist de los alumnos que están en la posición par
	static LinkedList<String> alumnosPares(String[] alumnos){
		LinkedList<String> res= new LinkedList<String>();
		for(int i=0;i<alumnos.length;i++) {
			if (i%2==0) {
				res.add(alumnos[i]);
			}
		}
		return res;
	}
}

package com.trifulcas.colecciones;

import java.time.LocalDate;
import java.util.LinkedList;
import java.util.List;

public class EjemplosLinkedList {

	public static void main(String[] args) {
		LinkedList<String> lista = new LinkedList<String>();

		// Lo mismo pero no especifico tipo
		LinkedList<String> lista2 = new LinkedList<>();

		// Lo mismo pero usando la clase abstracta
		List<String> lista3 = new LinkedList<String>();

		// Muy importante: el tipo tiene que ser una clase
		// LinkedList<int> enteros=new LinkedList<int>();
		// Utilizar unas clases 'wrapper' (envolventes)
		// Que son lo mismo que los tipos primitivos pero en clase
		LinkedList<Integer> enteros = new LinkedList<Integer>();
		LinkedList<Boolean> boleanos = new LinkedList<Boolean>();
		LinkedList<Double> decimales = new LinkedList<Double>();

		// No especificamos tamaño, porque es dinámico
		// Yo añado elementos con add, los que quiera
		enteros.add(5);
		enteros.add(9);
		enteros.add(13);
		System.out.println(enteros);
		// Puedo recorrer con un for :
		for (Integer i : enteros) {
			System.out.println(i);
		}
		// Con un for normal usando el size (tamaño)
		for (int i = 0; i < enteros.size(); i++) {
			// con get obtenemos el elemento en esa posición
			System.out.println(enteros.get(i));
		}
		// Podemos usar el foreach
		enteros.forEach(x -> System.out.println(x));

		LinkedList<LocalDate> fechas = new LinkedList<LocalDate>();
		fechas.add(LocalDate.now());

		// Añadir en un índice determinado
		enteros.add(1, 666);
		System.out.println(enteros);
		// Eliminamos el elemento de la posición 2
		enteros.remove(2);
		System.out.println(enteros);

		// Si un elemento está dentro el LinkedList
		System.out.println(enteros.contains(5)); // true
		System.out.println(enteros.contains(90)); // false

		// Buscar la posición de un elemento
		System.out.println(enteros.indexOf(13)); // 2
		System.out.println(enteros.indexOf(130)); // -1 porque no lo encuentra

		// Tenemos una serie de funciones que nos van a recordar a JS

		// Yo puedo añadir al principio
		enteros.push(7);
		System.out.println(enteros);
		// Recuperar del principio (y se va de la lista)
		int r = enteros.pop();
		System.out.println(enteros);

		// ver sin eliminar
		System.out.println(enteros.peekFirst());
		System.out.println(enteros.peekLast());

		System.out.println(enteros.getFirst());
		System.out.println(enteros.getLast());

		while (enteros.size() > 0) {
			System.out.println(enteros.pop());
		}
		for (int i = 2; i < 40; i += 3) {
			enteros.push(i);
		}
		System.out.println(enteros);
		
		// Eliminar
		System.out.println(enteros.poll());
		System.out.println(enteros.pollFirst());
		System.out.println(enteros.pollLast());
		System.out.println(enteros);

	}

}

package com.trifulcas.colecciones;

import java.util.ArrayList;

public class FuncionesArrayList {
	public static void main(String[] args) {

		int[] lista = { 2, 4, 7, 3, 45, 76, 90, 101 };
		ArrayList<Integer> pares = getPares(lista);
		ArrayList<Integer> otra = new ArrayList<Integer>();
		otra.add(4);
		otra.add(76);
		otra.add(40);
		System.out.println(pares);
		System.out.println(sumaArray(pares));
		System.out.println(interseccion(pares,otra));
	}

	// Función a la que le pasamos un array de enteros y nos devuelve los pares
	static ArrayList<Integer> getPares(int[] numeros) {
		ArrayList<Integer> res = new ArrayList<Integer>();
		for (int i : numeros) {
			if (i % 2 == 0) {
				res.add(i);
			}
		}
		return res;
	}

	// Función a la que le pasamos un ArrayLIst de enteros y nos devuelve la suma
	static int sumaArray(ArrayList<Integer> numeros) {
		int suma = 0;
		for (int i : numeros) {
			suma += i;
		}
		return suma;
	}
	
	// Función que le pasamos dos arraylist y nos devuelve la intersección de los dos
	static ArrayList<Integer> interseccion(ArrayList<Integer> a, ArrayList<Integer>b){
		ArrayList<Integer> res=new ArrayList<Integer>();
		for(int i:a) {
			if (b.contains(i)) {
				res.add(i);
			}
		}
		return res;
	}
}

// Sintaxis ArrayList<Tipo de datos> nombre = new ArrayList<Tipo>()
		ArrayList<String> lista = new ArrayList<String>();
		
		// Lo mismo pero no especifico tipo
		ArrayList<String> lista2 = new ArrayList<>();
		
		// Lo mismo pero usando la clase abstracta
		List<String> lista3=new ArrayList<String>();
		
		// Muy importante: el tipo tiene que ser una clase
		//ArrayList<int> enteros=new ArrayList<int>();
		// Utilizar unas clases 'wrapper' (envolventes)
		// Que son lo mismo que los tipos primitivos pero en clase
		ArrayList<Integer> enteros=new ArrayList<Integer>();
		ArrayList<Boolean> boleanos=new ArrayList<Boolean>();
		ArrayList<Double> decimales=new ArrayList<Double>();
		
		// No especificamos tamaño, porque es dinámico
		// Yo añado elementos con add, los que quiera
		enteros.add(5);
		enteros.add(9);
		enteros.add(13);
		System.out.println(enteros);
		// Puedo recorrer con un for :
		for(Integer i:enteros) {
			System.out.println(i);
		}
		// Con un for normal usando el size (tamaño)
		for(int i=0;i<enteros.size();i++) {
			// con get obtenemos el elemento en esa posición
			System.out.println(enteros.get(i));
		}
		// Podemos usar el foreach
		enteros.forEach(x->System.out.println(x));
		
		ArrayList<LocalDate> fechas= new ArrayList<LocalDate>();
		fechas.add(LocalDate.now());
		
		// Añadir en un índice determinado
		enteros.add(1,666);
		System.out.println(enteros);
		// Eliminamos el elemento de la posición 2
		enteros.remove(2);
		System.out.println(enteros);
		
		// Si un elemento está dentro el arraylist
		System.out.println(enteros.contains(5)); // true
		System.out.println(enteros.contains(90)); // false
		
		// Buscar la posición de un elemento
		System.out.println(enteros.indexOf(13)); // 2
		System.out.println(enteros.indexOf(130)); // -1 porque no lo encuentra