All posts by admin

openCV – Android app

April 7, 2019 admin

This a post from a guy that have just used openCV libraries directly on Android. Brilliant! Thank you for your post, Elvis Chidera

For those who doesn’t know what openCV is or what is it for, openCV is the most popular opensource library that allows you to manipulate images, like identifying objects and so on.

If you need that on your android app, take a look on this post.

Curiosity, Development, tutorial, web, web development

Java 8 – Some of the new features

March 23, 2018 admin Leave a comment

In this post, some of the new features of JAVA 8…

package pt.joaobrito.java8;

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.Month;
import java.time.Period;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

public class Main {

    public static void main(String[] args) throws InterruptedException {
        // simple lambda example
        print("Hello Lambda", s -> s.length());

        // another lambda example
        new Thread(() -> System.out.println("Hello Runnable")).start();

        List<Person> people = new ArrayList<>(Arrays.asList(
            new Person("John Doe", LocalDate.of(1978, Month.JUNE, 14)),
            new Person("Jane Doe", LocalDate.of(1983, Month.FEBRUARY, 16)),
            new Person("Steven Smith", LocalDate.of(2008, Month.SEPTEMBER, 23)),
            new Person("Martin", LocalDate.of(2010, Month.NOVEMBER, 27)),
            new Person("Mike", LocalDate.of(2012, Month.NOVEMBER, 3)),
            new Person("Louis", LocalDate.of(2014, Month.NOVEMBER, 6)),
            new Person("Mary", LocalDate.of(2016, Month.FEBRUARY, 16))
        ));

        System.out.println("---- All people sorted by name -----");
        people.sort((p1, p2) -> p1.getName().compareTo(p2.getName()));
        people.forEach(p -> System.out.println(p.getName()));

        System.out.println("---- All people -----");
        people = new ArrayList<>(Arrays.asList(
            new Person("John Doe", LocalDate.of(1978, Month.JUNE, 14)),
            new Person("Jane Doe", LocalDate.of(1983, Month.FEBRUARY, 16)),
            new Person("Steven Smith", LocalDate.of(2008, Month.SEPTEMBER, 23)),
            new Person("Martin", LocalDate.of(2010, Month.NOVEMBER, 27)),
            new Person("Mike", LocalDate.of(2012, Month.NOVEMBER, 3)),
            new Person("Louis", LocalDate.of(2014, Month.NOVEMBER, 6)),
            new Person("Mary", LocalDate.of(2016, Month.FEBRUARY, 16))
        ));
        people.stream().map(Person::getName).forEach(System.out::println); // using method reference

        System.out.println("---- People older than 9 yrs -----");
        people
            .stream() // convert to stream
            .filter(p -> Period.between(p.getDob(), LocalDate.now()).getYears() > 9) // get only the people thaht matches the given condition
            .map(Person::getName) // get a new stream with only the names => returns Stream<String>
            .forEach(System.out::println); // iterates the entire stream and prints out each element

        System.out.println("---- Remove items from list -----");
        people.removeIf(i -> i.getAge() < 2); // remove if the given condition is true
        people.
            stream()
            .map(Person::getName)
            .sorted(Comparator.reverseOrder()) // order the list in reverse order
            .forEach(System.out::println);

        // calculate time between two dates
        LocalDate dob = LocalDate.of(1978, 6, 14);
        LocalDate now = LocalDate.now();
        Period p = Period.between(dob, now);
        System.out.println("Priod of " + p.getYears() + " years; " + p.getMonths() + " months, " + p.getDays() + " days.");

        // calculate time between two instants
        Instant start = Instant.now();
        Thread.sleep(1000);
        Instant end = Instant.now();
        System.out.println("The time is... " + Duration.between(start, end).toMillis());

        // Optional<T>
        Optional<String> opt = Optional.ofNullable("some string"); // not null value
        System.out.println(opt.orElse("or else"));
        opt.orElseThrow(UnsupportedOperationException::new);

        opt = Optional.ofNullable(null); // notice that here we pass a null value
        System.out.println(opt.orElse("or else"));
        opt.orElseThrow(UnsupportedOperationException::new);

    }

    public static void print(String s, MyLambda l) {
        System.out.println(l.getLength(s));
    }

}

@FunctionalInterface
interface MyLambda {
    int getLength(String s);
}

package pt.joaobrito.java8;

import java.time.Duration;

import java.time.Instant;

import java.time.LocalDate;

import java.time.Month;

import java.time.Period;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.List;

import java.util.Optional;

public class Main {

public static void main(String[] args) throws InterruptedException {

// simple lambda example

print("Hello Lambda", s -> s.length());

// another lambda example

new Thread(() -> System.out.println("Hello Runnable")).start();

List<Person> people = new ArrayList<>(Arrays.asList(

new Person("John Doe", LocalDate.of(1978, Month.JUNE, 14)),

new Person("Jane Doe", LocalDate.of(1983, Month.FEBRUARY, 16)),

new Person("Steven Smith", LocalDate.of(2008, Month.SEPTEMBER, 23)),

new Person("Martin", LocalDate.of(2010, Month.NOVEMBER, 27)),

new Person("Mike", LocalDate.of(2012, Month.NOVEMBER, 3)),

new Person("Louis", LocalDate.of(2014, Month.NOVEMBER, 6)),

new Person("Mary", LocalDate.of(2016, Month.FEBRUARY, 16))

));

System.out.println("---- All people sorted by name -----");

people.sort((p1, p2) -> p1.getName().compareTo(p2.getName()));

people.forEach(p -> System.out.println(p.getName()));

System.out.println("---- All people -----");

people = new ArrayList<>(Arrays.asList(

new Person("John Doe", LocalDate.of(1978, Month.JUNE, 14)),

new Person("Jane Doe", LocalDate.of(1983, Month.FEBRUARY, 16)),

new Person("Steven Smith", LocalDate.of(2008, Month.SEPTEMBER, 23)),

new Person("Martin", LocalDate.of(2010, Month.NOVEMBER, 27)),

new Person("Mike", LocalDate.of(2012, Month.NOVEMBER, 3)),

new Person("Louis", LocalDate.of(2014, Month.NOVEMBER, 6)),

new Person("Mary", LocalDate.of(2016, Month.FEBRUARY, 16))

));

people.stream().map(Person::getName).forEach(System.out::println); // using method reference

System.out.println("---- People older than 9 yrs -----");

people

.stream() // convert to stream

.filter(p -> Period.between(p.getDob(), LocalDate.now()).getYears() > 9) // get only the people thaht matches the given condition

.map(Person::getName) // get a new stream with only the names => returns Stream<String>

.forEach(System.out::println); // iterates the entire stream and prints out each element

System.out.println("---- Remove items from list -----");

people.removeIf(i -> i.getAge() < 2); // remove if the given condition is true

people.

stream()

.map(Person::getName)

.sorted(Comparator.reverseOrder()) // order the list in reverse order

.forEach(System.out::println);

// calculate time between two dates

LocalDate dob = LocalDate.of(1978, 6, 14);

LocalDate now = LocalDate.now();

Period p = Period.between(dob, now);

System.out.println("Priod of " + p.getYears() + " years; " + p.getMonths() + " months, " + p.getDays() + " days.");

// calculate time between two instants

Instant start = Instant.now();

Thread.sleep(1000);

Instant end = Instant.now();

System.out.println("The time is... " + Duration.between(start, end).toMillis());

// Optional<T>

Optional<String> opt = Optional.ofNullable("some string"); // not null value

System.out.println(opt.orElse("or else"));

opt.orElseThrow(UnsupportedOperationException::new);

opt = Optional.ofNullable(null); // notice that here we pass a null value

System.out.println(opt.orElse("or else"));

opt.orElseThrow(UnsupportedOperationException::new);

}

public static void print(String s, MyLambda l) {

System.out.println(l.getLength(s));

}

@FunctionalInterface

interface MyLambda {

int getLength(String s);

}

package pt.joaobrito.java8;

import java.time.LocalDate;
import java.time.Period;

public class Person {
    private String name;
    private LocalDate dob;

    public Person(String name, LocalDate dob) {
        this.name = name;
        this.dob = dob;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public LocalDate getDob() {
        return dob;
    }

    public void setDob(LocalDate dob) {
        this.dob = dob;
    }
    
    public int getAge(){
        return Period.between(dob, LocalDate.now()).getYears();
    }
}

package pt.joaobrito.java8;

import java.time.LocalDate;

import java.time.Period;

public class Person {

private String name;

private LocalDate dob;

public Person(String name, LocalDate dob) {

this.name = name;

this.dob = dob;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public LocalDate getDob() {

return dob;

}

public void setDob(LocalDate dob) {

this.dob = dob;

}

public int getAge(){

return Period.between(dob, LocalDate.now()).getYears();

}

…and here are the results from running the file above

------------------------------------------------------------------------
Building Java8 0.0.1-SNAPSHOT
------------------------------------------------------------------------

--- exec-maven-plugin:1.2.1:exec (default-cli) @ Java8 ---
12
Hello Runnable
---- All people sorted by name -----
Jane Doe
John Doe
Louis
Martin
Mary
Mike
Steven Smith
---- All people -----
John Doe
Jane Doe
Steven Smith
Martin
Mike
Louis
Mary
---- People older than 9 yrs -----
John Doe
Jane Doe
---- Remove items from list -----
Steven Smith
Mike
Mary
Martin
Louis
John Doe
Jane Doe
Priod of 39 years; 9 months, 9 days.
The time is... 1014
some string
or else
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Optional.orElseThrow(Optional.java:290)
	at pt.joaobrito.java8.Main.main(Main.java:83)
------------------------------------------------------------------------
BUILD FAILURE
------------------------------------------------------------------------
Total time: 1.649 s
Finished at: 2018-03-23T00:07:33+00:00
Final Memory: 8M/309M
------------------------------------------------------------------------

------------------------------------------------------------------------

Building Java8 0.0.1-SNAPSHOT

------------------------------------------------------------------------

--- exec-maven-plugin:1.2.1:exec (default-cli) @ Java8 ---

Hello Runnable

---- All people sorted by name -----

Jane Doe

John Doe

Louis

Martin

Mary

Mike

Steven Smith

---- All people -----

John Doe

Jane Doe

Steven Smith

Martin

Mike

Louis

Mary

---- People older than 9 yrs -----

John Doe

Jane Doe

---- Remove items from list -----

Steven Smith

Mike

Mary

Martin

Louis

John Doe

Jane Doe

Priod of 39 years; 9 months, 9 days.

The time is... 1014

some string

or else

Exception in thread "main" java.lang.UnsupportedOperationException

at java.util.Optional.orElseThrow(Optional.java:290)

at pt.joaobrito.java8.Main.main(Main.java:83)

------------------------------------------------------------------------

BUILD FAILURE

------------------------------------------------------------------------

Total time: 1.649 s

Finished at: 2018-03-23T00:07:33+00:00

Final Memory: 8M/309M

------------------------------------------------------------------------

Note that the build fails because we pass null to the Optional and we have a condition to throw an exception if null is passed to it (this is the reason why this line is the last statement of this example).

Thank you! 🙂

Development, tutorial, web

Design Pattern: Command and State together

March 17, 2018 admin Leave a comment

In this article we will explain two JAVA design patterns:
Command and State.

In the main method we:

first create the light object (aka receiver);
then we check if the light is on or off;
after that we create a light command passing to it the light we’ve just created;
then we create a Remote Control and set the command into it;
in the next step we press the button and we check the light state;
finally, we repeat the process and check the light state again.

So lets start with the code:

Here we have the client class (the one that have the main method)

package pt.joaobrito.client;

import pt.joaobrito.command.Command;
import pt.joaobrito.command.LightCommand;
import pt.joaobrito.command.invoker.RemoteControl;
import pt.joaobrito.state.receiver.Light;

/**
 * The client object 
 */
public class Client {

    public static void main(String[] args) {
        // receiver
        Light light = new Light();
        
        // prints to the console the current state of the light
        System.out.println("1st state - the light is " + (light.getCurrentState().isOn() ? "ON" : "OFF"));
        
        Command lightsCmd = new LightCommand(light);
        
        //invoker
        RemoteControl remoteControl = new RemoteControl();
        remoteControl.setCommand(lightsCmd);
        
        //switch on
        remoteControl.pressButton();
        System.out.println("2nd state - the light is " + (light.getCurrentState().isOn() ? "ON" : "OFF"));
        
        //switch off
        remoteControl.pressButton();
        System.out.println("3rd state - the light is " + (light.getCurrentState().isOn() ? "ON" : "OFF"));
    }
}

package pt.joaobrito.client;

import pt.joaobrito.command.Command;

import pt.joaobrito.command.LightCommand;

import pt.joaobrito.command.invoker.RemoteControl;

import pt.joaobrito.state.receiver.Light;

/**

* The client object

public class Client {

public static void main(String[] args) {

// receiver

Light light = new Light();

// prints to the console the current state of the light

System.out.println("1st state - the light is " + (light.getCurrentState().isOn() ? "ON" : "OFF"));

Command lightsCmd = new LightCommand(light);

//invoker

RemoteControl remoteControl = new RemoteControl();

remoteControl.setCommand(lightsCmd);

//switch on

remoteControl.pressButton();

System.out.println("2nd state - the light is " + (light.getCurrentState().isOn() ? "ON" : "OFF"));

//switch off

remoteControl.pressButton();

System.out.println("3rd state - the light is " + (light.getCurrentState().isOn() ? "ON" : "OFF"));

}

The Command Design Pattern implementation
Here we define our Command interface

package pt.joaobrito.command;

public interface Command {
    public void execute();
}

package pt.joaobrito.command;

public interface Command {

public void execute();

}

This is the remote control class.
Note that in the pressButton method we actually execute the Command passed previously in the set method. Notice that this class has no knowledge at all about the receiver. Instead it just knows that it has a Command and how to interact with it.

package pt.joaobrito.command.invoker;

import pt.joaobrito.command.Command;

/**
 * Invoker
 */
public class RemoteControl {

    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }
}

package pt.joaobrito.command.invoker;

import pt.joaobrito.command.Command;

/**

* Invoker

public class RemoteControl {

private Command command;

public void setCommand(Command command) {

this.command = command;

}

public void pressButton() {

command.execute();

}

Here we have the concrete light command (the implementation of the Command interface). In the execute method we specify what the command really does: in this case with the help of the State Design Pattern we are simply saying to the light to go to the next state.

package pt.joaobrito.command;

import pt.joaobrito.state.receiver.Light;

/**
 * Concrete Command: light command
 */
public class LightCommand implements Command {
    //reference to the light
    private Light light;

    public LightCommand(Light light) {
        this.light = light;
    }

    public void execute() {
        light.switchToNextState();
    }
}

package pt.joaobrito.command;

import pt.joaobrito.state.receiver.Light;

/**

* Concrete Command: light command

public class LightCommand implements Command {

//reference to the light

private Light light;

public LightCommand(Light light) {

this.light = light;

}

public void execute() {

light.switchToNextState();

}

The next section is the State Design Pattern part
This is the Light class. From the Command point of view this is the receiver and from the point of view of the state design pattern this is the object that keeps the current state of the light (also known as a wrapper that will be passed to the concrete states).

package pt.joaobrito.state.receiver;

/**
 * This class is responsible to keep the state of the light
 */
public class Light {
    private State currentState;
    
    public Light() {
        // 1st state of light
        currentState = new LightOff();
    }

    public State getCurrentState() {
        return currentState;
    }

    public void setState(State state) {
        currentState = state;
    }

    /**
     * light switch
     */
    public void switchToNextState() {
        currentState.next(this);
    }

}

package pt.joaobrito.state.receiver;

/**

* This class is responsible to keep the state of the light

public class Light {

private State currentState;

public Light() {

// 1st state of light

currentState = new LightOff();

}

public State getCurrentState() {

return currentState;

}

public void setState(State state) {

currentState = state;

}

/**

* light switch

public void switchToNextState() {

currentState.next(this);

}

This is the state interface. Notice that here we have two methods that have to be implemented by the classes that implement the state interface.

package pt.joaobrito.state.receiver;

public interface State {
    void next(Light wrapper);
    boolean isOn();
}

package pt.joaobrito.state.receiver;

public interface State {

void next(Light wrapper);

boolean isOn();

}

The next class represents one of the possible state of the light (the concrete state that represents the ON state of the light)

package pt.joaobrito.state.receiver;

/**
 * Receiver
 */
public class LightOn implements State{
    
    @Override
    public void next(Light wrapper) {
        wrapper.setState(new LightOff());
    }

    @Override
    public boolean isOn() {
        return true;
    }
}

package pt.joaobrito.state.receiver;

/**

* Receiver

public class LightOn implements State{

@Override

public void next(Light wrapper) {

wrapper.setState(new LightOff());

}

@Override

public boolean isOn() {

return true;

}

This is the other possible state (the concrete state that represents the OFF state of the light)

package pt.joaobrito.state.receiver;

/**
 * Receiver
 */
public class LightOff implements State{

    @Override
    public void next(Light wrapper) {
        wrapper.setState(new LightOn());
    }

    @Override
    public boolean isOn() {
        return false;
    }
}

package pt.joaobrito.state.receiver;

/**

* Receiver

public class LightOff implements State{

@Override

public void next(Light wrapper) {

wrapper.setState(new LightOn());

}

@Override

public boolean isOn() {

return false;

}

And the results:

run:
1st state - the light is OFF
2nd state - the light is ON
3rd state - the light is OFF
BUILD SUCCESSFUL (total time: 0 seconds)

run:

1st state - the light is OFF

2nd state - the light is ON

3rd state - the light is OFF

BUILD SUCCESSFUL (total time: 0 seconds)

And that’s it. Feel free to comment.

Thank you!

Development, tutorial, web development

Working with nested Maps in JAVA

May 20, 2016 admin Leave a comment

In this post I will show you a simple and easy way of working with JAVA Maps, more precisely, how to add an element (a.k.a value) to a multi nested maps:

public void addElementToMap(Map<Long, Map<String, Map<Short, List<SomeDto>>>> map, SomeDto dto) {
	
	// get the first inner map
	Map<String, Map<Short, List<SomeDto>>> someMap = map.get(dto.gePrimaryKey());
	
	if(someMap == null){
		someMap = new HashMap<>();
		map.put(dto.gePrimaryKey(), someMap);
	}
	
	
	// get the second inner map
	Map<Short, List<SomeDto>> otherMap = someMap.get(dto.getSomeId());
	
	if(otherMap == null){
		otherMap = new HashMap<>();
		someMap.put(dto.getSomeId(), otherMap);
	}
	
	
	// get the inner list
	List<SomeDto> someList = otherMap.get(dto.getOtherId());
	
	if(someList == null){
		someList = new ArrayList<>();
		otherMap.put(dto.getOtherId()), someList);
	}
	
	// add dto to the list
	someList.add(dto);
}

public void addElementToMap(Map<Long, Map<String, Map<Short, List<SomeDto>>>> map, SomeDto dto) {

// get the first inner map

Map<String, Map<Short, List<SomeDto>>> someMap = map.get(dto.gePrimaryKey());

if(someMap == null){

someMap = new HashMap<>();

map.put(dto.gePrimaryKey(), someMap);

}

// get the second inner map

Map<Short, List<SomeDto>> otherMap = someMap.get(dto.getSomeId());

if(otherMap == null){

otherMap = new HashMap<>();

someMap.put(dto.getSomeId(), otherMap);

}

// get the inner list

List<SomeDto> someList = otherMap.get(dto.getOtherId());

if(someList == null){

someList = new ArrayList<>();

otherMap.put(dto.getOtherId()), someList);

}

// add dto to the list

someList.add(dto);

}

That’s it. Simple, isn’t it? 😉

Source code: github

Curiosity, Development, tutorial, web development

Git Workflow

February 9, 2016 admin Leave a comment

Here is just an example (and suggestion) of git workflow best practices.

git-workflow

You can learn more about git here at Atlassian git tutorial website.

Development, sql

SQL JOINS

September 14, 2015 admin Leave a comment

Development, tutorial

Builder Design Pattern

August 28, 2015 admin Leave a comment

Here is the “usual” implementation of this design pattern.

package pt.joaobrito.builder;

/**
 * This is the main class
 */
public class BuilderExample {

	public static void main(String[] args) {
		Vehicle v1 = new Client(new CarBuilder()).constructVehicle();
		System.out.println(v1);

		Vehicle v2 = new Client(new BikeBuilder()).constructVehicle();
		System.out.println(v2);

		Vehicle v3 = new Client(new CarBuilder()).constructVehicleWithoutWindowsOrSeats();
		System.out.println(v3);

		Vehicle v4 = new Client(new BikeBuilder()).constructVehicleWithoutWindowsOrSeats();
		System.out.println(v4);
	}
}
/**
 * The Client class has the responsability of building the vehicles
 */
class Client {

	private final VehicleBuilder vehicleBuilder;

	public Client(VehicleBuilder vehicleBuilder) {
		this.vehicleBuilder = vehicleBuilder;
	}

	/**
	 * Builds a complete vehicle
	 * @return a vehicle
	 */
	public Vehicle constructVehicle() {
		return vehicleBuilder.buildType().buildSeats().buildWindows().get();
	}

	/**
	 * Builds a vehicle without parts
	 * @return a vehicle
	 */
	public Vehicle constructVehicleWithoutWindowsOrSeats() {
		return vehicleBuilder.buildType().get();
	}
}

/**
 * This class is the abstract builder
 */
abstract class VehicleBuilder {

	protected Vehicle vehicle;

	public VehicleBuilder() {
		this.vehicle = new Vehicle();
	}

	/**
	 * Vehicle get method
	 * @return the vehicle
	 */
	public Vehicle get() {
		return vehicle;
	}

	/**
	 * The 3 following lines are the methods that must be implemented on the concrete builders
	 * @return
	 */
	public abstract VehicleBuilder buildType();
	public abstract VehicleBuilder buildSeats();
	public abstract VehicleBuilder buildWindows();
}

/**
 * This is a concrete builder for Bikes
 */
class BikeBuilder extends VehicleBuilder {

	@Override
	public VehicleBuilder buildType() {
		vehicle.setType("Bike");
		return this;
	}

	@Override
	public VehicleBuilder buildWindows() {
		vehicle.setWindows(0);
		return this;
	}

	@Override
	public VehicleBuilder buildSeats() {
		vehicle.setSeats(2);
		return this;
	}

}

/**
 * This is the concrete builder for Cars
 */
class CarBuilder extends VehicleBuilder {

	@Override
	public VehicleBuilder buildType() {
		vehicle.setType("Car");
		return this;
	}

	@Override
	public VehicleBuilder buildSeats() {
		vehicle.setSeats(5);
		return this;
	}

	@Override
	public VehicleBuilder buildWindows() {
		vehicle.setWindows(4);
		return this;
	}


}

/**
 * This is the vehicle class
 */
class Vehicle {

	private String type;
	private int seats;
	private int windows;

	public void setType(String type) {
		this.type = type;
	}

	public void setSeats(int seats) {
		this.seats = seats;
	}

	public void setWindows(int windows) {
		this.windows = windows;
	}
	
	/**
	 * @return a printable vehicle
	 */
	@Override
	public String toString() {
		return "Vehicle[Type: " + type + "; Seats: " + seats + "; Windows: " + windows + "]";
	}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

package pt.joaobrito.builder;

/**

* This is the main class

public class BuilderExample {

public static void main(String[] args) {

Vehicle v1 = new Client(new CarBuilder()).constructVehicle();

System.out.println(v1);

Vehicle v2 = new Client(new BikeBuilder()).constructVehicle();

System.out.println(v2);

Vehicle v3 = new Client(new CarBuilder()).constructVehicleWithoutWindowsOrSeats();

System.out.println(v3);

Vehicle v4 = new Client(new BikeBuilder()).constructVehicleWithoutWindowsOrSeats();

System.out.println(v4);

}

/**

* The Client class has the responsability of building the vehicles

class Client {

private final VehicleBuilder vehicleBuilder;

public Client(VehicleBuilder vehicleBuilder) {

this.vehicleBuilder = vehicleBuilder;

}

/**

* Builds a complete vehicle

* @return a vehicle

public Vehicle constructVehicle() {

return vehicleBuilder.buildType().buildSeats().buildWindows().get();

}

/**

* Builds a vehicle without parts

* @return a vehicle

public Vehicle constructVehicleWithoutWindowsOrSeats() {

return vehicleBuilder.buildType().get();

}

/**

* This class is the abstract builder

abstract class VehicleBuilder {

protected Vehicle vehicle;

public VehicleBuilder() {

this.vehicle = new Vehicle();

}

/**

* Vehicle get method

* @return the vehicle

public Vehicle get() {

return vehicle;

}

/**

* The 3 following lines are the methods that must be implemented on the concrete builders

* @return

public abstract VehicleBuilder buildType();

public abstract VehicleBuilder buildSeats();

public abstract VehicleBuilder buildWindows();

}

/**

* This is a concrete builder for Bikes

class BikeBuilder extends VehicleBuilder {

@Override

public VehicleBuilder buildType() {

vehicle.setType("Bike");

return this;

}

@Override

public VehicleBuilder buildWindows() {

vehicle.setWindows(0);

return this;

}

@Override

public VehicleBuilder buildSeats() {

vehicle.setSeats(2);

return this;

}

/**

* This is the concrete builder for Cars

class CarBuilder extends VehicleBuilder {

@Override

public VehicleBuilder buildType() {

vehicle.setType("Car");

return this;

}

@Override

public VehicleBuilder buildSeats() {

vehicle.setSeats(5);

return this;

}

@Override

public VehicleBuilder buildWindows() {

vehicle.setWindows(4);

return this;

}

/**

* This is the vehicle class

class Vehicle {

private String type;

private int seats;

private int windows;

public void setType(String type) {

this.type = type;

}

public void setSeats(int seats) {

this.seats = seats;

}

public void setWindows(int windows) {

this.windows = windows;

}

/**

* @return a printable vehicle

@Override

public String toString() {

return "Vehicle[Type: " + type + "; Seats: " + seats + "; Windows: " + windows + "]";

}

The result is:

UML

Development, tutorial

Builder Design Pattern (simple way)

August 25, 2015 admin Leave a comment

This design pattern allows us to create an object with the advantage that the same construction process can create different representations of that object. Here is the simplest implementation of this design pattern.

In a next tutorial we will explain the other way of doing the same thing, with more flexibility but with a more complex implementation.

So, let’s start creating a car!

package pt.joaobrito.builder;

/**
 * This is the class that we will create object of
 */
class Car {

	private String brand, model, version;

	/**
	 * This private constructor avoids the user to create the object in the complex way
	 * using the new keyword.
	 */
	private Car() {}

	/**
	 * This method allows us to get the builder of the car without instantiating the car
	 * 
	 * @return the builder instance
	 */
	public static Builder getBuilder() { return new Builder(); }

	public String getBrand() { return this.brand; }

	public String getModel() { return this.model; }

	public String getVersion() { return this.version; }

	/**
	 * This is the printable version of the car
	 * @return a printable car
	 */
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder("Your new car -> ");
		if (brand != null) { sb.append("brand: " + brand); }
		if (model != null) { sb.append(", model: " + model); }
		if (version != null) { sb.append(", version: " + version); }
		return sb.toString();
	}

	/**
	 * This class is the builder itself.
	 * Notice that in every builder method we always return the builder instance. 
	 * This allows us to continue building more parts of the car in one single line.
	 */
	static final class Builder {

		/**
		 * Here we keep an instance of the car we are building. When finished we return it.
		 */
		private final Car car = new Car();

		/**
		 * This is the method that return the car we previously built (or not)
		 * @return
		 */
		public Car getInstance() { return car.getBrand() == null ? null : car; }

		public Builder buildBrand(String brand) {
			this.car.brand = brand;
			return this;
		}

		public Builder buildModel(String model) {
			this.car.model = model;
			return this;
		}

		public Builder buildVersion(String version) {
			this.car.version = version;
			return this;
		}
	}

}

public class Builder {

	public static void main(String[] args) {
		Car c1 = Car.getBuilder().buildBrand("BMW").buildModel("Serie 5").buildVersion("535d Touring").getInstance();
		Car c2 = Car.getBuilder().buildBrand("VW").buildModel("Passat").getInstance();
		Car c3 = Car.getBuilder().buildModel("Class E").getInstance();
		
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3 == null ? "You don't have a car! Please create a car with a brand defined." : c3);
	}
}

package pt.joaobrito.builder;

/**

* This is the class that we will create object of

class Car {

private String brand, model, version;

/**

* This private constructor avoids the user to create the object in the complex way

* using the new keyword.

private Car() {}

/**

* This method allows us to get the builder of the car without instantiating the car

* @return the builder instance

public static Builder getBuilder() { return new Builder(); }

public String getBrand() { return this.brand; }

public String getModel() { return this.model; }

public String getVersion() { return this.version; }

/**

* This is the printable version of the car

* @return a printable car

@Override

public String toString() {

StringBuilder sb = new StringBuilder("Your new car -> ");

if (brand != null) { sb.append("brand: " + brand); }

if (model != null) { sb.append(", model: " + model); }

if (version != null) { sb.append(", version: " + version); }

return sb.toString();

}

/**

* This class is the builder itself.

* Notice that in every builder method we always return the builder instance.

* This allows us to continue building more parts of the car in one single line.

static final class Builder {

/**

* Here we keep an instance of the car we are building. When finished we return it.

private final Car car = new Car();

/**

* This is the method that return the car we previously built (or not)

* @return

public Car getInstance() { return car.getBrand() == null ? null : car; }

public Builder buildBrand(String brand) {

this.car.brand = brand;

return this;

}

public Builder buildModel(String model) {

this.car.model = model;

return this;

}

public Builder buildVersion(String version) {

this.car.version = version;

return this;

}

public class Builder {

public static void main(String[] args) {

Car c1 = Car.getBuilder().buildBrand("BMW").buildModel("Serie 5").buildVersion("535d Touring").getInstance();

Car c2 = Car.getBuilder().buildBrand("VW").buildModel("Passat").getInstance();

Car c3 = Car.getBuilder().buildModel("Class E").getInstance();

System.out.println(c1);

System.out.println(c2);

System.out.println(c3 == null ? "You don't have a car! Please create a car with a brand defined." : c3);

}

The final result:

Development, tutorial

Singleton Design Pattern

August 24, 2015 admin Leave a comment

With his design patttern we allways get the same instance, as you can see next.

The Singleton class:

package pt.joaobrito.singleton;

public final class Singleton {

	/**
	 * A private constructor. This is necessary in order to not allow create a new Singleton object
	 * from the outside with the keyword new
	 */
	private Singleton() {}

	private static final class SingletonHolder {
		public static final Singleton INSTANCE = new Singleton();
	}

	public static final Singleton getInstance() {
		return SingletonHolder.INSTANCE;
	}
}

package pt.joaobrito.singleton;

public final class Singleton {

/**

* A private constructor. This is necessary in order to not allow create a new Singleton object

* from the outside with the keyword new

private Singleton() {}

private static final class SingletonHolder {

public static final Singleton INSTANCE = new Singleton();

}

public static final Singleton getInstance() {

return SingletonHolder.INSTANCE;

}

2. The main class:

package pt.joaobrito.singleton;

public class Main {

	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();

		// test if the reference are the same
		System.out.println(s1 == s2);
	}

}

package pt.joaobrito.singleton;

public class Main {

public static void main(String[] args) {

Singleton s1 = Singleton.getInstance();

Singleton s2 = Singleton.getInstance();

// test if the reference are the same

System.out.println(s1 == s2);

}

3. The result:

UML

Development, tutorial

Reverse String/array recursively

July 24, 2015 admin Leave a comment

Here is an example how to recursively invert the order of a string or an array in Java.

package pt.joaobrito;

public class Recursive {

	/**
	 * The main method
	 *
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println("Inverted string: " + reverseString("123456789"));

		System.out.print("Inverted array:  ");
		int[] ra = reverseArray(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9});
		for (int s : ra) {
			System.out.print(s);
		}
		System.out.println("");
	}

	/**
	 * This method inverts the order of the string
	 *
	 * @param s
	 * @return the reverse string
	 */
	public static String reverseString(String s) {
		if (s.length() == 0) {
			return s;
		}
		// recursive call
		return s.substring(s.length() - 1) + reverseString(s.substring(0, s.length() - 1));
	}

	/**
	 * This method inverts the order of the array
	 *
	 * @param array
	 * @return the inverted array
	 */
	public static int[] reverseArray(int[] array) {
		if (array.length <= 1) { // stop condition
			return new int[]{};
		}

		int[] aux = new int[array.length - 2];
		for (int i = 0; i < aux.length; i++) {
			aux[i] = array[i + 1];
		}

		int[] g = reverseArray(aux); // recursive call

		System.arraycopy(g, 0, array, 1, g.length);
		int firstPosition = array[0];
		array[0] = array[array.length - 1];
		array[array.length - 1] = firstPosition;
		return array;
	}

}

package pt.joaobrito;

public class Recursive {

/**

* The main method

* @param args

public static void main(String[] args) {

System.out.println("Inverted string: " + reverseString("123456789"));

System.out.print("Inverted array: ");

int[] ra = reverseArray(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9});

for (int s : ra) {

System.out.print(s);

}

System.out.println("");

}

/**

* This method inverts the order of the string

* @param s

* @return the reverse string

public static String reverseString(String s) {

if (s.length() == 0) {

return s;

}

// recursive call

return s.substring(s.length() - 1) + reverseString(s.substring(0, s.length() - 1));

}

/**

* This method inverts the order of the array

* @param array

* @return the inverted array

public static int[] reverseArray(int[] array) {

if (array.length <= 1) { // stop condition

return new int[]{};

}

int[] aux = new int[array.length - 2];

for (int i = 0; i < aux.length; i++) {

aux[i] = array[i + 1];

}

int[] g = reverseArray(aux); // recursive call

System.arraycopy(g, 0, array, 1, g.length);

int firstPosition = array[0];

array[0] = array[array.length - 1];

array[array.length - 1] = firstPosition;

return array;

}

The output is:

Notice that in the string method we have twice the iterations that we have in the array method, because we go through all positions in the string.

If you know other ways of doing it, please feel free to comment it out.

Thanks.

João David Brito

All posts by admin

openCV – Android app

Java 8 – Some of the new features

Design Pattern: Command and State together

Working with nested Maps in JAVA

Git Workflow

SQL JOINS

Builder Design Pattern

Builder Design Pattern (simple way)

Singleton Design Pattern

Reverse String/array recursively

software architect

March 2020
M	T	W	T	F	S	S
« Feb
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

software architect