OOP - answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
Point2D point2D = new Point2D(10, 20);
point2D.setXY(43, 65);
System.out.println(point2D);
Point3D point3D = new Point3D(10, 20, 30);
point3D.setXYZ(43, 64, 2);
System.out.println(point3D);
}
}
class Point2D {
protected float x, y;
public Point2D() {
public Point2D(float x, float y) {
this.x = x;
this.y = y;
}
public float getX() {
return x;
}
public void setX(float x) {
this.x = x;
}
public float getY() {
return y;
}
public void setY(float y) {
this.y = y;
}
public float[] getXY() {
return new float[]{x, y};
}
public void setXY(float x, float y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return String.format("(%f,%f)", x, y);
}
}
class Point3D extends Point2D {
private float z;
public Point3D(float x, float y, float z) {
super(x, y);
this.z = z;
}
public float getZ() {
return z;
}
public void setZ(float z) {
this.z = z;
}
public float[] getXYZ() {
return new float[]{x, y, z};
}
public void setXYZ(float x, float y, float z) {
this.setXY(x, y);
this.z = z;
}
@Override
public String toString() {
return String.format("(%f,%f,%f)", x, y, z);
}
}
Task 2
public class Exercise2 {
public static void main(String[] args) {
Person student = new Student("John", "BC 43", "IT", 1,
1000);
Person staff = new Staff("Computer Programming", 4500f);
System.out.println(student);
System.out.println(staff);
}
}
class Person {
protected String name, address;
public Person() {
public Person(String name, String address) {
this.name = name;
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return String.format("%s->%s", name, address);
}
}
class Student extends Person {
private String typeOfStudies;
private int yearOfStudy;
private float studiesPrice;
public Student(String name, String address, String
typeOfStudies, int yearOfStudy, float studiesPrice) {
super(name, address);
this.typeOfStudies = typeOfStudies;
this.yearOfStudy = yearOfStudy;
this.studiesPrice = studiesPrice;
}
public String getTypeOfStudies() {
return typeOfStudies;
}
public void setTypeOfStudies(String typeOfStudies) {
this.typeOfStudies = typeOfStudies;
}
public int getYearOfStudy() {
return yearOfStudy;
}
public void setYearOfStudy(int yearOfStudy) {
this.yearOfStudy = yearOfStudy;
}
public float getStudiesPrice() {
return studiesPrice;
}
public void setStudiesPrice(float studiesPrice) {
this.studiesPrice = studiesPrice;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
", typeOfStudies='" + typeOfStudies + '\'' +
", yearOfStudy='" + yearOfStudy + '\'' +
", studiesPrice=" + studiesPrice +
'}';
}
}
class Staff extends Person {
private String specialization;
private float salary;
public Staff(String specialization, float salary) {
this.specialization = specialization;
this.salary = salary;
}
public String getSpecialization() {
return specialization;
}
public void setSpecialization(String specialization) {
this.specialization = specialization;
}
public float getSalary() {
return salary;
}
public void setSalary(float salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Staff{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
", specialization='" + specialization + '\'' +
", salary='" + salary + '\'' +
'}';
}
}
Task 3
public class Exercise3 {
public static void main(String[] args) {
Shape shape = new Shape("red", false);
System.out.println(shape);
Shape circle = new Circle("blue", true, 20);
System.out.println(circle);
Shape rectangle = new Rectangle("yellow", true, 20, 30);
System.out.println(rectangle);
Shape square = new Square("green", false, 40);
System.out.println(square);
}
}
class Shape {
private String color;
private boolean isFilled;
public Shape() {
this.color = "unknown";
this.isFilled = false;
}
public Shape(String color, boolean isFilled) {
this.color = color;
this.isFilled = isFilled;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public boolean isFilled() {
return isFilled;
}
public void setFilled(boolean filled) {
isFilled = filled;
}
@Override
public String toString() {
return String.format("Shape with color of %s and %s",
color, isFilled ? "filled" : "NotFilled");
}
}
class Circle extends Shape {
private float radius;
public Circle(String color, boolean isFilled, float radius) {
super(color, isFilled);
this.radius = radius;
}
public float getRadius() {
return radius;
}
public void setRadius(float radius) {
this.radius = radius;
}
public float getArea() {
return (float) (Math.PI * radius * radius);
}
public float getPerimeter() {
return (float) (2 * Math.PI * radius);
}
@Override
public String toString() {
return String.format("Circle with radius=%f which is
subclass off %s", radius, super.toString());
}
}
class Rectangle extends Shape {
protected double width, length;
public Rectangle(String color, boolean isFilled, double width,
double length) {
super(color, isFilled);
this.width = width;
this.length = length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public float getArea() {
return (float) (width * length);
}
public float getPerimeter() {
return (float) (2 * width + 2 * length);
}
@Override
public String toString() {
return String.format("Rectangle with width=%f and
length=%f which is subclass off %s", width, length,
super.toString());
}
}
class Square extends Rectangle {
public Square(String color, boolean isFilled, double size) {
super(color, isFilled, size, size);
}
@Override
public void setWidth(double width) {
super.setWidth(width);
super.setLength(width);
}
@Override
public void setLength(double length) {
super.setWidth(width);
super.setLength(length);
}
@Override
public String toString() {
return String.format("Square with width=%f and length=%f
which is subclass off %s", width, length, super.toString());
}
}
Task 4
public class Exercise4 {
public static void main(String[] args) {
ShapeEx4[] shapes = {
new CircleEx4("blue", true, 20),
new RectangleEx4("yellow", true, 20, 30),
new SquareEx4("green", false, 40)
};
for (ShapeEx4 shape : shapes) {
System.out.println(shape);
System.out.println(shape.getArea());
System.out.println(shape.getPerimeter());
}
}
}
abstract class ShapeEx4 {
private String color;
private boolean isFilled;
public ShapeEx4() {
this.color = "unknown";
this.isFilled = false;
}
public ShapeEx4(String color, boolean isFilled) {
this.color = color;
this.isFilled = isFilled;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public boolean isFilled() {
return isFilled;
}
public void setFilled(boolean filled) {
isFilled = filled;
}
public abstract float getArea();
public abstract float getPerimeter();
@Override
public String toString() {
return String.format("Shape with color of %s and %s",
color, isFilled ? "filled" : "NotFilled");
}
}
class CircleEx4 extends ShapeEx4 {
private float radius;
public CircleEx4(String color, boolean isFilled, float radius)
{
super(color, isFilled);
this.radius = radius;
}
public float getRadius() {
return radius;
}
public void setRadius(float radius) {
this.radius = radius;
}
@Override
public float getArea() {
return (float) (Math.PI * radius * radius);
}
@Override
public float getPerimeter() {
return (float) (2 * Math.PI * radius);
}
@Override
public String toString() {
return String.format("Circle with radius=%f which is
subclass off %s", radius, super.toString());
}
}
class RectangleEx4 extends ShapeEx4 {
protected double width, length;
public RectangleEx4(String color, boolean isFilled, double
width, double length) {
super(color, isFilled);
this.width = width;
this.length = length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
@Override
public float getArea() {
return (float) (width * length);
}
@Override
public float getPerimeter() {
return (float) (2 * width + 2 * length);
}
@Override
public String toString() {
return String.format("Rectangle with width=%f and
length=%f which is subclass off %s", width, length,
super.toString());
}
}
class SquareEx4 extends RectangleEx4 {
public SquareEx4(String color, boolean isFilled, double size)
{
super(color, isFilled, size, size);
}
@Override
public void setWidth(double width) {
super.setWidth(width);
super.setLength(width);
}
@Override
public void setLength(double length) {
super.setWidth(width);
super.setLength(length);
}
@Override
public String toString() {
return String.format("Square with width=%f and length=%f
which is subclass off %s", width, length, super.toString());
}
}
Task 5
public class Exercise5 {
public static void main(String[] args) {
Line line = new Line(10, 20, 30, 40);
System.out.println(line.getLength());
System.out.println(line.getMiddlePoint());
}
}
class Line {
private Point2DExt p1, p2;
public Line(Point2DExt p1, Point2DExt p2) {
this.p1 = p1;
this.p2 = p2;
}
public Line(float p1Start, float p1End, float p2Start, float
p2End) {
this.p1 = new Point2DExt(p1Start, p1End);
this.p2 = new Point2DExt(p2Start, p2End);
}
public Point2DExt getP1() {
return p1;
}
public void setP1(Point2DExt p1) {
this.p1 = p1;
}
public Point2DExt getP2() {
return p2;
}
public void setP2(Point2DExt p2) {
this.p2 = p2;
}
public float getLength() {
return (float) Math.sqrt((Math.pow(p2.x - p1.x, 2) +
Math.pow(p2.y - p1.y, 2)));
}
public Point2DExt getMiddlePoint() {
float xMiddle = (p1.x + p2.x) / 2;
float yMiddle = (p1.y + p2.y) / 2;
return new Point2DExt(xMiddle, yMiddle);
}
}
class Point2DExt {
protected float x, y;
public Point2DExt() {
public Point2DExt(float x, float y) {
this.x = x;
this.y = y;
}
public float getX() {
return x;
}
public void setX(float x) {
this.x = x;
}
public float getY() {
return y;
}
public void setY(float y) {
this.y = y;
}
public float[] getXY() {
return new float[]{x, y};
}
public void setXY(float x, float y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return String.format("(%f,%f)", x, y);
}
}
Task 6
public class Exercise6 {
public static void main(String[] args) {
Movable movablePoint = new MovablePoint(10, 10, 3, 3);
System.out.println(movablePoint);
movablePoint.moveRight();
movablePoint.moveUp();
System.out.println(movablePoint);
Movable movableCircle = new MovablePoint(20, 30, 4, 4);
System.out.println(movableCircle);
movableCircle.moveRight();
movableCircle.moveUp();
System.out.println(movableCircle);
}
}
interface Movable {
void moveUp();
void moveDown();
void moveLeft();
void moveRight();
}
class MovablePoint implements Movable {
private int x, y;
private int xSpeed, ySpeed;
public MovablePoint(int x, int y, int xSpeed, int ySpeed) {
this.x = x;
this.y = y;
this.xSpeed = xSpeed;
this.ySpeed = ySpeed;
}
@Override
public void moveUp() {
y += ySpeed;
}
@Override
public void moveDown() {
y -= ySpeed;
}
@Override
public void moveLeft() {
x -= xSpeed;
}
@Override
public void moveRight() {
x += xSpeed;
}
@Override
public String toString() {
return "MovablePoint{" +
"x=" + x +
", y=" + y +
", xSpeed=" + xSpeed +
", ySpeed=" + ySpeed +
'}';
}
}
class MovableCircle implements Movable {
private float radius;
private MovablePoint movablePoint;
public MovableCircle(int radius, int x, int y, int xSpeed, int
ySpeed) {
this.radius = radius;
this.movablePoint = new MovablePoint(x, y, xSpeed,
ySpeed);
}
@Override
public void moveUp() {
movablePoint.moveUp();
}
@Override
public void moveDown() {
movablePoint.moveDown();
}
@Override
public void moveLeft() {
movablePoint.moveLeft();
}
@Override
public void moveRight() {
movablePoint.moveRight();
}
@Override
public String toString() {
return "MovableCircle{" +
"radius=" + radius +
", movablePoint=" + movablePoint +
'}';
}
}
Task 7
public class Exercise7 {
public static void main(String[] args) {
CircleGeometricObject circleGeometricObject = new
CircleGeometricObject(14);
System.out.println(circleGeometricObject.getArea());
System.out.println(circleGeometricObject.getPerimeter());
System.out.println(circleGeometricObject);
Resizable resizable = new ResizableCircle(40);
resizable.resize(30);
System.out.println(resizable);
}
}
interface GeometricObject {
double getPerimeter();
double getArea();
}
interface Resizable {
void resize(int percent);
}
class CircleGeometricObject implements GeometricObject {
protected float radius;
public CircleGeometricObject(float radius) {
this.radius = radius;
}
@Override
public double getPerimeter() {
return 2 * Math.PI * radius;
}
@Override
public double getArea() {
return Math.PI * radius * radius;
}
@Override
public String toString() {
return "CircleGeometricObject{" +
"radius=" + radius +
'}';
}
}
class ResizableCircle extends CircleGeometricObject implements
Resizable {
public ResizableCircle(float radius) {
super(radius);
}
@Override
public void resize(int percent) {
radius = radius * percent / 100;
}
@Override
public String toString() {
return "ResizableCircle{" +
"radius=" + radius +
'}';
}
}
Exceptions - answers
Task 1
public class Exercise1 {
public static void main(String[] args) throws
CannotDivideBy0Exception {
MathUtils.divide(10, 0);
}
}
class CannotDivideBy0Exception extends Exception {
public CannotDivideBy0Exception() {
super("Can't divide by 0!");
}
}
class MathUtils {
public static float divide(int a, int b) throws
CannotDivideBy0Exception {
if (b == 0) {
throw new CannotDivideBy0Exception();
}
return a / b;
}
}
Task 2
public class Exercise2 {
public static void main(String[] args) throws
NoBookFoundException {
BookRepository bookRepository = new BookRepository();
bookRepository.add(new Book("Harry Potter Part 1", "J.K.
Rowling", "3323-434ds"));
bookRepository.add(new Book("Harry Potter Part 2", "J.K.
Rowling", "54dsd-dsds"));
List<Book> book = bookRepository.findByName("??");
Book book1 = bookRepository.findByIsbn("??");
bookRepository.delete("43");
}
}
class NoBookFoundException extends Exception {
public NoBookFoundException(String message) {
super(message);
}
}
class Book {
private String title;
private String author;
private String isbn;
public Book(String title, String author, String isbn) {
this.title = title;
this.author = author;
this.isbn = isbn;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getId() {
return isbn;
}
public void setId(String id) {
this.isbn = id;
}
@Override
public String toString() {
return "Book{" +
"title='" + title + '\'' +
", author='" + author + '\'' +
", isbn=" + isbn +
'}';
}
}
class BookRepository {
private List<Book> books = new ArrayList<>();
public void add(Book book) {
this.books.add(book);
}
public void delete(String isbn) throws NoBookFoundException {
for (Book book : books) {
if (book.getId().equals(isbn)) {
books.remove(book);
return;
}
}
throw new NoBookFoundException("Can't delete book with
isbn: " + isbn);
}
public Book findByIsbn(String isbn) throws
NoBookFoundException {
for (Book book : books) {
if (book.getId().equals(isbn)) {
return book;
}
}
throw new NoBookFoundException("Can't find book with isbn:
" + isbn);
}
public List<Book> findByName(String name) throws
NoBookFoundException {
List<Book> booksByName = new ArrayList<>();
for (Book book : books) {
if (book.getTitle().equals(name)) {
booksByName.add(book);
}
}
if (booksByName.isEmpty()) {
throw new NoBookFoundException("Can't find book with
name: " + name);
}
return booksByName;
}
}
Classes and interfaces - answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
UserValidator userValidator = new UserValidator();
String[] results = userValidator.validateEmails("pb@",
"@yahoo.com");
System.out.println(results[0]);
System.out.println(results[1]);
}
}
class UserValidator {
public String[] validateEmails(String email, String
alternativeEmail) {
class Email {
private String email;
public Email(String email) {
if (email == null || email.isEmpty() ||
!validate(email)) {
this.email = "unknown";
} else {
this.email = email;
}
}
}
Email email1 = new Email(email);
Email email2 = new Email(alternativeEmail);
return new String[]{email1.email, email2.email};
}
public static final Pattern VALID_EMAIL_ADDRESS_REGEX =
Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]
{2,6}$", Pattern.CASE_INSENSITIVE);
public static boolean validate(String emailStr) {
Matcher matcher =
VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
return matcher.find();
}
}
Task 2
public class Exercise2 {
public static void main(String[] args) {
Movie movie = new Movie.MovieCreator()
.setTitle("Star Wars")
.setDirector("J.J Abrams")
.setGenre("Action")
.setYearOfRelease(2015)
.setPublisher("Disney")
.createMovie();
System.out.println(movie);
}
}
class Movie {
private String title;
private String director;
private int yearOfRelease;
private String genre;
private String publisher;
public Movie(String title, String director, int yearOfRelease,
String genre, String publisher) {
this.title = title;
this.director = director;
this.yearOfRelease = yearOfRelease;
this.genre = genre;
this.publisher = publisher;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public int getYearOfRelease() {
return yearOfRelease;
}
public void setYearOfRelease(int yearOfRelease) {
this.yearOfRelease = yearOfRelease;
}
public String getGenre() {
return genre;
}
public void setGenre(String genre) {
this.genre = genre;
}
public String getPublisher() {
return publisher;
}
public void setPublisher(String publisher) {
this.publisher = publisher;
}
@Override
public String toString() {
return "Movie{" +
"title='" + title + '\'' +
", director='" + director + '\'' +
", yearOfRelease='" + yearOfRelease + '\'' +
", genre='" + genre + '\'' +
", publisher='" + publisher + '\'' +
'}';
}
static class MovieCreator {
private String title;
private String director;
private int yearOfRelease;
private String genre;
private String publisher;
public MovieCreator setTitle(String title) {
this.title = title;
return this;
}
public MovieCreator setDirector(String director) {
this.director = director;
return this;
}
public MovieCreator setYearOfRelease(int yearOfRelease) {
this.yearOfRelease = yearOfRelease;
return this;
}
public MovieCreator setGenre(String genre) {
this.genre = genre;
return this;
}
public MovieCreator setPublisher(String publisher) {
this.publisher = publisher;
return this;
}
public Movie createMovie() {
Movie movie = new Movie(title, director,
yearOfRelease, genre, publisher);
return movie;
}
}
}
Task 3
public class Exercise3 {
public static void main(String[] args) {
Car car = new Car("VW", "sport");
System.out.println(car);
}
}
class Car {
private String name;
private String type;
private Engine engine;
public Car(String name, String type) {
this.name = name;
this.type = type;
engine = new Car.Engine();
engine.setEngineType(type);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public Engine getEngine() {
return engine;
}
public void setEngine(Engine engine) {
this.engine = engine;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", type='" + type + '\'' +
", engine=" + engine +
'}';
}
class Engine {
private String engineType;
public void setEngineType(String carType) {
switch (carType) {
case "economy":
engineType = "diesel";
break;
case "luxury":
engineType = "electric";
break;
default:
engineType = "petrol";
}
}
@Override
public String toString() {
return "Engine{" +
"engineType='" + engineType + '\'' +
'}';
}
}
}
Task 4
public class Exercise4 {
public static void main(String[] args) {
User user = new User();
user.setName("John", new Validator<String>() {
@Override
public boolean validate(String input) {
return !input.isEmpty() &&
Character.isUpperCase(input.charAt(0));
}
});
user.setLastName("Smith", new Validator<String>() {
@Override
public boolean validate(String input) {
return input != null && !input.isEmpty() &&
Character.isUpperCase(input.charAt(0));
}
});
user.setAge(20, new Validator<Integer>() {
@Override
public boolean validate(Integer input) {
return input >= 0 && input <= 150;
}
});
user.setLogin("test", new Validator<String>() {
@Override
public boolean validate(String input) {
return input.length() == 10;
}
});
user.setPassword("test", new Validator<String>() {
@Override
public boolean validate(String input) {
return input.contains("!");
}
});
System.out.println(user);
}
}
interface Validator<T> {
boolean validate(T input);
}
class User {
private String name;
private String lastName;
private int age;
private String login;
private String password;
public String getName() {
return name;
}
public void setName(String name, Validator<String> validator)
{
if (validator.validate(name)) {
this.name = name;
}
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName, Validator<String>
validator) {
this.lastName = lastName;
}
public int getAge() {
return age;
}
public void setAge(int age, Validator<Integer> validator) {
if (validator.validate(age)) {
this.age = age;
}
}
public String getLogin() {
return login;
}
public void setLogin(String login, Validator<String>
validator) {
if (validator.validate(login)) {
this.login = login;
}
}
public String getPassword() {
return password;
}
public void setPassword(String password, Validator<String>
validator) {
if (validator.validate(password)) {
this.password = password;
}
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", lastName='" + lastName + '\'' +
", age=" + age +
", login='" + login + '\'' +
", password='" + password + '\'' +
'}';
}
}
Enumerated types - answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
System.out.println("Saturday is holiday: " +
Weekday.SATURDAY.isHoliday());
System.out.println("Firday is weekday: " +
Weekday.FRIDAY.isWeekDay());
Weekday.TUESDAY.whichIsGreater(Weekday.FRIDAY);
}
}
enum Weekday {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY,
SUNDAY;
boolean isWeekDay() {
return this != SATURDAY && this != SUNDAY;
}
boolean isHoliday() {
return this == SATURDAY || this == SUNDAY;
}
void whichIsGreater(Weekday weekday) {
if (this.ordinal() < weekday.ordinal()) {
System.out.println("Before " + weekday);
} else {
System.out.println("After " + weekday);
}
}
}
Task 2
public class Exercise2 {
public static void main(String[] args) {
PackageSize packageSize = PackageSize.getPackageSize(41,
60);
System.out.println(packageSize);
}
}
enum PackageSize {
SMALL(40, 90),
MEDIUM(90, 140),
LARGE(140, 250),
UNKNOWN(0, 0);
private int minSize;
private int maxSize;
PackageSize(int minSize, int maxSize) {
this.minSize = minSize;
this.maxSize = maxSize;
}
public static PackageSize getPackageSize(int minSize, int
maxSize) {
for (PackageSize packageSize : values()) {
if (minSize >= packageSize.minSize && maxSize <
packageSize.maxSize) {
return packageSize;
}
}
return UNKNOWN;
}
}
Task 3
public class Exercise3 {
public static void main(String[] args) {
float convertedTemp =
TemperatureConverter.convertTemperature('C', 'K', 34f);
System.out.println(convertedTemp);
}
}
interface Converter {
float convert(float tempIn);
}
enum TemperatureConverter {
C_F('C', 'F', new Converter() {
@Override
public float convert(float tempIn) {
return (tempIn * 9 / 5) + 32;
}
}),
C_K('C', 'K', new Converter() {
@Override
public float convert(float tempIn) {
return tempIn + 273.15f;
}
}),
K_C('K', 'C', new Converter() {
@Override
public float convert(float tempIn) {
return tempIn - 273.15f;
}
}),
F_C('F', 'C', new Converter() {
@Override
public float convert(float tempIn) {
return (tempIn - 32) * 5 / 9;
}
}),
F_K('F', 'K', new Converter() {
@Override
public float convert(float tempIn) {
return (tempIn - 32f) * 5 / 9 + 273.15f;
}
}),
K_F('K', 'F', new Converter() {
@Override
public float convert(float tempIn) {
return (tempIn + 273.15f) * 9 / 5 + 32;
}
});
private char input;
private char output;
private Converter converter;
TemperatureConverter(char input, char output, Converter
converter) {
this.input = input;
this.output = output;
this.converter = converter;
}
public static float convertTemperature(char input, char
output, float temp) {
for (TemperatureConverter temperatureConverter : values())
{
if (temperatureConverter.input == input &&
temperatureConverter.output == output) {
return
temperatureConverter.converter.convert(temp);
}
}
return Integer.MIN_VALUE;
}
}
Collections - answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
SDAArrayList<Integer> arrayList = new SDAArrayList<>();
arrayList.add(1);
arrayList.add(4);
arrayList.add(5);
arrayList.add(6);
arrayList.add(9);
arrayList.remove(0);
System.out.println(arrayList.get(0));
arrayList.display();
}
}
class SDAArrayList<E> {
private static final int INITIAL_CAPACITY = 5;
private Object[] elementArray;
private int size = 0;
public SDAArrayList() {
elementArray = new Object[INITIAL_CAPACITY];
}
public E get(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index out of
bound exception. Please provide valid index");
}
return (E) elementArray[index];
}
public void add(E e) {
if (size == elementArray.length) {
increaseArraySize();
}
elementArray[size++] = e;
}
public E remove(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index out of
bound exception. Please provide valid index");
}
Object removedElement = elementArray[index];
for (int i = index; i < size - 1; i++) {
elementArray[i] = elementArray[i + 1];
}
size--;
decreaseArraySize();
return (E) removedElement;
}
public void display() {
for (Object element : elementArray) {
System.out.println(element);
}
}
private void decreaseArraySize() {
elementArray = Arrays.copyOf(elementArray,
elementArray.length - 1);
}
private void increaseArraySize() {
int newIncreasedCapacity = elementArray.length * 2;
elementArray = Arrays.copyOf(elementArray,
newIncreasedCapacity);
}
}
Task 2
public class Exercise2 {
public static void main(String[] args) {
Author author1 = new Author("John", "Smith", 'M');
Author author2 = new Author("Jessica", "Albana", 'F');
Author author3 = new Author("Roger", "Moore", 'M');
Author author4 = new Author("Catherin", "Nadie", 'F');
Book book1 = new Book("Book 1", 34, 2000,
Arrays.asList(author1), Genre.FANTASY);
Book book2 = new Book("Book 1", 56, 1999,
Arrays.asList(author2, author3, author4), Genre.ACTION);
BookService bookService = new BookService();
bookService.add(book1);
bookService.add(book2);
System.out.println(bookService.findByAuthor(author2));
System.out.println(bookService.getAll());
System.out.println(bookService.findMostExpensiveBook());
System.out.println(bookService.sortByTitleAsc());
System.out.println(bookService.sortByTitleDsc());
}
}
class Author {
private String name;
private String lastName;
private char gender;
public Author(String name, String lastName, char gender) {
this.name = name;
this.lastName = lastName;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Author author = (Author) o;
return gender == author.gender &&
Objects.equals(name, author.name) &&
Objects.equals(lastName, author.lastName);
}
@Override
public int hashCode() {
return Objects.hash(name, lastName, gender);
}
@Override
public String toString() {
return "Author{" +
"name='" + name + '\'' +
", lastName='" + lastName + '\'' +
", gender=" + gender +
'}';
}
}
enum Genre {
ACTION, FANTASY, CRIME
}
class Book implements Comparable<Book> {
private String title;
private float price;
private int yearOfRelease;
private List<Author> authors;
private Genre genre;
public Book(String title, float price, int yearOfRelease,
List<Author> authors, Genre genre) {
this.title = title;
this.price = price;
this.yearOfRelease = yearOfRelease;
this.authors = authors;
this.genre = genre;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
public int getYearOfRelease() {
return yearOfRelease;
}
public void setYearOfRelease(int yearOfRelease) {
this.yearOfRelease = yearOfRelease;
}
public List<Author> getAuthors() {
return authors;
}
public void setAuthors(List<Author> authors) {
this.authors = authors;
}
public Genre getGenre() {
return genre;
}
public void setGenre(Genre genre) {
this.genre = genre;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Book book = (Book) o;
return Float.compare(book.price, price) == 0 &&
yearOfRelease == book.yearOfRelease &&
Objects.equals(title, book.title) &&
Objects.equals(authors, book.authors) &&
genre == book.genre;
}
@Override
public int hashCode() {
return Objects.hash(title, price, yearOfRelease, authors,
genre);
}
@Override
public int compareTo(Book o) {
return o.getTitle().compareTo(title);
}
@Override
public String toString() {
return "Book{" +
"title='" + title + '\'' +
", price=" + price +
", yearOfRelease=" + yearOfRelease +
", authors=" + authors +
", genre=" + genre +
'}';
}
}
class BookService {
private List<Book> books = new ArrayList<>();
public void add(Book book) {
books.add(book);
}
public void remove(Book book) {
books.remove(book);
}
public List<Book> getAll() {
return books;
}
public List<Book> findByGenre(Genre genre) {
List<Book> results = new ArrayList<>();
for (Book book : books) {
if (book.getGenre() == genre) {
results.add(book);
}
}
return results;
}
public List<Book> findByYear(int yearOfRelease) {
List<Book> results = new ArrayList<>();
for (Book book : books) {
if (book.getYearOfRelease() < yearOfRelease) {
results.add(book);
}
}
return results;
}
public Book findMostExpensiveBook() {
Book result = null;
for (Book book : books) {
if (result == null || result.getPrice() <
book.getPrice()) {
result = book;
}
}
return result;
}
public Book findCheapestBook() {
Book result = null;
for (Book book : books) {
if (result == null || result.getPrice() >
book.getPrice()) {
result = book;
}
}
return result;
}
public List<Book> findByNumberOfAuthors(int numberOfAuthors) {
List<Book> results = new ArrayList<>();
for (Book book : books) {
if (book.getAuthors().size() == numberOfAuthors) {
results.add(book);
}
}
return results;
}
public List<Book> sortByTitleAsc() {
Collections.sort(books);
return books;
}
public List<Book> sortByTitleDsc() {
Collections.reverse(books);
return books;
}
public boolean isBookInRepo(Book book) {
return books.contains(book);
}
public List<Book> findByAuthor(Author author) {
List<Book> results = new ArrayList<>();
for (Book book : books) {
if (book.getAuthors().contains(author)) {
results.add(book);
}
}
return results;
}
}
Task 3
public class Exercise3 {
public static void main(String[] args) {
Random random = new Random();
List<Integer> values = new ArrayList<>();
for (int i = 0; i < 100; i++) {
values.add(random.nextInt(50));
}
Set<Integer> uniqueValues = new HashSet<>();
Set<Integer> duplicatedValues = new HashSet<>();
for (Integer value : values) {
if (!uniqueValues.add(value)) {
duplicatedValues.add(value);
}
}
System.out.println("Unique: " + uniqueValues);
System.out.println("Duplicated: " + duplicatedValues);
}
}
Task 4
public class Exercise4 {
public static void main(String[] args) {
Author author1 = new Author("John", "Smith", 'M');
Author author2 = new Author("Jessica", "Albana", 'F');
Author author3 = new Author("Roger", "Moore", 'M');
Author author4 = new Author("Catherin", "Nadie", 'F');
Book book1 = new Book("Book 1", 34, 2000,
Arrays.asList(author1), Genre.FANTASY);
Book book2 = new Book("Book 1", 56, 1999,
Arrays.asList(author2, author3, author4), Genre.ACTION);
BookServiceExt bookService = new BookServiceExt();
bookService.add(book1);
bookService.add(book2);
System.out.println(bookService.mapBooks());
}
}
class BookServiceExt {
private List<Book> books = new ArrayList<>();
public void add(Book book) {
books.add(book);
}
public void remove(Book book) {
books.remove(book);
}
public List<Book> getAll() {
return books;
}
public Map<Genre, String> mapBooks() {
Map<Genre, String> booksMap = new HashMap<>();
for (Book book : books) {
booksMap.put(book.getGenre(), book.getTitle());
}
return booksMap;
}
}
Task 5
public class Exercise5 {
public static void main(String[] args) {
Author author1 = new Author("John", "Smith", 'M');
Author author2 = new Author("Jessica", "Albana", 'F');
Author author3 = new Author("Roger", "Moore", 'M');
Author author4 = new Author("Catherin", "Nadie", 'F');
Book book1 = new Book("Book 1", 34, 2000,
Arrays.asList(author1), Genre.FANTASY);
Book book2 = new Book("Book 1", 56, 1999,
Arrays.asList(author2, author3, author4), Genre.ACTION);
BookServiceExt2 bookService = new BookServiceExt2();
bookService.add(book1);
bookService.add(book2);
Stack<Book> bookStack = bookService.createBookStack();
while (!bookStack.isEmpty()) {
System.out.println(bookStack.pop());
}
}
class BookServiceExt2 {
private List<Book> books = new ArrayList<>();
public void add(Book book) {
books.add(book);
}
public void remove(Book book) {
books.remove(book);
}
public List<Book> getAll() {
return books;
}
public Stack<Book> createBookStack() {
Collections.sort(books, Comparator.comparingDouble(new
ToDoubleFunction<Book>() {
@Override
public double applyAsDouble(Book value) {
return value.getPrice();
}
}));
Stack<Book> bookStack = new Stack<>();
for (Book book : books) {
bookStack.push(book);
}
return bookStack;
}
}
Functional programming - answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
Video video = new Video("GOT1", "got1.com",
VideoType.CLIP);
Video video1 = new Video("GOT2", "got2.com",
VideoType.EPISODE);
Video video2 = new Video("GOT3", "got3.com",
VideoType.PREVIEW);
Video video3 = new Video("GOT4", "got4.com",
VideoType.PREVIEW);
Video video4 = new Video("GOT5", "got5.com",
VideoType.CLIP);
Video video5 = new Video("GOT6", "got6.com",
VideoType.EPISODE);
Episode episode = new Episode("got1", 1,
Arrays.asList(video, video1));
Episode episode1 = new Episode("got2", 2,
Arrays.asList(video2, video3));
Episode episode2 = new Episode("got3", 1,
Arrays.asList(video4, video5));
Season season = new Season("GOTS1", 1,
Arrays.asList(episode, episode1));
Season season1 = new Season("GOTS1", 2,
Arrays.asList(episode2));
List<Season> seasons = Arrays.asList(season, season1);
//list of episodes
List<Episode> episodes = seasons.stream()
.flatMap(s -> season.episodes.stream())
.collect(Collectors.toList());
//list of videos
List<Video> videos = seasons.stream()
.flatMap(s -> season.episodes.stream())
.flatMap(e -> e.videos.stream())
.collect(Collectors.toList());
//list of seasons names
List<String> seasonNames = seasons.stream()
.map(s -> s.seasonName)
.collect(Collectors.toList());
//list of seasons numbers
List<Integer> seasonNumbers = seasons.stream()
.map(s -> s.seasonNumber)
.collect(Collectors.toList());
//list of episodes names
List<String> episodeNames = seasons.stream()
.flatMap(s -> season.episodes.stream())
.map(e -> e.episodeName)
.collect(Collectors.toList());
//list of episodes numbers
List<Integer> episodeNumbers = seasons.stream()
.flatMap(s -> season.episodes.stream())
.map(e -> e.episodeNumber)
.collect(Collectors.toList());
//list of videos names
List<String> videoNames = seasons.stream()
.flatMap(s -> season.episodes.stream())
.flatMap(e -> e.videos.stream())
.map(v -> v.title)
.collect(Collectors.toList());
//list of videos urls
List<String> videoUrls = seasons.stream()
.flatMap(s -> season.episodes.stream())
.flatMap(e -> e.videos.stream())
.map(v -> v.url)
.collect(Collectors.toList());
//list of even episodes
List<Episode> evenEpisodes = seasons.stream()
.flatMap(s -> season.episodes.stream())
.filter(e -> e.episodeNumber % 2 == 0)
.collect(Collectors.toList());
//list of even seasons
List<Season> evenSeasons = seasons.stream()
.filter(s -> s.seasonNumber % 2 == 0)
.collect(Collectors.toList());
//list of even episodes and seasons
List<Episode> evenEpisodesFromEvenSeasons =
seasons.stream()
.filter(s -> s.seasonNumber % 2 == 0)
.flatMap(s -> season.episodes.stream())
.filter(e -> e.episodeNumber % 2 == 0)
.collect(Collectors.toList());
//list of clips videos from even episodes and odd seasons
List<Video> clipVideoFromEvenEpisodesFromOddSeasons =
seasons.stream()
.filter(s -> s.seasonNumber % 2 == 0)
.flatMap(s -> season.episodes.stream())
.filter(e -> e.episodeNumber % 2 != 0)
.flatMap(e -> e.videos.stream())
.filter(v -> v.videoType == VideoType.CLIP)
.collect(Collectors.toList());
//list of preview videos from odd episodes and even
seasons
List<Video> previewVideoFromOddEpisodesFromEvenSeasons =
seasons.stream()
.filter(s -> s.seasonNumber % 2 != 0)
.flatMap(s -> season.episodes.stream())
.filter(e -> e.episodeNumber % 2 == 0)
.flatMap(e -> e.videos.stream())
.filter(v -> v.videoType == VideoType.PREVIEW)
.collect(Collectors.toList());
}
}
enum VideoType {
CLIP, PREVIEW, EPISODE
}
class Video {
public String title;
public String url;
public VideoType videoType;
public Video(String title, String url, VideoType videoType) {
this.title = title;
this.url = url;
this.videoType = videoType;
}
@Override
public String toString() {
return "Video{" +
"title='" + title + '\'' +
", url='" + url + '\'' +
", videoType=" + videoType +
'}';
}
}
class Episode {
public String episodeName;
public int episodeNumber;
List<Video> videos;
public Episode(String episodeName, int episodeNumber,
List<Video> videos) {
this.episodeName = episodeName;
this.episodeNumber = episodeNumber;
this.videos = videos;
}
@Override
public String toString() {
return "Episode{" +
"episodeName='" + episodeName + '\'' +
", episodeNumber=" + episodeNumber +
", videos=" + videos +
'}';
}
}
class Season {
public String seasonName;
public int seasonNumber;
List<Episode> episodes;
public Season(String seasonName, int seasonNumber,
List<Episode> episodes) {
this.seasonName = seasonName;
this.seasonNumber = seasonNumber;
this.episodes = episodes;
}
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonNumber=" + seasonNumber +
", episodes=" + episodes +
'}';
}
}
Generic types - answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
Pair<Integer, String> pair = new Pair<>(23,
"JavaAdvanced");
System.out.println(pair);
}
}
class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
@Override
public String toString() {
return "Pair{" +
"key=" + key +
", value=" + value +
'}';
}
}
Task 2
public class Exercise2 {
public static void main(String[] args) {
Integer[] tab = {10, 21, 33, 40, 50, 60};
int counter = Utils.countIf(tab, new Validator<Integer>()
{
@Override
public boolean validate(Integer value) {
return value % 3 == 0;
}
});
System.out.println(counter);
}
}
interface Validator<T> {
boolean validate(T value);
}
class Utils {
public static <T> int countIf(T[] tab, Validator<T> validator)
{
int counter = 0;
for (T element : tab) {
if (validator.validate(element)) {
counter++;
}
}
return counter;
}
}
Task 3
public class Exercise3 {
public static void main(String[] args) {
Integer[] tab = {10, 21, 33, 40, 50, 60};
ArrayUtils.swap(tab, 2, 5);
System.out.println(Arrays.toString(tab));
}
}
class ArrayUtils {
public static <T> void swap(T[] array, int index1, int index2)
{
T tmp = array[index1];
array[index1] = array[index2];
array[index2] = tmp;
}
}
Task 4
public class Exercise4 {
public static void main(String[] args) {
Library<Book> bookLibrary = new Library<>(new Book[]{new
Book("Harry Potter", "Fantasy")});
System.out.println(Arrays.toString(bookLibrary.getElements()));
Library<Movie> movieLibrary = new Library<>(new Movie[]
{new Movie("Star Wars", "J.J Ambrams")});
System.out.println(Arrays.toString(movieLibrary.getElements()));
Library<Newspaper> newspaperLibrary = new Library<>(new
Newspaper[]{new Newspaper("NYC", "US")});
System.out.println(Arrays.toString(newspaperLibrary.getElements()));
}
}
abstract class MediaContent {
protected String title;
public MediaContent(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}
class Book extends MediaContent {
private String author;
public Book(String title, String author) {
super(title);
this.author = author;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
@Override
public String toString() {
return "Book{" +
"title='" + title + '\'' +
", author='" + author + '\'' +
'}';
}
}
class Newspaper extends MediaContent {
private String editor;
public Newspaper(String title, String editor) {
super(title);
this.editor = editor;
}
public String getEditor() {
return editor;
}
public void setEditor(String editor) {
this.editor = editor;
}
@Override
public String toString() {
return "Newspaper{" +
"title='" + title + '\'' +
", editor='" + editor + '\'' +
'}';
}
}
class Movie extends MediaContent {
private String director;
public Movie(String director, String title) {
super(title);
this.director = director;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
@Override
public String toString() {
return "Movie{" +
"title='" + title + '\'' +
", director='" + director + '\'' +
'}';
}
}
class Library<T extends MediaContent> {
private T[] elements;
public Library(T[] elements) {
this.elements = elements;
}
public T[] getElements() {
return elements;
}
public void setElements(T[] elements) {
this.elements = elements;
}
}
Task 5
public class Exercise5 {
public static void main(String[] args) {
Animal[] animal = {new Cat("Persian", 10), new Dog("German
Shepherd", "beef")};
AnimalHouse<Animal> animals = new AnimalHouse<>(animal);
System.out.println(Arrays.toString(animals.getAnimals()));
}
}
abstract class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Dog extends Animal {
private String favoriteFood;
public Dog(String name, String favoriteFood) {
super(name);
this.favoriteFood = favoriteFood;
}
public String getFavoriteFood() {
return favoriteFood;
}
public void setFavoriteFood(String favoriteFood) {
this.favoriteFood = favoriteFood;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", favoriteFood='" + favoriteFood + '\'' +
'}';
}
}
class Cat extends Animal {
private int numberOfLife;
public Cat(String name, int numberOfLife) {
super(name);
this.numberOfLife = numberOfLife;
}
public int getNumberOfLife() {
return numberOfLife;
}
public void setNumberOfLife(int numberOfLife) {
this.numberOfLife = numberOfLife;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
", numberOfLife=" + numberOfLife +
'}';
}
}
class AnimalHouse<T extends Animal> {
T[] animals;
public AnimalHouse(T[] animals) {
this.animals = animals;
}
public T[] getAnimals() {
return animals;
}
public void setAnimals(T[] animals) {
this.animals = animals;
}
}
Java IO - answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
//replace with sample directory path on Your OS
File file = new File("/Users/sdauser/Documents/sda");
String[] fileList = file.list();
for (String name : fileList) {
System.out.println(name);
}
}
}
Task 2
public class Exercise2 {
public static void main(String[] args) {
BufferedReader bufferedReader;
String strLine;
try {
bufferedReader = new BufferedReader(new
FileReader("/Users/sdauser/Documents/sda/code/test.txt"));
while ((strLine = bufferedReader.readLine()) != null)
{
System.out.println(strLine);
}
bufferedReader.close();
} catch (FileNotFoundException e) {
System.err.println("File not found");
} catch (IOException e) {
System.err.println("Unable to read the file.");
}
}
}
Task 3
public class Exercise3 {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder();
String strLine = "";
try {
String filename =
"/Users/sdauser/Documents/sda/code/test.txt";
FileWriter fw = new FileWriter(filename, true);
fw.write("Java I/O Exercises\n");
fw.close();
BufferedReader br = new BufferedReader(new
FileReader(filename));
while (strLine != null) {
stringBuilder.append(strLine);
stringBuilder.append(System.lineSeparator());
strLine = br.readLine();
System.out.println(strLine);
}
br.close();
} catch (IOException ioe) {
System.err.println("IOException: " +
ioe.getMessage());
}
}
}
Task 4
public class Exercise4 {
public static void main(String[] args) throws
FileNotFoundException {
String longestWord = new Exercise4().findLongestWords();
System.out.println(longestWord);
}
public String findLongestWords() throws FileNotFoundException
{
String longestWord = "";
String current;
Scanner scanner = new Scanner(new
File("/Users/sdauser/Documents/sda/code/test.txt"));
while (scanner.hasNext()) {
current = scanner.next();
if (current.length() > longestWord.length()) {
longestWord = current;
}
}
return longestWord;
}
}
Task 5
public class Exercise5 {
public static void main(String[] args) throws IOException {
UserParser userParser = new UserParser();
Path path =
Paths.get("/Users/sdauser/Documents/sda/code/test.txt");
List<User> users = new ArrayList<>();
List<String> lines = Files.readAllLines(path);
for (String line : lines) {
User user = userParser.fromCSV(line);
users.add(user);
}
System.out.println("Results " + users);
}
}
class UserParser {
public User fromCSV(String csvLine) {
String[] data = csvLine.split(",");
return new User(data[0], data[1],
Integer.parseInt(data[2]));
}
}
class User {
private String name;
private String lastName;
private int age;
public User(String name, String lastName, int age) {
this.name = name;
this.lastName = lastName;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", lastName='" + lastName + '\'' +
", age=" + age +
'}';
}
}
Task 6
public class Exercise6 {
public static void main(String[] args) throws IOException {
MovieFileRepository movieFileRepository = new
MovieFileRepository();
movieFileRepository.add(new Movie("Star Wars Force
Awaken", "Action", "J.J Ambrams", 2015));
movieFileRepository.add(new Movie("Star Wars Last Jedi",
"Action", "J.J Ambrams", 2017));
System.out.println("Results :" +
movieFileRepository.getAll());
}
}
class MovieFileRepository {
private final MovieParser movieParser = new MovieParser();
private final static Path PATH =
Paths.get("/Users/sdauser/Documents/sda/code/test.txt");
public void add(Movie movie) throws IOException {
Files.writeString(PATH, movieParser.toCSV(movie),
StandardOpenOption.APPEND);
}
public List<Movie> getAll() throws IOException {
List<String> movieLines = Files.readAllLines(PATH);
List<Movie> movies = new ArrayList<>();
for (String line : movieLines) {
Movie movie = movieParser.fromCSV(line);
movies.add(movie);
}
return movies;
}
}
class MovieParser {
private static final String SEPARATOR = ",";
public Movie fromCSV(String line) {
String[] data = line.split(SEPARATOR);
return new Movie(data[0], data[1], data[2],
Integer.parseInt(data[3]));
}
public String toCSV(Movie movie) {
return new StringBuilder().append(movie.getTitle())
.append(SEPARATOR)
.append(movie.getGenre())
.append(SEPARATOR)
.append(movie.getDirector())
.append(SEPARATOR)
.append(movie.getYearOfRelease())
.append("\n")
.toString();
}
}
class Movie {
private String title;
private String genre;
private String director;
private int yearOfRelease;
public Movie(String title, String genre, String director, int
yearOfRelease) {
this.title = title;
this.genre = genre;
this.director = director;
this.yearOfRelease = yearOfRelease;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getGenre() {
return genre;
}
public void setGenre(String genre) {
this.genre = genre;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public int getYearOfRelease() {
return yearOfRelease;
}
public void setYearOfRelease(int yearOfRelease) {
this.yearOfRelease = yearOfRelease;
}
@Override
public String toString() {
return "Movie{" +
"title='" + title + '\'' +
", genre='" + genre + '\'' +
", director='" + director + '\'' +
", yearOfRelease=" + yearOfRelease +
'}';
}
}
Parallel and concurrent programming -
answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1000; i < 2000; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 14300; i < 17800; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
});
thread1.start();
thread2.start();
}
Task 2
public class Exercise2 {
public static void main(String[] args) {
Bridge bridge = new Bridge();
Car car1 = new Car("VW", "Combi");
Car car2 = new Car("SEAT", "Suv");
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
bridge.driveThrough(car1);
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
bridge.driveThrough(car2);
}
});
thread1.start();
thread2.start();
}
}
class Car {
private String name;
private String type;
public Car(String name, String type) {
this.name = name;
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", type='" + type + '\'' +
'}';
}
}
class Bridge {
public synchronized void driveThrough(Car car) {
System.out.println("Driving through: " + car);
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Finished!: " + car);
}
}
Task 3
public class Exercise3 {
public static void main(String[] args) throws
InterruptedException, ExecutionException {
Random random = new Random();
int[] array1 = new int[10000];
int[] array2 = new int[10000];
for (int i = 0; i < 10000; i++) {
array1[i] = random.nextInt(20000);
array2[i] = array1[i];
}
ExecutorService executorService =
Executors.newFixedThreadPool(2);
String result = executorService.invokeAny(Arrays.asList(
new BubbleSortStrategy(array1),
new InsertionSortStrategy(array2)
));
System.out.println(result);
executorService.shutdown();
}
}
class BubbleSortStrategy implements Callable<String> {
private int[] array;
public BubbleSortStrategy(int[] array) {
this.array = array;
}
public void bubbleSort() {
boolean sorted = false;
int temp;
while (!sorted) {
sorted = true;
for (int i = 0; i < array.length - 1; i++) {
if (array[i] > array[i + 1]) {
temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
sorted = false;
}
}
}
}
@Override
public String call() throws Exception {
bubbleSort();
return "Bubble sort";
}
}
class InsertionSortStrategy implements Callable<String> {
private int[] array;
public InsertionSortStrategy(int[] array) {
this.array = array;
}
public void insertionSort() {
for (int i = 1; i < array.length; i++) {
int current = array[i];
int j = i - 1;
while (j >= 0 && current < array[j]) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = current;
}
}
@Override
public String call() throws Exception {
insertionSort();
return "Insertion sort";
}
}
Task 4
public class Exercise4 {
public static void main(String[] args) {
Account account = new Account(10000);
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
try {
account.pay(20000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.transfer(5000);
}
});
Thread thread3 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.transfer(6000);
}
});
thread1.start();
thread2.start();
thread3.start();
}
}
class Account {
private float saldo;
public Account(int saldo) {
this.saldo = saldo;
}
synchronized void transfer(float amount) {
saldo += amount;
notify();
System.out.println(String.format("Transfer %f, saldo: %f",
amount, saldo));
}
synchronized void pay(float amount) throws
InterruptedException {
while (amount > saldo) {
System.out.println("Not enough money! Waiting ... ");
wait();
}
saldo -= amount;
System.out.println(String.format("Pay %f, saldo: %f",
amount, saldo));
}
Task 5
public class Exercise5 {
public static void main(String[] args) {
Iterator<Integer> iterator = new Iterator<Integer>(new
Integer[]{1, 4, 50, 434, 78});
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
int value = iterator.next();
System.out.println(Thread.currentThread().getName() + " " +
value);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
int value = iterator.prev();
System.out.println(Thread.currentThread().getName() + " " +
value);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
thread1.start();
thread2.start();
}
}
class Iterator<T> {
private AtomicInteger atomicInteger = new AtomicInteger(0);
private T[] data;
public Iterator(T[] data) {
this.data = data;
}
public T next() {
if (atomicInteger.get() < data.length) {
return data[atomicInteger.getAndIncrement()];
}
throw new IllegalArgumentException("Out of range!");
}
public T prev() {
if (atomicInteger.get() > 0 && atomicInteger.get() <
data.length) {
return data[atomicInteger.getAndDecrement()];
}
throw new IllegalArgumentException("Out of range!");
}
}
Re ection API basics - answers
Task 1
public class Exercise1 {
public static void main(String[] args) {
Student student = new Student();
System.out.println("Methods: ");
Method[] methods =
student.getClass().getDeclaredMethods();
System.out.println(Arrays.toString(methods));
System.out.println("Fields: ");
Field[] fields = student.getClass().getDeclaredFields();
System.out.println(Arrays.toString(fields));
System.out.println("Constructors: ");
Constructor[] constructors =
student.getClass().getConstructors();
System.out.println(Arrays.asList(constructors));
}
}
class Student {
private String name;
private String lastName;
private int index;
private String typeOfStudies;
public Student() {
public Student(String name, String lastName, int index, String
typeOfStudies) {
this.name = name;
this.lastName = lastName;
this.index = index;
this.typeOfStudies = typeOfStudies;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public String getTypeOfStudies() {
return typeOfStudies;
}
public void setTypeOfStudies(String typeOfStudies) {
this.typeOfStudies = typeOfStudies;
}
}
Task 2
public class Exercise2 {
public static void main(String[] args) throws
ClassNotFoundException, NoSuchMethodException,
IllegalAccessException, InvocationTargetException,
InstantiationException, NoSuchFieldException {
StudentExt studentExt = (StudentExt)
Class.forName("reflection_api.StudentExt")
.getConstructor(String.class, String.class,
Integer.class, String.class)
.newInstance("John", "Smith", 10, "It");
System.out.println(studentExt);
Field nameField =
studentExt.getClass().getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(studentExt, "Johnson");
Field lastNameField =
studentExt.getClass().getDeclaredField("lastName");
lastNameField.setAccessible(true);
lastNameField.set(studentExt, "Spring");
String name = (String)
studentExt.getClass().getMethod("getName").invoke(studentExt);
System.out.println(name);
String lastName = (String)
studentExt.getClass().getMethod("getLastName").invoke(studentExt);
System.out.println(lastName);
String typeOfStudies = (String)
studentExt.getClass().getMethod("getTypeOfStudies").invoke(studentExt
System.out.println(typeOfStudies);
int index = (Integer)
studentExt.getClass().getMethod("getIndex").invoke(studentExt);
System.out.println(index);
}
}
class StudentExt {
private String name;
private String lastName;
private int index;
private String typeOfStudies;
public StudentExt() {
public StudentExt(String name, String lastName, Integer index,
String typeOfStudies) {
this.name = name;
this.lastName = lastName;
this.index = index;
this.typeOfStudies = typeOfStudies;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public String getTypeOfStudies() {
return typeOfStudies;
}
public void setTypeOfStudies(String typeOfStudies) {
this.typeOfStudies = typeOfStudies;
}
@Override
public String toString() {
return "StudentExt{" +
"name='" + name + '\'' +
", lastName='" + lastName + '\'' +
", index=" + index +
", typeOfStudies='" + typeOfStudies + '\'' +
'}';
}
}