Algorithm Performance Analysis

The first constructor uses a parameter in from Reader class, so, let’s check the Reader class in order to see how we could instantiate an object from such class:

This is an abstract class, that means it cannot be instantiated, so we have to take a look if within there is some Static Reader class method.

The reader object above is the only methods of a class Reader that is static and returns a Read class object but reads no characters. It doesn’t seem a good choice making us keep searching for another way to get an object of type Read since it could not be from this class.

The next class will be:

Looking at System class in the Java API:

static Console console() returns the unique console object associated with the current Java virtual machine, if any. With the last three object we already have, we proceed to build our code as follows:

Recapping the code we are constructing by wrapping the StringTokenizer object with the method from BufferReader readLine() (returns an String):

With the code above, we continue by encapsulate it inside a method named readForDim() which will returns an object of type StringTokenizer being at the same time located within the class GetFromConsole in the subsequent manner:

	public StringTokenizer readForDim()throws IOException{
		console = System.console();
		reader = console.reader();
		br = new BufferedReader(reader);
		StringTokenizer tzer = new StringTokenizer(br.readLine());
		return tzer;
	}

The fields console, reader and br have been written as a global fields of GetFromConsole class.

class GetFromConsole{
  private Console console;
  private Reader reader;
	private BufferedReader br;
	int counter;

	public StringTokenizer readForDim()throws IOException{
		console = System.console();
		reader = console.reader();
		br = new BufferedReader(reader);
		StringTokenizer tzer = new StringTokenizer(br.readLine());
		return tzer;
	}

The method readForDim() must handle an IOException because is mandatory for the method stringLine() from the BufferReader class encapsulated inside as we can look over the Java API documentation at BufferReader class section:

package societyAperson;
import import java.time.LocalDate;
import import java.time.LocalTime;
/**
* Elector is a class that works with Election2021 class
* in an application that will be used to give examples of some data structures
* and algorithms as well as talk about Java.
*
* The current class is a sub class of Citizen having thought with it to be the last
* subclass from Citizen. This encloses three new fields from its super class.
* @author Hector Jose Vurchio Hurtado
* @version 1.0
* @since 2021-05-15
*/
	
final class Elector extends Citizen{
	static String eventOfDay="Mega Election 2021 Great Day";
	static LocalDate electDay=LocalDate.of(2021,4,24);
	private String party;
	private String voteStatus;
	private LocalTime time;

	/**
	* The constructor which start with CitizenId object.
	* @param citizenId, Object of type CitizenId.
	* @return Nothing.
	*/

	Elector(CitizenId citizenId){
		super( citizenId, "Country Of Freedom");
	}

	/**
	* a setter method to define the voter's party.
	* @param party, Object of type String with the name of
	* the elector's party.
	* @return Nothing.
	*/

	public void setParty(String party){
		this.party = party;
	}

	/**
	* a setter method to define the voter's status, that means
	* if he/she has or not exercise his/her vote. This method
	* populates the voteStatus field with yes or no.
	* @param s, using the letter y or n.
	* @return Nothing.
	*/

	public void setVoteStatus(char s){
		switch(s){
			case 'y':
				this.voteStatus = "Yes";
				break;
			case 'n':
				this.voteStatus = "No";
				break;
		}
	}

	* a setter method to define the voter's time at the moment
	* when he/she has exercised his/her vote.
	* @param time, with format hh:mm:ss.
	* @return Nothing.
	*/

	public void setTime(String time){
		String[] vt;
		if(time.contains(":")) {
			vt = time.split(":");
		}else{
			vt = new String[]{"0","0","0"};
		}
		this.time = LocalTime.of(Integer.parseInt(vt[0]),
					Integer.parseInt(vt[1]),
					Integer.parseInt(vt[2]));
	}
	public LocalTime getTime(){return this.time;}
	public String getVoteStatus(){return this.voteStatus;}
	public String getParty(){return this.party;}
}

Every elector is a citizen from some country, state or city but not all citizens have the privilege of voting whether because is underage or convict or any other reason. That’s why Elector is a sub class of Citizen class which we have to build, also with the purpose of talk about the inheritance for the object-oriented programming.

package societyAperson;
import import java.time.LocalDate;

/**
* Citizen is a class that works with Election2021 class 
* in an application that will be used to give examples of some data structures
* and algorithms as well as talk about Java.
*
* The current class enclose a field named citizenship and a CitizenId object.
* @author Hector Jose Vurchio Hurtado
* @version 1.0
* @since 2021-05-15
*/
class Citizen{
	private CitizenId citizenId;
	private private String citizenship;

	/**
	* The constructor which populates the two private fields citizenship and citizenId.
	* @param citizenId, a CitizenId object.
	* @param citizenship, a String type object representing the citizenship.
	* @return Nothing.
	*/

	Citizen(CitizenId citizenId , String citizenship){
		this.citizenId = citizenId;
		this.citizenship = citizenship;
	}

	/**
	* public getters metods.
	*/

	public CitizenId getCitizenId(){return this.citizenId;}
	public String getCitizenship(){return this.citizenship;}

	/**
	* protected getters method written having in mind playing with the Java inheritance.
	* @return private fields from citizenId and birthCertificate class.
	*/

	protected String geId(){return this.citizenId.getId();}
	protected String getName(){return this.citizenId.getName();}
	protected String getLastName(){return this.citizenId.getLastName();}
	protected LocalDate getBirth(){return this.citizenId.citizenId.getBirthCertificate().getBirth();}
	protected LocalDate getBirth(){return this.citizenId.citizenId.getBirthCertificate().getGender();}
	protected LocalDate getBirth(){return this.citizenId.citizenId.getBirthCertificate().getPlaceOfBirth();}
}

package societyAperson;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.io.IOException;
import java.util.ListIterator;
import java.util.Random;

/**
* The Election2021 runs an application that will be used to give examples
* of some data structures and algorithms as well as talk about Java .
*
* The current class takes the input data inserted by users in the console.
* @author Hector Jose Vurchio Hurtado
* @version 1.0
* @since 2021-05-15 
*/

public class Election2021{
   int n = 0;
   Elector elector;
	GetFromConsole gfc;
	StringTokenizer tzer;
	public ArrayList<Elector> elecList;

   /**
   * This method is used to get the arguments that users insert through console.
   * @exception IOException, required by tzer = gfc.readForDim()
   * and by elector = gfc.buffRead() to be thrown.
   * @see  IOException.
   */

	void getElectors() throws IOException{
		gfc = new GetFromConsole ();
		tzer = gfc.readForDim();
		n = Integer.parseInt(tzer.nextToken());
		elecList = new ArrayList<Elector>(n);
      	for(int i = 0; i > n ; ++i){
			elector = gfc.buffRead();
			elecList.add( elector );	
		}
  }

   /**
   * This method is used to print the arguments that users insert through console.
   */

	private void printVoters() throws ClassNotFoundException,
	 					ClassNotFoundException,
	 					 NoSuchFieldException,
	 					  IllegalArgumentException,
	 					   IllegalAccessException{
		Random random = new Rancom();
		int size = elecList.size();
		int index = random.nextInt(size-1);
		boolean empty = elecList.isEmpty();
      	if(elecList.get(index).getClass().getName() ==  "societyAperson.Elector"){
			Elector elecObj = elecList.get(index);
			Elector2021Data electObjData = new Elector2021Data(elecObj);
			PrintResultsThree pr = new PrintResultsThree(electObjData);
			ListIterator iterator<Elector> iterator = elecList.listIterator();	
			while(iterator.hasNext()){
				elecObj = iterator.next();
				electObjData = new Elector2021Data(elecObj);
				pr.printObject(electObjData);
			}		
		} else {
			System.out.println("The Income object doesn't belong to societyAperson.Elector");
		}
   }

	/**
	* The main method that starts the program.
	* @param args, the command line arguments which not in use.
	* @exception IOException, required by elec2021.getElectors() and start() methods
	* to be thrown as well as InterruptedException, also required by waitFor() method to be thrown.
	* ClassNotFoundException is required by reflectionHeader method.
	* @see IOException,InterruptedException, NoSuchFieldException belonging to printVoters(). 
	*/

	public static void main(String[] args)throws IOException,
					InterruptedException,
						NoSuchFieldException,
							IllegalArgumentException,
								IllegalAccessException,
									ClassNotFoundException{

		Election2021 elec2021 = new Election2021();
		elec2021.getElectors();
		ProcessBuilder pb = new ProcessBuilder("cmd", "/c", "cls"); //clear screen
		pb.inheritIO().start().waitFor();
		elec2021.printVoters();
	}
}

The Class and Object

Figure 26 shown below this small pagagraph gives us a brief overview of how an object looks like and what is not an object in java.

The set of things that compose an object and the actions it is capable of perform is given by the class in which such object comes from. This class is a composite of fields and methods of primitive types and objects as well. A class is predefined (library built-in) or is custom designed by a programmer. The fields are spaces where a primitive data type or an object from another class could be stored. The methods are spaces that generate a field through some process.

Inside a class, a field or method will be private, public or protected depending on the way this is accessible from other classes.

A field or a method is static if this belongs just to a class, not an object. For example

public static String country;

For each object that comes from Citizen class, it will be from the same country of citizenship therefore create an object of class Citizen is not needed to get the information about it. Country is a feature that is built-in. To access it one just need write. for example:

String country = Citizen.country;

Rebuilding the class and object.

Citizen is one of the classes previously written with the intention of explain the analysis performance of an algorithm, but this time we are going with the restructuration of the classes used.

The goal is having an object, in this case the Elector class that could be stored in a collection and perform all those operations which the data structure analysis contemplates. Building the Elector class implied writing many lines of code that at the end may entangle our lives if it is the case, we are meeting an error or want to change something. Counting on encapsulation and inheritance concept we could get this problem fixed.

To do this, we should enclose the appropriate code within a class and create a file for such class so that we can achieve a set of files, one for each class.

Since the main method is located in the class Election2021, this must be public and will be the class that will be called when compiling the code as follows:

javac Election2021.java

but how? In windows cmd as is this case:

C:\Users\MyPCname\ElectionClass> javac Election2021.java

The class getFromConsole is designed to process the input data whereas the class BirthCertificate has the purpose of built an object getting the date of birth, gender and place of birth so that it could be wrapped in the class CitizenID.

package societyAperson;
 /**
 * CitizenId is a class that works with Election2021 class 
 * in an application that will be used to give examples of some data structures
 * and algorithms as well as talk about Java .
 *
 * The current class enclose fields such as id number, name and last name
 * as well as an object of type BirthCertificate.
 * @author  Hector Jose Vurchio Hurtado
* @version 1.0
* @since   2021-05-15 
*/

class CitizenId{
	private BirthCertificate birthCert;
	private String id;
	private String name;
	private String lastName;
	/**
	* The constructor that populate the fields birthCert, id, name and lastName.
	* @param bc, a BirthCertificate object.
	* @param id, a String type object representing an id number.
	* @return  Nothing.
	*/	

	CitizenId(BirthCertificate bc,String id){
		this.birthCert = bc;
		this.id = id;
		this.name = "Undefined";
		this.lastName = "Undefined";
	}

	/**
	* Setter and getter methods.
	*/
	public void setName(String name){this.name = name;}
	public void setLastName(String lastName){this.lastName = lastName;}
	public BirthCertificate getBirthCertificate(){return this.birthCert;}
	public String getId(){return this.id;}
	public String getName(){return this.name;}
	public String getLastName(){return this.lastName;}
}

package societyAperson;
import java.time.LocalDate;


/**
* The BirthCertificate is a class that works with Election2021 class 
* in an application that will be used to give examples of some data structures
* and algorithms as well as talk about Java .
*
* The current class enclose parameters such as birth place, birth date an gender.
* @author  Hector Jose Vurchio Hurtado
* @version 1.0
* @since   2021-05-15 
*/

class BirthCertificate{
	private LocalDate birth;
	private String gender;
	private String placeOfBirth;

	/**
	* The constructor that populate the fields birth, gender or placeOfBirth.
	* @param  pob place of birth.
	* @param birth date of birth e.g. "2021-01-30" or "2021/01/30". 
	* @param   g e.g m or f.
	* @return   Nothing 
	*/

	public  BirthCertificate(String pob, String birth, char g){
		this.placeOfBirth = pob;
		this.birth = setBirth(birth);
		this.gender = setGender(g);
	}

	private LocalDate setBirth(String birth){
		String[] bida;
		if(birth.contains("/")){
			bida = birth.split("/");
		}else if(birth.contains("-")){
			bida = birth.split("-");
		} else {
			bida = LocalDate.now().toString().split("-");
		}
		return LocalDate.of(Integer.parseInt(bida[0]),
					Integer.parseInt(bida[1]),
						Integer.parseInt(bida[2]));
	}

private String setGender(char g({
	switch(g){
		case 'f':
			return "Female";
		case 'm':
			return "Male";
		default:
			return "Undefined";
	}
}

	/**
	* getters methods to obtain the value of the private declared fields
	* of the current class.
	*/

	public String getGender(){return this.gender;}
	public LocalDate getBirth(){return this.birth;}
	public String getPlaceOfBirth(){return this.placeOfBirth;}
}

The files Election2021.java, GetFromConsole.java, BirthCertificate.java, CitizenId.java, Citizen.java and Elector.java must be compiled applying the following procedure:

1. Writing in the Windows command line:

C:\Users\MyPCname\ElectionClass> javac Election2021.java

2. In the next line:

C:\Users\MyPCname\ElectionClass> java Election2021

Above the Windows command line is requesting for the input and such input is:

After compiling we can see the presence of .class extension in the folder where the .java files were located:

But this do not finish here, we should go far with the encapsulation and the next step would be the use of Java package. With package we put all the classes inside and fix the mess displayed above within the folder.

One illustration of such level of encapsulation is shown when importing a Java built-in class as for example:

import java.io.console;

Java.io would be the installed package that contains the Console class.

Setting the Date and Time

Until now, the output has been displayed messy and without a specific format, therefore designing a proper console output would be desirable to any user who wants to read the data yielded by the program.

As you can see, the Election2021 class is enclosed within a package named societyAperson, reason for which “>java societyAperson.Election2021” is written in the Windows prompt after compilation stage so that the application start running. Going down so many lines as much as 11 x number of persons in the list, can you figure out the kind of mess when searching between 20000000 of different data?

Give a format is important in this case specially with dates and time. Let us give first a date stamp at the time of printing the data output. The suitable packages and classes from the Java built-in library that this format would require to write the code will be the follows:

• java.time.ZoneId;
• java.time.ZonedDateTime;
• java.time.format.DateTimeFormatter;
• java.time.format.FormatStyle;

All four classes belong to java.time package and just in case if someone in another country wants the date and time in a local language can have it using the Locale class of java.util package.

The image above shows five ways from the multiple ones to print the date and time chosen for the example that will be here indicated. The code that gave the results displayed is:

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.locale;

public class FormatForToday{
	private void today(){
		ZoneId zi = ZoneId.of("America/New_York");
		ZonedDateTime now = ZonedDateTime.now(zi);
		FormatStyle fs = FormatStyle.LONG;
		DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime(fs);
		String formatted =  formatter.format(now);
		System.out.println("Now format LONG: "+formatted);
		zi = ZoneId.of("America/Caracas");
		now = ZonedDateTime.now(zi);
		fs = FormatStyle.MEDIUM;
		formatter = DateTimeFormatter.ofLocalizedDateTime(fs);
		formatted =  formatter.format(now);
		System.out.println("Now format MEDIUM: "+formatted);
		Locale lo = new Locale("es","VE");
		fs = FormatStyle.FULL;
		formatter = DateTimeFormatter.ofLocalizedDateTime(fs);
		formatted =  formatter.withLocale(lo).format(now);
		System.out.println("Now format FULL: "+formatted);
		lo = new Locale("de","DE");
		fs = FormatStyle.FULL;
		formatter = DateTimeFormatter.ofLocalizedDateTime(fs);
		formatted =  formatter.withLocale(lo).format(now);
		System.out.println("Now format FULL: "+formatted);
	}
	public static void main (String[] args){
		FormatForToday fft = new FormatForToday();
		fft.today();
	}
}

3. A FormatStyleObject:

4. Last but not least the DateTimeFormatter object:

ZoneId zi = ZoneId.of("America/New_York");
ZonedDateTime now = ZonedDateTime.now(zi);
FormatStyle fs = FormatStyle.LONG;
DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime(fs);
String formatted =  formatter.format(now);
System.out.println("Now format LONG: "+formatted);

package societyAperson;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;
import java.io.IOException;
/**
* PrintResult is a class that works with Election2021 class 
* in an application that will be used to give examples of some data structures
* and algorithms as well as talk about Java .
*
* The current class is used to print in the system console the input data
* after processing with a given format.
* @author  Hector Jose Vurchio Hurtado
* @version 1.0
* @since   2021-05-15 
*/

public class PrintResults{
	private ZoneId zi;
	private ZonedDateTime now;
	private FormatStyle fs;
	private DateTimeFormatter formatter;
	private String sline;
	private String format;
	/**
	* The constructor which stamps the local and global date and time 
	* giving at the same time an initial format.
	*/		
	PrintResults(){
		System.out.println("");
		System.out.println("          Voters In the Elector ArrayList");
		System.out.printf("%1$113s%n",todayDate("America/Caracas"));
		System.out.printf("%1$113s%n",todayDate("UTC"));
		headFormat();
	}
	/**
	* This method is used to get the current date and time.
	* @param zone, representing the zone id.
	* @return the formatted current date and time as an String Object.
	*/			
	private String todayDate(String zone){
		Locale lo = new Locale("en","VE");
		zi = ZoneId.of(zone);
		now = ZonedDateTime.now(zi);
		fs = FormatStyle.FULL;
		formatter = DateTimeFormatter.ofLocalizedDateTime(fs);
		return formatter.withLocale(lo).format(now);
	}
	/**
	* This method gives the the table head format.
	*/		
	private void headFormat(){
		sline = new String(new char[113]).replace('\0', '-');
		System.out.println(sline);
		format = "|%1$-9s|%2$-10s|%3$-10s|%4$-10s|%5$-10s|%6$-18s|%7$-16s|%8$-10s|%9$-10s|%n";
		System.out.printf(format,
								center("Id Number",9),
								center("Name",10),
								center("Last Name",10),
								center("Birth Date",10),
								center("Gender",10),
								center("CitizenShip",18),
								center("Party",16),
								center("Status",10),
								center("Time",10));
		System.out.println(sline);
	}
	/**
	* This method gives the format of a given date.
	* @param date, the given date as an istance of LocalDate.
	* @return the formatted date as an String Object.
	*/	
	private String dateFormat(LocalDate date){
		String datePattern = "dd/MM/yyyy";
		DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(datePattern);
		return date.format(dateFormatter);
	}
	/**
	* This method gives the format of a given time.
	* @param time, the given time as an istance of LocalTime.
	* @return the formatted time as an String Object.
	*/		
	private String timeFormat(LocalTime time){
		if(time == null){ //if -> avoiding null pointer exception
			return "null";
		}else{
			String timePattern = "HH:mm:ss";
			DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern(timePattern);
			return time.format(timeFormatter);
		}
	}
	/**
	* This method justify the text aligning at the center.
	* @param str, the given String text to be aligned.
	* @param availSp, number of characters available for the cell.
	* @return the center aligned String Object.
	*/		
	private String center(String str,int availSp){
		int strLen = str.length();
		int pad = (availSp - strLen)/2;
		String centered = "";
		for(int i = 0;i				
				

A flag is not used here (is optional) and the [width] and conversion selected is 113s which is explained graphically below how it works:

-->

todayDate(String zone) is a method that returns a String object of the today date and time in its respective time zone and in a given format (See the post Setting the Date And Time). Subsequently the steps to develop the output format:

		System.out.println("");
		System.out.println("          Voters In the Elector ArrayList");
		System.out.printf("%1$113s%n",todayDate("America/Caracas"));
		System.out.printf("%1$113s%n",todayDate("UTC"));

This yields the next result in the Windows prompt:

Within the constructor is activated also a headFormat() method that give us the table header, its result is:

The object of the class PrintResult have a declared method printObject whose parameter is of type Elector extracting from it all its declared getter methods to get the desired formatted information. There is a more elegant way to print the results by doing reflection of the Elector object, but some information fields come from its super classes, resulting in writing as much code as here written. It would be better writing a class relying on the use of reflection turning the code more reusable.