File Locking can be achieved in java by making use of the New I/O API (nio). Before the advent of New I/O API, there was no direct support in Java for locking a file. It is important to understand that File locking is hugely dependent on the native operating system on which the program is [...]

File Locking can be achieved in java by making use of the New I/O API (nio). Before the advent of New I/O API, there was no direct support in Java for locking a file. It is important to understand that File locking is hugely dependent on the native operating system on which the program is executing.

File Locks can either be exclusive or shared. An exclusive lock can be acquired on a file only if there are no processes or applications accessing the file. It is possible for one or more processes to have any number of locks on the same file but in different region of a file in the case of a shared lock. Some operating systems doesn’t support the concept of shared locking.

Java provides lock() and tryLock() methods in FileChannel class for getting a lock over the file object. Whether the lock is an exclusive lock or a shared lock depends on the flavor of the methods taking arguments which represents the region of the file to be locked. The method lock() blocks execution until it gets a lock whereas the method tryLock() doesn’t block and returns immediately. If a lock cannot be cannot be acquired on a file, then the tryLock() method will return null.

FileLockTest.java

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
32
33
34
35
36
37
38
39
40

package tips.javabeat.nio.lock;
 
import java.io.*;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
 
public class FileLockTest {
 
    public static void main(String[] args) throws Exception {
 
        RandomAccessFile file = null;
        FileLock fileLock = null;
        try
        {
            file = new RandomAccessFile("FileToBeLocked", "rw");
            FileChannel fileChannel = file.getChannel();
 
            fileLock = fileChannel.tryLock();
            if (fileLock != null){
                System.out.println("File is locked");
                accessTheLockedFile();
            }
        }finally{
            if (fileLock != null){
                fileLock.release();
            }
        }
    }
 
    static void accessTheLockedFile(){
 
        try{
            FileInputStream input = new FileInputStream("FileToBeLocked");
            int data = input.read();
            System.out.println(data);
        }catch (Exception exception){
            exception.printStackTrace();
        }
    }
}

The above program tries to lock a file called “FileToBeLocked” by calling the lock() method on the associated File Channel object. The lock() method blocks the thread until it gets a lock on the file. Then, in order to ensure that the file is locked, the method accessTheLockedFile() is called which tries to read the file contents. Since the lock acquired is an exclusive lock, an IOException is thrown.

The Rounding Mode Enum in java.math package is used to perform precise rounding of decimal values. It was introduced in Java 5.0. This Enum provides various constants each of which is used for different modes of rounding. The decimal value would be rounded off to the number of decimal places based on the scale that [...]

The Rounding Mode Enum in java.math package is used to perform precise rounding of decimal values. It was introduced in Java 5.0.
This Enum provides various constants each of which is used for different modes of rounding. The decimal value would be rounded off to the number of decimal places based on the scale that is defined for the decimal value.

The Rounding Mode Enum constants are UP, DOWN, CEILING, FLOOR, HALF_DOWN, HALF_EVEN, HALF_UP, and UNNECESSARY.

UP

This rounds off any given decimal value away from zero. It basically increments the decimal value. Let us see a simple example,

1
2
3
4
5

BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.UP);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.UP);
System.out.println(value + "n" + value1);

The output of the above code is,

1
2

3
-3

In this example, we have specified the scale as 0. Hence, the rounded value does not have any decimal places.

DOWN

This rounds off any given decimal value towards zero. It does not increment the value. Let us see a simple example,

1
2
3
4
5

BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.DOWN);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.DOWN);
System.out.println(value + "n" + value1);

The output of the above code is,

1
2

2
-2

CEILING

It rounds off any decimal value towards positive infinity. For a positive decimal, it performs the same rounding as RoundingMode.UP. In case of a negative decimal, it performs the same rounding as as for RoundingMode.DOWN. It does not decrement the value. Let us see a sample,

1
2
3
4
5

BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.CEILING);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.CEILING);
System.out.println(value + "n" + value1);

The output of the above code is,

1
2

3
2

FLOOR

It rounds off any decimal value towards negative infinity. For a positive decimal, it performs the same rounding as RoundingMode.DOWN. In case of a negative decimal, it performs the same rounding as as for RoundingMode.UP. It does not increment the value. Let us see a sample that illustrates this,

1
2
3
4
5

BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.FLOOR);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.FLOOR);
System.out.println(value + "n" + value1);

The output of the above code is,

1
2

2
-3

HALF_UP

This rounds off a decimal value towards the nearest neighbouring value apart from the case when both neighbouring values are equidistant, in which case it just rounds up the value. It performs the same rounding as RoundingMode.UP if the discarded fractional part is >= 0.5, else it performs the same rounding as RoundingMode.DOWN. Let us see a sample that illustrates this,

1
2
3
4
5
6
7

BigDecimal value = new BigDecimal("2.4");
value = value.setScale(0, RoundingMode.HALF_UP);
BigDecimal value1 = new BigDecimal("2.5");
value1 = value1.setScale(0, RoundingMode.HALF_UP);
BigDecimal value2 = new BigDecimal("2.6");
value2 = value2.setScale(0, RoundingMode.HALF_UP);
System.out.println(value + "n" + value1 + "n" + value2);

The output of this code is,

1
2
3

2
3
3

HALF_DOWN

This rounds off a decimal value towards the nearest neighbouring value apart from the case when both neighbouring values are equidistant, in which case it just rounds down the value. It performs the same rounding as RoundingMode.DOWN if the discarded fractional part is > 0.5, else it performs the same rounding as RoundingMode.UP. Let us see an example for this,

1
2
3
4
5
6
7

BigDecimal value = new BigDecimal("2.4");
value = value.setScale(0, RoundingMode.HALF_DOWN);
BigDecimal value1 = new BigDecimal("2.5");
value1 = value1.setScale(0, RoundingMode.HALF_DOWN);
BigDecimal value2 = new BigDecimal("2.6");
value2 = value2.setScale(0, RoundingMode.HALF_DOWN);
System.out.println(value + "n" + value1 + "n" + value2);

The output of the above code is,

1
2
3

2
2
3

HALF_EVEN

This rounds off a decimal value towards the nearest neighbouring value apart from the case when both neighbouring values are equidistant, in which case it just rounds towards the nearest even number. It performs the same rounding as RoundingMode.HALF_UP if the digit to the left of the discarded fractional part is odd, and performs the same rounding as RoundingMode.HALF_DOWN if it’s even. Let us see an example for this,

1
2
3
4
5
6
7
8
9

BigDecimal value = new BigDecimal("2.4");
value = value.setScale(0, RoundingMode.HALF_EVEN);
BigDecimal value2 = new BigDecimal("2.6");
value2 = value2.setScale(0, RoundingMode.HALF_EVEN);
BigDecimal value3 = new BigDecimal("7.5");
value3 = value3.setScale(0, RoundingMode.HALF_EVEN);
BigDecimal value4 = new BigDecimal("6.5");
value4 = value4.setScale(0, RoundingMode.HALF_EVEN);
System.out.println(value + "n" + value2+ "n" + value3+ "n" + value4);

The output of the above code is,

1
2
3
4

2
3
8
6

UNNECESSARY

This Rounding mode is used to insist that a value does not need rounding, and this can be possible only when the value has no decimals. If it is used in cases where in the value has decimal places i.e. when rounding is needed, then this will throw Arithmetic Exception stating that rounding is necessary.

Prototype pattern is one of the creational patterns that concentrate on duplicating objects if needed. Assuming that we are in process of creating a template. Most of the times, we copy an existing template, do some changes in it and then will use it. Technically, we make a copy of the source, make some changes [...]

Prototype pattern is one of the creational patterns that concentrate on duplicating objects if needed. Assuming that we are in process of creating a template. Most of the times, we copy an existing template, do some changes in it and then will use it. Technically, we make a copy of the source, make some changes and will use according to the requirements. This is the core concept of the prototype pattern.

For example, assuming that we are creating an Online Leave Application, where someone is asked to fill-in the reason for the leave, start and end date of his/her leave along with details of the approver. A smart thing is for the very first time, we can ask the person to fill in the details and for the subsequent time we can provide an option to copy the first template, do some changes (like changing the start and end date) and allow him to submit.

One important thing that has to be considered in designing prototype pattern is regarding the depth to which we want the object to be copied. In Java terms, whether we want shallow copying or deep copying. In shallow copying, only the primitive properties of the outer object will be copied during the cloning operation, and not the object references. It means that changes made to the target object will be reflected back to the original source object. Whereas, in the case of deep copying, all the primitive and the object references will be copied bit-by-bit, so that it can be ensured that changes done to the target object is not reflected back to the source.

Now, let us see an example for the Prototype pattern what we have discussed till now. Given below is the complete example,

LeaveApplication.java

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

import java.text.SimpleDateFormat;
import java.util.Date;
 
public class LeaveApplication implements Cloneable {
 
	private String reason;
	private Date startDate;
	private Date endDate;
	private Approver approver;
 
	public LeaveApplication(
			String reason, Date startDate, Date endDate, Approver approver){
 
		this.reason = reason;
		this.startDate = startDate;
		this.endDate = endDate;
		this.approver = approver;
	}
 
	public LeaveApplication clone(){
 
		Approver copyApprover = new Approver(
			approver.getName(), approver.getDesignation());
		LeaveApplication copyApplication = new LeaveApplication(
			reason, ((Date)startDate.clone()), ((Date)endDate.clone()), copyApprover);
		return copyApplication;
	}
 
	public String toString(){
		return "[Leave Application:" + reason + "," + toString(startDate)
			+ "," + toString(endDate) + approver + "]";
	}
 
	private String toString(Date date){
 
		SimpleDateFormat format = new SimpleDateFormat("dd-MMM-yy");
		return format.format(date);
	}
 
	public String getReason() {
		return reason;
	}
 
	public void setReason(String reason) {
		this.reason = reason;
	}
 
	public Date getStartDate() {
		return startDate;
	}
 
	public void setStartDate(Date startDate) {
		this.startDate = startDate;
	}
 
	public Date getEndDate() {
		return endDate;
	}
 
	public void setEndDate(Date endDate) {
		this.endDate = endDate;
	}
 
	public Approver getApprover() {
		return approver;
	}
 
	public void setApprover(Approver approver) {
		this.approver = approver;
	}
}

This LeaveApplication is the class that we want to clone. It has 3 simple properties namely reason, startDate and endDate and 1 composite property called Approver. Later on we see the class definition for Approver class. Now, let us have a look over the clone() method. Within this method, we create a new instance for the LeaveApplication class and set its properties to the value of the properties of the original object. In this way, we are making a deep cloning of the object and not a shallow cloning. Given below is the class definition for the Approver class,

Approver.java

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
32

package tips.pattern.prototype;
 
public class Approver {
 
	private String name;
	private String designation;
 
	public Approver(String name, String designation){
		this.name = name;
		this.designation = designation;
	}
 
	public String toString(){
		return "[Approver: " + name + "," + designation + "]";
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public String getDesignation() {
		return designation;
	}
 
	public void setDesignation(String designation) {
		this.designation = designation;
	}
}

Then, we define the main class PrototypeTest for testing the prototype pattern. It creates a new instance of the LeaveApplication class for setting the sickLeave properties. After that, it makes a clone of the sickLeave instance as a casualLeave and modifies some of its properties like the reason and the dates.

PrototypeTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package tips.pattern.prototype;
 
import java.util.Date;
 
public class PrototypeTest {
 
	public static void main(String[] args) {
 
		Approver manager = new Approver("Johny", "manager");
		LeaveApplication sickLeave =
			new LeaveApplication("Fever", new Date(2007, 3, 20), new Date(2007, 3, 22), manager);
		System.out.println(sickLeave);
 
		LeaveApplication casualLeave = sickLeave.clone();
		casualLeave.setReason("Vacation");
		casualLeave.setStartDate(new Date(2007, 10, 10));
		casualLeave.setEndDate(new Date(2007, 10, 20));
		System.out.println(casualLeave);
	}
}

The Java Mail API provides support for sending and receiving electronic mail messages. The API provides a plug-in architecture where vendor’s implementation for their own proprietary protocols can be dynamically discovered and used at the run time. Sun provides a reference implementation and its supports the following protocols namely, Internet Mail Access Protocol (IMAP) Simple [...]

The Java Mail API provides support for sending and receiving electronic mail messages. The API provides a plug-in architecture where vendor’s implementation for their own proprietary protocols can be dynamically discovered and used at the run time. Sun provides a reference implementation and its supports the following protocols namely,

• Internet Mail Access Protocol (IMAP)
• Simple Mail Transfer Protocol (SMTP)
• Post Office Protocol 3(POP 3)

In this tip, let us see how to send mail using the Java Mail API. Following is the complete code listing for sending a mail from a Java Application,

Random numbers in java can be generated either by using the Random class in java.util package or by using the random() method in the Math class in java.lang package. In both these approaches, we only get a pseudo random number and not a true random number because it is all generated based on some mathematical [...]

Random numbers in java can be generated either by using the Random class in java.util package or by using the random() method in the Math class in java.lang package.

In both these approaches, we only get a pseudo random number and not a true random number because it is all generated based on some mathematical computation, and hence the number can be predicted if the logic behind the computation is known. In spite of this, we can use any of these two approaches itself for random number generation for most of our application needs.

Using the Random class

The Random class in java.util package can be used in order to generate random numbers. A seed value can be specfied, which would be used for generating random numbers. This seed value can be specified while creating the Random object. If it is not specified, then the default seed value would be the current time in a day.

There are several methods such as next(), nextInt(), nextDouble(), nextFloat(), nextLong(), nextBytes(), nextBoolean() and nextGaussian() etc.. which can be used to generate random numbers of different data types.

Let us see a simple example for generating random numbers using the Random class,

RandomNumberTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13

import java.util.Random;
 
public class RandomNumberTest {
 
    public static void main(String[] args) {
 
        Random random = new Random();
        int randomVal1 = random.nextInt();
        long randomVal2 = random.nextLong();
        float randomVal3 = random.nextFloat();
        System.out.println(randomVal1 + "n"  + randomVal2+ "n"  + randomVal3);
    }
}

The above code would generate random int, long and float values.

Using the random() method in Math class

The random() method in Math class returns a random positive decimal value that ranges between 0.0 and 1.0. It is a static synchronized method.

The following code shows how to generate random numbers using the random() method,

1
2

double randomValue = Math.random();
System.out.println(randomValue);

If we need to generate a random number in a particular range, we can do so by using the following syntax,

1

<lower-bound in the range> + Math.random() * <count of numbers in the range>

The following code is an example of generating random numbers within a range of 10 to 15,

1
2

double randomValue = 10 + Math.random() * 5;
System.out.println(randomValue);

Let us write a Simple Downloader in this techincal tip by making use of the classes with java.net package. URL stands for Uniform Resource Locator and it is used to locate a resource in the Web in a standard fashion. A resource in the Web can be anything; it can be as simple as Html [...]