Examen Resuelto Diciembre 2018 PDF

Preview

Summary

Examen Resuelto Diciembre 2018...

Description

Examen Resuelto Diciembre 2018 Main.java import java.util.Calendar; import java.util.Date;

public class Main {

public static void main(String[] args) { //Defino fechas Calendar f = Calendar.getInstance(); f.set(1999, 10, 26); Date fecha = f.getTime(); f.set(2000, 3, 25); Date fecha2 = f.getTime();

WikiMovies wikiMovies = new WikiMovies(); // Creo el objeto WikiMovies

// PRUEBO A AÑADIR PELICULAS

System.out.println(wikiMovies.addMovie("1111", "Harry Potter", Genero.TERROR, 2017)); // Se añade

System.out.println(wikiMovies.addMovie("1234", "Star Wars", Genero.SCIFI, 1984)); // Se añade

System.out.println(wikiMovies.addMovie("1234", "Aladin", Genero.DRAMA, 1975)); // Error por la referencia

System.out.println(wikiMovies.addMovie("3333", "Rambo", Genero.WESTERN, 1984)); // Se añade

// PRUEBO A AÑADIR ACTORES

System.out.println(wikiMovies.addActor("1234", "Pablo Mateos", fecha)); //Se añade

System.out.println(wikiMovies.addActor("1234", "Pepe Pérez", fecha)); // Error por el codigo

System.out.println(wikiMovies.addActor("1111", "Daniel Radcliffe", fecha2)); //Se añade

// PRUEBO A AÑADIR PERFORMANCES

System.out.println(wikiMovies.addPerformance("1111", "1234", "Ron Weasley")); // Se añade

System.out.println(wikiMovies.addPerformance("1234", "1234", "Luke Skywalker")); // Se añade

System.out.println(wikiMovies.addPerformance("4321", "1234", "Luke Skywalker")); // No existe pelicula

System.out.println(wikiMovies.addPerformance("1234", "4321", "Luke Skywalker")); // No existe actor

System.out.println(wikiMovies.addPerformance("1234", "1234", "Luke Skywalker")); // Ya esta registrada la interpretacion

System.out.println(wikiMovies.addPerformance("1111", "1111", "Harry Potter")); // Se añade

System.out.println(wikiMovies.addPerformance("1111", "1111", "James Potter")); // Se añade (puede un actor interpretar varios papeles en una película)

System.out.println(wikiMovies.addPerformance("3333", "1234", "Unknown")); // Se añade

// PRUEBO A BUSCAR PELICULAS

System.out.println(wikiMovies.findMovie("1234")); // La encuentra

System.out.println(wikiMovies.findMovie("4321")); // No la encuentra

System.out.println(wikiMovies.findMovie("1111")); // La encuentra

// PRUEBO A BUSCAR ACTORES

System.out.println(wikiMovies.findActor("1234")); // Lo encuentra

System.out.println(wikiMovies.findActor("4321")); // No lo encuentra

System.out.println(wikiMovies.findActor("1111")); // Lo encuentra

// PRUEBO A MOSTRAR PELÍCULAS

wikiMovies.showMovie("1234"); // La muestra

wikiMovies.showMovie("4321"); // No la encuentra

wikiMovies.showMovie("1111"); // La muestra y en el orden que me piden

// PRUEBO A MOSTRAR ACTORES

wikiMovies.showActor("1234"); // Lo muestra y en el orden que me piden

wikiMovies.showActor("4321"); // No lo encuentra

wikiMovies.showActor("1111"); // Lo muestra y en orden correcto

// PRUEBO VARIOS FILTROS

for(Movie pelicula: wikiMovies.getFilteredFilmography("1234" , MovieFilter.byYear(2017))){ // Se muestran las del 2017 System.out.println(pelicula.getTitulo()); }

for(Movie pelicula: wikiMovies.getFilteredFilmography("1234" , MovieFilter.byYear(1984))){ // Se muestran las del 1984 System.out.println(pelicula.getTitulo()); }

for(Movie pelicula: wikiMovies.getFilteredFilmography("1234" , MovieFilter.byYear(1984).and(MovieFilter.byGenre(Genero.SCIFI)))){ // Se muestran las del 1984 de scifi System.out.println(pelicula.getTitulo());

}

for(Movie pelicula: wikiMovies.getFilteredFilmography("1234" , MovieFilter.byYear(2017).not())){ // Se muestran las que NO son del 2017 System.out.println(pelicula.getTitulo()); }

for(Movie pelicula: wikiMovies.getFilteredFilmography("1234" , MovieFilter.byYear(2017).or(MovieFilter.byCoStarring(wikiMovies.findActor("1234"))))){ // Se muestran las que NO son del 2017 or actua el actor 1234 System.out.println(pelicula.getTitulo()); } }

}

WikiMovies.java import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map;

public class WikiMovies { private Map peliculas = new HashMap(); // Utilizo un mapa ya que la referencia de cada película, de tipo String; la identifica y por tanto es su clave. Además, no requerimos de ningún orden así que no es necesario utilizar un TreeMap. Por ello, utilizo un HashMap. private Map actores = new HashMap(); // Utilizo un mapa ya que el código de cada actor, de tipo String; le identifica y por tanto es su clave. Además, no requerimos de ningún orden así que no es necesario utilizar un TreeMap. Por ello, utilizo un HashMap.

protected boolean addMovie(String referencia, String titulo, Genero genero, int añoProduccion){ if(peliculas.containsKey(referencia)==true){ // Una pelicula con esa referencia ya esta registrada return false; // No creo ni añado } // No existe otra pelicula con esa referencia, por lo que puedo añadirla. peliculas.put(referencia, new Movie(referencia, titulo, genero, añoProduccion));

return true; // Creada y añadida }

protected boolean addActor(String codigo, String nombre, Date fechaNacimiento){ if(actores.containsKey(codigo)==true){ // Un actor con ese codigo ya esta registrado return false; // No creo ni añado } // No existe otro actor con ese codigo, por lo que puedo añadirlo. actores.put(codigo, new Actor(codigo, nombre, fechaNacimiento)); return true; // Creado y añadido }

protected int addPerformance(String referenciaMovie, String codigoActor, String nombrePersonaje){ if(peliculas.containsKey(referenciaMovie)==false){ // No existe la referencia return -1; // No existe la película } if(actores.containsKey(codigoActor)==false){ // No existe el codigo return -2; // No existe el codigo } if(peliculas.get(referenciaMovie).addPerformance(nombrePersonaje, actores.get(codigoActor))==false){ return -3; //Ya está interpretado, no puedo añadirlo } else{ // Ya está añadido como reparto en la película. Ahora procedo a incluir la película en la filmografía del actor actores.get(codigoActor).addPerformance(nombrePersonaje, peliculas.get(referenciaMovie)); return 0; // OK } }

protected Movie findMovie(String referencia){ if(peliculas.containsKey(referencia)==false){ // No existe la película return null; } //Sí que existe return peliculas.get(referencia); }

protected Actor findActor(String codigo){

if(actores.containsKey(codigo)==false){ // No existe el actor return null; } //Sí que existe return actores.get(codigo); }

protected void showMovie(String referencia){ if(peliculas.containsKey(referencia)==false){ // No existe la película System.out.println("No existe ninguna película con esa referencia."); return; } // Sí que existe Movie pelicula = peliculas.get(referencia); System.out.println("Título: [" + pelicula.getTitulo() + "] Año: [" + pelicula.getAñoProduccion() + "] Género: [" + pelicula.getGenero() + "]"); pelicula.visualizarReparto(); }

protected void showActor(String codigo){ SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); if(actores.containsKey(codigo)==false){ // No existe el actor System.out.println("No existe ningun actor con ese codigo."); return; } //Sí que existe Actor actor = actores.get(codigo); System.out.println("Nombre: [" + actor.getNombre() + "] Fecha nacimiento: [" + sdf.format(actor.getFechaNacimiento()) + "]"); actor.visualizarFilmografia(); }

protected List getFilteredFilmography(String code, MovieFilter filter){ if(actores.containsKey(code)==false){ // No existe el actor return null; } // Sí que existe

List resultado = new LinkedList(); //Utilizo un ArrayList ya que me es indiferente utilizar ArrayList o LinkedList y así me garantizo que se recorra secuencialmente for (Movie pelicula : actores.get(code).getPeliculas()){ if(filter.test(pelicula) == true){ resultado.add(pelicula); } } return resultado; } }

Movie.java import java.util.Map; import java.util.TreeMap;

public class Movie { private String referencia; private String titulo; private Genero genero; private int añoProduccion; private Map reparto = new TreeMap (); //He decidido utilizar un mapa ya que garantiza la no repeticion de claves y en este caso, la clave seria el nombre de personaje. Este no se puede repetir y se asocia con un actor que lo interpreta; es decir, el valor del elemento que referencia la clave. He utilizado un TreeMap ya que voy a ordenarlo por orden natural (nombre del personaje) para así mostrarlo directamente en la funcionalidad de showMovie()

public Movie(String referencia, String titulo, Genero genero, int añoProduccion) { this.referencia = referencia; this.titulo = titulo; this.genero = genero; this.añoProduccion = añoProduccion; }

protected boolean isPersonajeInterpretado(String nombrePersonaje){ if(reparto.containsKey(nombrePersonaje)==true){ // El personaje ya está interpretado return true; } else{ // El personaje no está interpretado

return false; } }

protected boolean addPerformance(String nombrePersonaje, Actor actor){ if(isPersonajeInterpretado(nombrePersonaje)==true){ return false; // No puedo, ya interpretado } // No se ha interpretado aún reparto.put(nombrePersonaje, actor); return true; }

protected String getReferencia() { return referencia; }

protected String getTitulo() { return titulo; }

protected Genero getGenero() { return genero; }

protected int getAñoProduccion() { return añoProduccion; }

protected void visualizarReparto() { for(String nombrePersonaje: reparto.keySet()){ System.out.println(" : "); } }

}

Actor.java import java.util.Collections; import java.util.Date; import java.util.LinkedList; import java.util.List;

public class Actor { private String codigo; private String nombre; private Date fechaNacimiento; private List filmografia = new LinkedList (); //He decidido utilizar un LinkedList para almacenar la filmografia ya que no tengo claves, así que no tiene sentido utilizar un mapa y además, puede haber repetición tanto de mismo personaje en diferentes películas como de que interprete varios papeles en una; así que no es muy eficiente un Set. Sin embargo, un LinkedList garantiza almacenar todo sin problema; y luego mas tarde nos faciita a ordenarlo con un sort. No utilizo ArrayList porque quiero acceso secuencial, no aleatorio.

public Actor(String codigo, String nombre, Date fechaNacimiento) { this.codigo = codigo; this.nombre = nombre; this.fechaNacimiento = fechaNacimiento; }

protected void addPerformance(String nombrePersonaje, Movie pelicula){ filmografia.add(new Performance(nombrePersonaje, pelicula)); //Suponemos que no estamos añadiendo una pelicula y personaje dos veces }

protected String getCodigo() { return codigo; }

protected String getNombre() { return nombre; }

protected Date getFechaNacimiento() { return fechaNacimiento; }

protected void visualizarFilmografia() { // Ordeno la filmografía por año y luego por título Collections.sort(filmografia, new ComparatorByAño().thenComparing(new ComparatorByTitulo())); //Muestro ahora for(Performance performance: filmografia){ System.out.println(" : : "); } }

protected boolean isActor(Movie pelicula){ for(Performance performance: filmografia){ if(pelicula.equals(performance.getPelicula())){ return true; // el actor actua en la pelicula } } return false; // no actua en la pelicula, ya que ha recorrido toda la lista y no la ha encontrado }

protected List getPeliculas(){ List peliculasActor = new LinkedList(); //Utilizo un ArrayList ya que me es indiferente utilizar ArrayList o LinkedList y así me garantizo que se recorra secuencialmente for(Performance performance: filmografia){ peliculasActor.add(performance.getPelicula()); } return peliculasActor; } }

Performance.java public class Performance { private String nombrePersonaje; private Movie pelicula;

public Performance(String nombrePersonaje, Movie pelicula) { this.nombrePersonaje = nombrePersonaje; this.pelicula = pelicula; }

protected String getNombrePersonaje() { return nombrePersonaje; }

protected Movie getPelicula() { return pelicula; }

}

Genero.java public enum Genero { DRAMA, TERROR, WESTERN, SCIFI; }

MovieFilter.java public interface MovieFilter {

abstract boolean test(Movie movie);

static MovieFilter byYear(int year){ return new FilterByYear(year); }

static MovieFilter byGenre(Genero genre){ return new FilterByGenre(genre); }

static MovieFilter byCoStarring(Actor actor){ return new FilterByCoStarring(actor); }

default MovieFilter not (){ return new Not(this);

} default MovieFilter and (MovieFilter filter){ return new And(this, filter);

} default MovieFilter or (MovieFilter filter){ return new Or(this, filter); } }

FilterByYear.java public class FilterByYear implements MovieFilter {

private int año;

protected FilterByYear(int year) { this.año = year; }

@Override public boolean test(Movie pelicula) { if(pelicula.getAñoProduccion()==año){ return true; } return false; }

}

FilterByGenre.java public class FilterByGenre implements MovieFilter {

private Genero genero;

public FilterByGenre(Genero genre) { this.genero=genre;

}

@Override public boolean test(Movie pelicula) { if(genero==pelicula.getGenero()){ return true; } return false; }

}

FilterByCoStarring.java public class FilterByCoStarring implements MovieFilter {

private Actor actor;

public FilterByCoStarring(Actor actor) { this.actor=actor; }

@Override public boolean test(Movie pelicula) { if(actor.isActor(pelicula)==true){ return true; } return false; }

}

And.java public class And implements MovieFilter { private MovieFilter f1; private MovieFilter f2;

public And(MovieFilter filter1, MovieFilter filter2) { this.f1=filter1; this.f2=filter2; }

@Override public boolean test(Movie pelicula) { if(f1.test(pelicula)==true && f2.test(pelicula)==true){ return true; } return false; }

}

Or.java public class Or implements MovieFilter { private MovieFilter f1; private MovieFilter f2;

public Or(MovieFilter filter1, MovieFilter filter2) { this.f1=filter1; this.f2=filter2; }

@Override public boolean test(Movie pelicula) { if(f1.test(pelicula)==true || f2.test(pelicula)==true){ return true; } return false; }

}

Not.java

public class Not implements MovieFilter { private MovieFilter not;

public Not(MovieFilter filter) { this.not = filter; }

@Override public boolean test(Movie pelicula) { if(not.test(pelicula)==true){ return false; } return true; } }

ComparatorByTitulo.java import java.util.Comparator;

public class ComparatorByTitulo implements Comparator{

@Override public int compare(Performance o1, Performance o2) { return o1.getPelicula().getTitulo().compareToIgnoreCase(o2.getPelicula().getTitulo()); }

}

ComparatorByAño.java import java.util.Comparator;

public class ComparatorByAño implements Comparator{

@Override

public int compare(Performance o1, Performance o2) { return o1.getPelicula().getAñoProduccion() - o2.getPelicula().getAñoProduccion(); }

}...