Trifulcas

//Instanciar una clase en un objeto
		Auto bmw=new Auto();
		
		Auto seat;
		
		// Puedo acceder a las cosas que he definido en la clase
		bmw.color="Azul metalizado";
		bmw.arrancar();

		
		// Para usar un objeto lo tengo que instanciar
		seat=new Auto();
		
		seat.color="Verde";
		Auto[] concesionario= {bmw,seat,new Auto(),new Auto(),new Auto()};
		concesionario[0].color="Rojo";
		
		System.out.println(bmw.color);
		
		
		seat=new Auto();
		// seat ----> [color,arrancar] (Auto@372f7a8d)
		System.out.println(seat);
		Auto copia=seat; // no copio el objeto, apuntan al mismo sitio
		// Si cambio uno cambio el otro y viceversa
		// seat ----> [color,arrancar]
		// copia ------^
		System.out.println(copia); //Auto@372f7a8d
		
		Auto clonado=new Auto();
		clonado.color=bmw.color;

Auto miCoche = new Auto();
		miCoche.color = "Rosa";
		miCoche.arrancar();
		miCoche.estado();
		miCoche.acelerar();
		miCoche.estado();
		for (int i = 0; i < 10; i++) {
			miCoche.acelerar(200);
		}
		miCoche.estado();
		
		Alumno ana=new Alumno();
		ana.nombre="Ana Pi";
		ana.notas.addAll(Arrays.asList(1,2,3,4,5,6));
		
		System.out.println(ana.media());

// Definición de la clase, no es un objeto
public class Auto {
	public String color;
	int velocidad;
	int limiteVelocidad = 100;

	public void arrancar() {
		velocidad = 0;
		System.out.println("Brum brum ");
	}

	public void acelerar() {
		acelerar(10);

	}

	public void acelerar(int cantidad) {
		velocidad += cantidad;
		if (velocidad > 100) {
			velocidad = 100;
		}

	}

	public void frenar() {
		if (velocidad > 10) {
			velocidad -= 10;
		}
	}

	public void estado() {
		System.out.println("Vamos a " + velocidad + " por horaa!!");
	}
}

import java.util.ArrayList;
public class Alumno {
	// El public es un modificador de acceso
	// Quiere decir que cualquiera puede acceder al valor
	public String nombre;
	// Tenemos tres sabores de protección
	// public, protected y private
	private ArrayList<Integer> notas;

	// Los parámetros que queremos poner al crear la clase
	public Alumno(String nombre) {
		// Las cosas que queremos que se ejecuten
		// cuando creamos la clase
		// this.nombre es el nombre del objeto
		// nombre es el parámetro que le pasamos
		this.nombre = nombre;
		notas = new ArrayList<Integer>();
	}

	public Alumno() {
		// Llamando a la sobrecarga del constructor
		this("anonimo");

	}

	public int ponNota(int nota) {
		// Me aseguro de que mis notas están entre 0  10
		if (nota > 0 && nota <= 10) {
			notas.add(nota);
		}
		return notas.size();
	}

	public double media() {

		double total = 0;
		// Desde dentro de la clase si que puedo acceder
		for (int nota : notas) {
			total += nota;
		}
		return total / this.notas.size();
	}
}

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;

	}

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));
		

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);

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);

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;
	}

	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;
	}

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);
		;
	}

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);
		
	}

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;
	}