Mes: noviembre 2023

public class Persona {
	private String nombre;
	private String dni;
	
	public Persona(String nombre) {
		this.nombre=nombre;
	}
	
	public String saludo() {
		return "Hola "+nombre;
	}

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getDni() {
		return dni;
	}

	public void setDni(String dni) {
		this.dni = dni;
	}
	
}

public class Caballero extends Persona {
	private String tratamiento;
	private int renta;
	
	public Caballero(String nombre, String tratamiento) {
		super(nombre);
		this.tratamiento=tratamiento;
	}

	@Override
	public String saludo() {
		return "Hola "+tratamiento+" "+getNombre();
	}

	public String getTratamiento() {
		return tratamiento;
	}

	public void setTratamiento(String tratamiento) {
		this.tratamiento = tratamiento;
	}

	public int getRenta() {
		return renta;
	}

	public void setRenta(int renta) {
		this.renta = renta;
	}
	
}

public class Plebeyo extends Persona {

	public Plebeyo(String nombre) {
		super(nombre);
	}

	@Override
	public String saludo() {
		return super.saludo()+" ¿Qué pasa?";
	}
}

	Persona pepe=new Persona("pepe");
		System.out.println(pepe.saludo());
		Caballero pelayo=new Caballero("Pelayo", "Don");
		System.out.println(pelayo.saludo());
		Plebeyo sancho=new Plebeyo("Sancho Panza");
		System.out.println(sancho.saludo());

public class Rectangulo {
	private double ancho;
	private double alto;

	public Rectangulo(double ancho, double alto) {
		this.ancho = ancho;
		this.alto = alto;
	}

	public double getAncho() {
		return ancho;
	}

	public void setAncho(double ancho) {
		this.ancho = ancho;
	}

	public double getAlto() {
		return alto;
	}

	public void setAlto(double alto) {
		this.alto = alto;
	}

	public double perimetro() {
		return ancho * 2 + alto * 2;
	}

	public double area() {
		return ancho * alto;
	}

	public boolean oblongo() {
		return ancho > alto;
	}

}

Rectangulo r=new Rectangulo(2,3);
		r.setAlto(9);
		System.out.println(r.getAlto());
		System.out.println(r.area());
		System.out.println(r.oblongo());

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