Intent i = new Intent(Intent.ACTION_VIEW,
Uri.parse("google.navigation:q=Hemsworth+Pontefract"));
startActivity(i);

I don’t want to go into the why’s of using grails when there are already many other frameworks out there but for me, I love Java for its power, vast number of libraries and community support available. I also love Ruby On Rails, for its convention over configuration benefits so when I discovered Grails is a kind of merge of the two, it quickly gained my interest. There are many cool features to Grails but to pinpoint a couple, not having to go through all the initial setting up of Spring, Hibernate, JPA etc is a real time saver, and how it allows you to use it’s own Groovy code alongside pure Java is something in my opinion both very clever and incredible beneficial to us web developers.

My target for these tutorials are not just for beginners to Grails but for anyone looking for quick how-to instructions to use Grails with various Ajax features such as displaying data in a jQuery grid, ajax filtering of data.

I do make the assumption however that you already know the basics of a grails based application and can already create, modify and deploy projects. I also don’t want to insist on any particular IDE for working on these tutorials, although I will be using IntelliJ’s IDEA IDE, Netbeans also has great Grails support but at the time of writing does not offer gsp tag completion. I cannot offer any other comment on the others as I am not familiar with Grails support in the other main contenders.

I also cannot recommend enough the combination of using Firefox as your browser with the Firebug plugin installed so you can keep an eye of your AJAX calls from your page to server. Firebug is a great tool that allows you to easily see what you are sending and what you are receiving.

Anyway enough introduction, let’s move onto the first tutorial of my series.

Grails, JQuery and the Jquery Grid.

In this tutorial I aim to show you how to use the jQuery Grid to present data to your users.

I am using Grails version 1.2 alongside MySQL database.

I will setup a mock up of a customer database for this example, so first you will need to create a new Grails project and setup your datasource details so you are all setup ready to go.

The first step after you’ve created your project and defined your datasource is to create a new Grails Domain class called Customer. I’ve kept it simple, but with enough fields for us to create and display several columns in a grid.

class Customer {
  static constraints = {
    firstName(blank:false,maxSize:50)
    lastName(blank:false,maxSize:50)
    age(nullable:true)
    emailAddress(nullable:true)
  }

  String firstName
  String lastName
  Integer age
  String emailAddress
}

Once your class is defined, you should go ahead and generate the customer controller and corresponding views.

Now would be a good time to add some test data so we have something we can use to manipulate our views. A handy shortcut to create test data here is to edit the bootstrap groovy file so we can create some data at the time our application is launched. This is a technique I often use to preload testdata.

class BootStrap {

def init = { servletContext ->
  // if we have an empty customer database,
  // create some test data
  if (Customer.count() == 0) {
    new Customer(
      firstName:'John', lastName:'Smith',
      age:27,
      emailAddress:'john@somewhere.com'
    ).save()

    new Customer(
      firstName:'Frank', lastName:'Malone',
      age:37,
      emailAddress:'frank@somewhere.com'
    ).save()

    new Customer(
      firstName:'Dave', lastName:'Brown',
      age:34,
      emailAddress:'dave@somewhere.com'
    ).save()

    new Customer(
      firstName:'Barney', lastName:'Rubble',
      age:44,
      emailAddress:'barney@somewhere.com'
    ).save()
  }
}

def destroy = { }
}

I will also change the urlmappings so when we launch the application our default page is the customer index view :

class UrlMappings {
  static mappings = {
    "/$controller/$action?/$id?"{
      constraints {
      // apply constraints here
    }
  }
  "/"(controller:"customer",action:"index")
  "500"(view:'/error')
  }
}

So try running the application now and you should see the default presented list on the customer page. So far so good.

Before we create the necessary adjustments to use a jQuery grid, you will first need to download the required javascript librarys as well css styles for your grid from the following links:

jQuery latest release

jQuery Grid latest release – contains the necessary javascript and css (ui.grid.css). Copy the ui.grid.css to the web-app/css folder.

jQuery UI css themes : theme download – this is a great site that allows you to visual different UI themes for jquery widgets/plugins before downloading the necessary css/images.

I download the ‘min’ versions of the javascript librarys to cut down download time for the user. jquery.jqGrid.min.js and jquery-1.3.2.min.js both go into the web-app/js folder.
You theme will be downloaded as a zip file, you will need to copy the jquery-ui-1.7.2.custom.min.js script into your applications js folder and the contents of the css folder go into your web-app/css folder. For the purpose of this tutorial I downloaded the ui-lightness theme.

So now I want to switch from the default list view, to a jQuery Grid to present our customer data.

Edit your Customer/list.gsp, and perform the following.

1. Include our new javascript librarys by adding the includes into the head section. Our css style sheet should also be reference by also adding to the head section. Your head section should then contain the following:

<link rel="stylesheet" href="${resource(dir:'css',file:'main.css')}" />
<link rel="stylesheet" href="${resource(dir:'css',file:'ui.jqgrid.css')}" />
<link rel="stylesheet" href="${resource(dir:'css/ui-lightness',file:'jquery-ui-1.7.2.custom.css')}" />
<g:javascript library="jquery-1.3.2.min"/>
<g:javascript library="jquery-ui-1.7.2.custom.min"/>
<g:javascript library="grid.locale-en"/>
<g:javascript library="jquery.jqGrid.min"/>

2. Remove the tag and contents of

tag as well as the paginator tag that immediately follows it.3. I usually create page fragments for my jquery specific grids but for this example we will just place the code directly into the main list page.

You have to create a table element to hold our grid, as well as div element to go at the end of the table to display record count, paginator.

Insert the following jquery Grid definition. This defines a very basic grid which will be rendered when the page loads in the browser. Notice the url parameter, url:’jq_customer_list’. This is the url from which the grid will load its data. I have also specified the format of the data will be JSON. These parameters lead us to our next stage, we need to create the necessary function in our Customer controller that will return the data.

<!-- table tag will hold our grid -->
<table id="customer_list" class="scroll jqTable" cellpadding="0" cellspacing="0"></table>
<!-- pager will hold our paginator -->
<div id="customer_list_pager" class="scroll" style="text-align:center;"></div>

<script type="text/javascript">// <![CDATA[
/* when the page has finished loading.. execute the follow */
$(document).ready(function () {
  jQuery("#customer_list").jqGrid({
  url:'jq_customer_list',
  datatype: "json",
  colNames:['First Name','Last Name','Age','Email Address','id'],
  colModel:[
    {name:'firstName'},
    {name:'lastName'},
    {name:'age'},
    {name:'email'},
    {name:'id'}
  ],
  pager: jQuery('#customer_list_pager'),
  viewrecords: true,
  gridview: true
  });
});
// ]]></script>

4. Create the jq_customer_list action in the Customer controller to respond to the grids request for JSON data.

As we are returning JSON type data, you must add an import to the top of the controller : import grails.converters.JSON

Note that the order of the fields must match the order in which we defined the order in the colModel and colNames in the grid definition. The minimal code to return the data is as follows:

def jq_customer_list = {
  def customers = Customer.list()
  def jsonCells = customers.collect {
    [cell: [it.firstName,
    it.lastName,
    it.age,
    it.emailAddress], id: it.id]
  }
  def jsonData= [rows: jsonCells]
  render jsonData as JSON
}

5. Try and run your application, if all succeeded you should be presented with your customer data in a nice looking grid.

Browser showing customer list presented in jquery grid

The entire project for this tutorial can be downloaded here.

In my next tutorial I will take what we have done so far, and implement ajax pagination and table sorting when the user clicks on a column header.

Interested in learning more grails?  Head over and join up at the grails forum

The problem is releated to Grails running out of connections to MySQL over time, & not freeing stale connections.  I believe it happens when there hasn’t been activity for over 8 hours, which in my case happened everyday due to the overnight period.

So what we should be doing is managing our own database connection pool.   I use Tomcat 6 on my production servers so the following solution is specifically for tomcat 6.

What we need to do is first change our application configuration so it sets up a database connection pool through tomcat.  And secondly we need to tweak the configuration so that we validate the connection is present periodically and removed stale connections.

The first thing then is to define the connection pool in <your application dir>/web-app/META-INF/context.xml

A typical context.xml would be :

<?xml version="1.0" encoding="UTF-8"?>
<Context path="/MyApplication">
<Resource
 auth="Container"
 driverClassName="com.mysql.jdbc.Driver"
 maxActive="20"
 maxIdle="10"
 maxWait="-1"
 removeAbandoned="true"
 name="jdbc/myAppsPool"
 type="javax.sql.DataSource"
 url="jdbc:mysql://localhost:3306/Database_Name"
 username="user"
 password="password"
 validationQuery="SELECT '1'"
 removeAbandonedTimeout="60"
 logAbandoned="true"/>
</Context>

This alone will create the necessary database connection pool when you application is deployed.

All thats left to do now is to change your datasource configuration to refer to the connection pool so in your DataSource.groovy file, locate the production section and alter it to refer to the new pool, e.g :

production {
  dataSource {
    pooled = false
    dbCreate = "update"
    jndiName = "java:comp/env/jdbc/myAppsPool"
  }
}

That should solve any of those DataAccessResourceFailureExceptions from now on.[

Both formats are based on Decimal coordinates.

Latitude range is from -90 to +90

Longitude from -180 to +180

For Latitude the regex pattern is

(-?[0-8]?[0-9](\.\d*)?)|-?90(\.[0]*)?

For Longitude use

(-?([1]?[0-7][1-9]|[1-9]?[0-9])?(\.\d*)?)|-?180(\.[0]*)?

This will also restrict the decimal values being > 0 for both +- 90′ and +- 180

1. Generate HTMLHELP via Oxygen.

2. (can compile to CHM) or carryon and import HTMLHelp project (hhp) file into Robohelp.

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException{ 

StringBuffer sb = new StringBuffer();
sb.append("The following information was posted via the website;\n\n");

// Sort the list
List paramList = Collections.list(request.getParameterNames());
Collections.sort(paramList);
Enumeration sortedList = Collections.enumeration(paramList);

// iterate the list and append to a StringBuffer
for (Enumeration e = sortedList; e.hasMoreElements();) {

String paramName = (String) e.nextElement();
String[] values = request.getParameterValues(paramName);
sb.append(paramName + " = " + values[0] + "\n");
sb.append("\n");
}

// Email admin the sorted form contents
Utils.Send_SMTP("mailer@dbws.net", Utils.adminEmails, "Website Form Submission", sb.toString());

request.getRequestDispatcher("thankyou.jsp").forward(request, response);
}

I am using Visual Studio 2005, with Compact Framework 2 SDK. I will target the Pocket PC 2003 platform but this will run on Windows Mobile 5 and 6 with no change to code.

First of all we must setup the development environment.

Start by creating a new project (see figure1).

(figure 1)

You now have your blank canvas to begin creating your control but first we should change the name of the control to something more meaningful.
In the Solution explorer right click the UserControl1.cs and choose rename, I have renamed my control to PictureButtonControl.cs. You will be prompted whether you wish to rename all references to UserControl1, click Yes.

One particular feature I have liked about Visual Studio, from the early days is the ability to add multiple project types to a solution and the way the projects are aware of each other. Because of this we can add a new Device Application project which will allow us to test the control as we develop it.

So lets add the Test project now, again in Solution explorer right click the solution and click Add, then “New Project…”. In the dialog that appears choose Device Application and give it a meaningful name (see figure2).

(figure 2)

Your solution explorer should now show both the UserControl project and the Testing Project(see figure3).

(figure 3)

Now we can begin to add some functionality to our control.

Lets start by adding the most important component of this control which is the PictureBox. Reselect our user control and drag a PictureBox control over to the empty control in the designer. Alternatively double click the PictureBox control and it will also be added to our control.

I’m going to apply a slight amount of padding around the picturebox control by setting its location property to 3,3. I have set the size property to 80, 70. To apply equal padding on the right side of our control I have set the width of our control to 86. (figure 4).

(figure 4)

Next we need to provide a method of getting a picture into our control for whoever will be using our control in a design environment. To do this we create a public property within our control which when set will in turn set the property of the private PictureBox control.

Begin by bring up the code for our PictureButtonControl.cs class. Not much to see at the moment.

namespace PictureButton {
	public partial class PictureButtonControl : UserControl
	{
		public PictureButtonControl()
		{
			InitializeComponent();
		}
	}
}

After the constructor enter the following code;

public Image ButtonImage{
	get
	{
		return pictureBox1.Image;
	}

	set
	{
		pictureBox1.Image = value;
		this.Refresh();
	}
}

This code declares a new property ButtonImage which will appear in the properties inspector at design time and acts as a proxy between our control and the underlying PictureBox within our control.

We can test this functionality immediately by first building the solution and then moving to our test application, so first press F6 to build the solution and then double click Form1.cs in the solution explorer. You should see an empty PDA image waiting for us to design our test app.

More importantly if you scan the toolbox you should now see our new custom control(see figure 5);

(figure 5)

Double click our control in the toolbox to place an instance on the test application form(figure 6). The control should now appear in our test form and if you look at the properties window, you will see our custom property – ButtonImage.

(figure 6)

Select the ButtonImage property, and click the … button to select an image from your computer that you would like to use on the button, choose a small picture.
Once selected you should see the image you chose appear in the PictureBox of our control(figure 7).

(figure 7)

We should think about sizing issues here since at the moment our user control may and will be resized by users as they design their forms, so we should capture that resize event and resize our picture box accordingly. So switching back to our control design and selecting our control we can look at the events listed in the properties window and create a ‘resize’ event. This will automatically create the stub below for you.

private void PictureButtonControl_Resize(object sender, EventArgs e)

Edit the code so it reads as below, this will adjust the size of the picturebox keeping the 3 pixel padding to the size of the user control;

private void PictureButtonControl_Resize(object sender, EventArgs e){            	pictureBox1.Width = this.Width - 6;	pictureBox1.Height = this.Height -6;}

Lets quickly test the behavior. First remove the instance of the existing control we have on our test application form and rebuild the solution pressing F6. Recreate an instance of the control on the form and try resizing the control, you should see the picturebox resizing with our control.

We need to see how that works when we have an image, so using the properties window, select the ButtonImage and load an image into the control and retry the resizing.

Notice how the image itself does not resize even though our control is resizing correctly, this means we should also expose the SizeMode property of the PictureBox by creating a new custom property. Switching back to the PictureButtonControl class I will add a new property called SizeMode.

Add the following code to your user control class.

// SizeMode - Defines Picturebox image sizing strategy.

public System.Windows.Forms.PictureBoxSizeMode SizeMode
{
	get
	{
		return pictureBox1.SizeMode;
	}

	set
	{
		pictureBox1.SizeMode = value;
		this.Refresh();
	}
}

This will give us a new property called SizeMode in our usercontrol which behaves exactly the same as if we are editing the SizeMode property of the PictureBox directly.

You can try testing this yourself, make sure you first remove the control from the test application form before rebuilding the solution.

I want to know think about having a label option, so that we can give the user the opportunity to include a label as well as set its various cosmetic properties such as font and colour. Begin by resizing the user control design so we have space at the bottom, the size in my example is now 86, 100. Next add a label to the control and position it at the space we created. I have set the anchor to Bottom, Left, Right, and set the TextAlign property to TopCenter.

I will add a set of properties using the same technique as before for Font, Forecolor, and Text.

We will also need to adjust our resizing event, so that it takes into account the label height when resizing the PictureBox.

The entire code for my user control class is now;

using System;using System.Collections.Generic;using System.ComponentModel;using System.Drawing;using System.Data;using System.Text;using System.Windows.Forms;

namespace PictureButton{    public partial class PictureButtonControl : UserControl    {        public PictureButtonControl()        {            InitializeComponent();        }        // PictureBox properties        // ButtonImage - Specifys image to be displayed        public Image ButtonImage        {            get            {                return pictureBox1.Image;            }            set            {                pictureBox1.Image = value;                this.Refresh();            }        }        // SizeMode - Defines Picturebox image sizing strategy.

        public System.Windows.Forms.PictureBoxSizeMode SizeMode        {            get            {                return pictureBox1.SizeMode;            }            set            {                pictureBox1.SizeMode = value;                this.Refresh();            }        }

        // Label Properties        // Text - Defines text to show on label        public String LabelText        {            get            {                return label1.Text;            }            set            {                label1.Text = value;                this.Refresh();            }        }

        // Font - Defines label font        public Font LabelFont        {            get            {                return label1.Font;            }            set            {                label1.Font = value;                this.Refresh();            }        }

        // ForeColor - Defines label forecolor        public Color LabelForeColor        {            get            {                return label1.ForeColor;            }

            set            {                label1.ForeColor = value;                this.Refresh();            }        }

        private void PictureButtonControl_Resize(object sender, EventArgs e)        {                        pictureBox1.Width = this.Width - 6;            pictureBox1.Height = this.Height - (label1.Height + 6);        }    }}

Now I have an image that resizes accordingly, and a customisable label it would be a good idea to give our control a test, so again remove the existing control from the test app form, rebuild the solution and add our control. Now you will be able to change the label as well as add an image and resize the control to best display the image.

Figure 8 shows the current control in our designer, and figure 9 shows the same control running within our test app on the emulator.

(figure

(figure 9)

The next stage is to add visual indication to show that the button has been clicked, a common approach is to supply an additional image that should be shown in place of our standard image when the button is clicked. Without going into image editing a quick way to produce an appropriate image is to create a grey scaled version of the original.

Again we will need to add a new property called ButtonImageClick along with a private variable to hold the reference to the image.

Create

private Image _ButtonImageClick;
private Image _ButtonImage; // Used for temp holder of main image

and

	// MouseDown event for our control
	private void PictureButtonControl_MouseDown(object sender, MouseEventArgs e)
	{
		if (_ButtonImageClick != null)
		{
			_ButtonImage = pictureBox1.Image;
			pictureBox1.Image = _ButtonImageClick;
			Refresh();
		}
	}
	// MouseUp event for our control
	private void PictureButtonControl_MouseUp(object sender, MouseEventArgs e)
	{
		if (_ButtonImage != null)
		{
			pictureBox1.Image = _ButtonImage;
			Refresh();
		}
	}

	private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
	{
		this.OnMouseDown(e);
	}

	private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
	{
		this.OnMouseUp(e);
	}

	private void pictureBox1_Click(object sender, EventArgs e)	{		this.OnClick(e);	}

This will allow us to specify an image that should be display when the user clicks a button, however it does not perform and swapping of images. We have to also capture the mouse down events for the PictureBox and call the MouseDown/Up event of our control.

Test the control again now, loading both images and you should have a functional custom control that redraws accordingly when clicked.

By now you can see how easy it is to add custom properties to the control and alter the behaviour accordingly, from here it is really up to you how far you want to carry on customising the control.

Other options you can quickly add now are options like whether to change the border state when pressed, or change the background colour of the control, or the color of the label. You could also extract the mouseDown event code and place it in its own method that we can call from the Key Down event as well as the Mouse Down Event. A consideration might be to show an indication when the control has focus, and again when the control loses focus, this may be a border or a background colour change.

A future task is to draw the original image in grey at runtime on a click event, so the user who is designing with our control does not have to perform the additional step of creating a greyscale image themselves. I would also like to discover a better way of passing the events from the PictureBox up to our usercontrol, otherwise there will be a growing amount of code capturing all the events. This could really get messy if you had to create a usercnotrol that contains many controls, then you’d have to capture and pass up the chain lots of events. I’m sure there must be a way to state that I only want our control to register events and none of the controls within our control.

Well thats about the end of this article, I hope someone out there finds it useful.

Download Entire Source Code & Test Application Solution (75k)

If you're not sure of the class you can send a 0 in the class parameter (There is also a slight change in the REGISTER definition).

Anyway the problem I ran into was when I exited my application and ran it a second time, It would act as if there is an instance already running and not allow itself to run.  Killing the NTVDM would make no difference.

So I wrote a little app to go through an enumeration of the available windows in the system and sure enough there was a window there with the same caption as my applications, Even though my app is no longer running and NTVDM was killed.

The thing I noted was the windows class name was "ThumbnailClass" – Which I'm pretty sure is to do with Vista's "Desktop Window Manager" fancy effects it uses for task switching. It shows you a thumbnail image of your application while you switch tasks. Now why this would still be present when my application is no longer running is beyond me, perhaps its a synchronisation problem between the Win16 layer windows enumeration and the Desktop Window Manager.  However the problem is existant on the Business edition and I presume the Premium edition as the fancy Aero effects dont come with  the Basic edition.

So the solution I used was to find the class of the Superbase application window and also use that in my call to FindWindow.

So if you're checking for a class name the REGISTER definition will be:

REGISTER "USER","FindWindow","HCC"

if you dont know the class name and will pass a 0 instead it will be:

REGISTER "USER","FindWindow","HJC"

And to get the handle of a window of a SB Application by its caption the call will be:

hwnd% = CALL ("FindWindow","SBV3DATACLASS",caption$)

First of all, How are you going to get the XML across the wire ?  To answer this the easiest method I discovered was to use the MSXML object, since I have already been using it to create my XML document.

But then which version is best ? There are 6 to choose from ! To answer that I would ask you if plan on distributing your application and dont mind also taking care to include the MSXML msi installer with your deployment. For my purposes I want to make the deployment as easy as possibly. You can pretty much rely on MSXML v3 being present on a target machine. If you dont mind deploying an MSXML msi, then go for version 6.  So I went with version 3.

So far so good, I created my VB code to use MSXML3 to create the document and perform a HTTP post to my servlet which read it in without difficulty.

However the document being sent was 20k in length. That size might not be of significance to you but for me, this action maybe repeated up to 30 times, from many different machines so optimising bandwidth use was also a priority.

The immediate solution is to compress the data.  Searching the web there are many compression components available for VB. However I dont want to pay for something and really just need to zip the data so I can unzip it from my servlet.  I used the ZLIB library from http://www.zlib.net/.  Very easy to use, simply reference zlib.dll from your project and you can either compress a string or a byte array which suits us perfectly.  

Using ZLIB I took the original XML Documents xml source and first converted it to a byte array. Then using the compressData method from the ZLIB library, compressed the data. This took my 15k document down to 2k.

So now I've got the compressed data,  I can just post this ? No.  It must be encoded first.  Without going into why data crossing across the internet must be converted to 7 bit ASCII for succesful transmission, just accept that it does.

What encoding method should we use ?    I repeatedly was having problems at this stage. You can specify that a XML node is intended to contain encoded binary by setting its data type to binary.base64.  I had problems here because even though I did this, I was trying to insert a string representation of the compressed data into the nodes content.  This would raise an error from MSXML.  You HAVE to insert a byte array.

These problems led me to trying various other base64 encoding solutions, each giving different results !

So my working solution was to create a New XML Document containing a single element (I called it Data). The data type definition for data is set to binary.base64.  As soon as I insert my compressed byte array into the "Data" node, it is automatically encoded to base64 so it can be transmitted successfully.

 But not quite. I was still having issues..  When my servlet decodes, then decompress the data… Its all in unicode !  So I was unable to recreate an XML document on the servlet side.

 It turned out the routine I used to convert the XML data as a String to a Byte array is creating unicode bytes.. Luckily I found an alternative routine which gives the option to use ASCII/Unicode.

 Once that was sorted everything works great..   & Also across HTTPS. So my XML transmission is fast and secure.

 Source code examples on request.

There are a several approaches to reading and writing files, as well as several approaches to the replacing of values, in fact Java almost always offers a multitude of solutions to a problem.

So i decided to embark upon a little experiment to see what I could find to be the most efficient method.

Firstly I decided to create my own test data. To do so I just simply created a file containing many random bytes. I chose a random number between 0 and 32 as that most closely matched my original client requirement. CreateTest.java will create a 10mb file.

I wrote 4 little tests during the experiment, trying String replacement, byte comparison and replacement and buffered readers/writers. The result surprised me.

Method 1.

My first method I decided to read in the data into a 4k buffer using a FileInputStream. I then create a new String object based upon the bytes read and replace the old value with the new value using String.replace(). Then the bytes from the String are written to a FileOutputStream.

Method 2

The second method I simply wondered if I could save any processing time by doing all the functions of Method1 for comparison and replacing on as little code lines as possible, as I expected this did not make any real difference.

Method 3

For method 3 I used the same method of reading the file by reading into a buffer using FileInputStream but rather than use the String replace function, I first compare the bytes and then write either the old or the new value into a second buffer. The result of this change was encouraging, the time taken to process the file was about 20-40% the time it took using the String object.

Method 4

Feeling encouraged by the results in method 3, I thought now if I use the Buffered Input & Output Stream objects java gives us, then I was sure to reap extra benefits, But the time taken rose dramatically.

Timing Results.

To come up with these results, I ran the classes from the command prompt 10 times each and recorded the average time taken.

Method1 : 500 ms
Method2 : 700 ms
Method3 : 150 ms
Method4 : 2800 ms

I wondered if I could tweak the buffer size in Method 3 to see what difference that makes when processing the files, To be honest I don’t know why I picked 4kb in the first place, it just happens to be habit when defining buffer sizes.

I tried 1k, 16k, 32k, 100k, and 512k.

With a 1k buffer the average time was 280 ms.
A 16k buffer gave me an average of 90 ms.
A 32k buffer gave me an average of 78 ms.
A 100k buffer averages out at 125 ms.
And the 512k buffer was back to roughly 200ms.

So using a 32k buffer gave me the best results.

Conclusion.

I was a little surprised that the time taken rose so dramatically when using the buffered reader and writer object. I must admit my understanding of the buffering objects is not at an expert level but I did expect to see improvement, else why use them if controlling the buffer myself proves to be so much more efficient.

Below you will find all the code used in these tests: