Digital Stronghold

This post will teach you how to delete files and directories in Java recursively. There is nothing special in this post but I’m sure this will be useful especially for those who are just starting out their programming career in Java.

boolean deleteRecursively(final File file) {
    if (file.exists()) {
        final File[] files = file.listFiles();
        for (int i = 0; i < files.length; i++) {
            if (files[i].isDirectory()) {
                deleteRecursively(files[i]);
            }
            else {
                files[i].delete();
            }
        }
    }
    return (file.delete());
}

This code was not tested. Please read the Java 6 File API documentation [here] for more information.

"Confidence means non-paralysis, a willingness to act, and act decisively, to start new things and cut failing ventures off." - Tom Peters

Locking a file in Java is platform dependent. Write once run anywhere? Thumbs down. Some platforms will not allow a file access without a lock while others will.

This is very useful especially when writing your own database (I know some people will argue but this is still happening in corporations handling very sensitive data). It starts with a simple file access.

try {
    final File file = new File("Tables.dat");
    final FileChannel fileChannel = new RandomAccessFile(file, "rw").getChannel();
	
    // this method will block until a lock is acquired
    final FileLock lock =fileChannel.lock();
	
    // this method will not block, it will return null or throw an exception
    lock = fileChannel.tryLock();
	
    // TODO: do something with the file
	
    // release the lock
    lock.release();
	
    // cleanup / close file
    fileChannel.close();
} catch (Exception e) {
    // TODO: handle exception
}

Caution: You really need to verify how the target platform handles files. This will not apply on a distributed database as well as networked file systems, if that’s the case you need to write at least a protocol for handling concurrency.

If you are dealing with IBM mainframes, you will see signed numbers written this way.

{ = 0  } = -0
A = 1  J = -1
B = 2  K = -2
C = 3  L = -3
D = 4  M = -4
E = 5  N = -5
F = 6  O = -6
G = 7  P = -7
H = 8  Q = -8
I = 9  R = -9

Enjoy!

“Stupidity is doing the same things repeatedly and expecting different results!”

If you are working on the back-end, this might be of use. Very trivial but rarely used.

/**
 * This class demonstrates how to recover from checked exceptions
 * @author Joset
 */
public class CheckedExceptionRecovery {
	
    /**
     * @param args the command line arguments
     */
    public static void main(String... args) {
	
        InputStreamReader inputStreamReader = new InputStreamReader(System.in);
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
	
        int input = 0;
        boolean done = false;
	
        do {
            try {
                System.out.println("Please enter an integer: ");
                input = Integer.parseInt(bufferedReader.readLine().trim());
                done = true;
            } catch (NumberFormatException numberFormatException) {
                System.out.println("Invalid input. Please try again.");
            } catch (IOException ioException) {
                System.out.println("Cannot proceed.");
            }
        } while (!done);
	
        System.out.println("The integer is: " + input);
    }
}

I was inspired by a face-to-face technical interview awhile ago that is why I am writing this down.

To avoid having the Servlet’s doXXX() methods clogged, use reflection by breaking down your controller code into modules. Here’s how.

You must have the following.

1. Reflection Interface (ServletHandler.java) - An interface for reflection. Nice definition!
2. Main Servlet (MainServlet.java) - A class extending HttpServlet.
3. Module Handler (CreditHandler.java) - A class containing the module’s controller code, for this example, the Credit Module.

in file ServletHandler.java,

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
	
public interface ServletHandler {
    public abstract void setServlet(HttpServlet servlet);
    public abstract void handle(HttpServletRequest request, HttpServletResponse response);
}

in file MainServlet.java,

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
...
    Class HandlerClass = null;
    ServletHandler handler = null;
	
    try {
        //assuming handlerClassName was defined beforehand as CreditHandler
        HandlerClass = Class.forName("com.eradicus.diamondbank.controller." + handlerClassName);
    } catch (ClassNotFoundException classNotFoundException) {
        //some logging facility here
    }
    if (HandlerClass != null) {
        try {
            handler = (ServletHandler) HandlerClass.newInstance();
        } catch (InstantiationException instantiationException) {
            //some logging facility here
        } catch (IllegalAccessException illegalAccessException) {
            //some logging facility here
        }
	
	if (handler != null) {
               //set executing servlet
		handler.setServlet(this);
               //switch control
		handler.handle(request, response);
	}
    }
...
}

in file CreditHandler.java,

public class CreditHandler implements ServletHandler {
    //use this if you need some attributes / methods from the executing servlet such as connection methods, application variables, etc.
    private MainServlet servlet;
	
    public void setServlet(HttpServlet servlet) {
        this.servlet = (MainServlet) servlet;
    }
	
    //this is where the control comes in after invoking handler.handle() above
    public void handle(HttpServletRequest request, HttpServletResponse response) {
        //some good code here
    }
}

There you go. I hope that helps. God bless.

There’s nothing new here. I just want to reiterate though.

class TargetClass {
    private static String DB_PASSWORD = "sw0rdfish";
	
    private static String getDatabasePassword() {
        return DB_PASSWORD;
    }
}

And the attack?

import java.lang.reflect.Method;
	
public class ClassPiercing {
	
    public static void main(String... args) throws Exception {
        Class targetClass = Class.forName("TargetClass");
        Method[] methods = targetClass.getDeclaredMethods();
        methods[0].setAccessible(true);
        String databasePassword = (String)methods[0].invoke(null, null);
        System.out.println("Database Password: " + databasePassword);
    }
}

Output:

Database Password: sw0rdfish

Check out Val’s Blog by clicking [here]. He has more examples.

Consider the snippet.

Integer firstInteger = 1000; // autoboxing
Integer secondInteger = 1000; //autoboxing 
	
if (firstInteger != secondInteger) {
     System.out.println("Different objects!");
}
	
if(firstInteger.equals(secondInteger)) {
     System.out.println("Meaningfully equivalent!");
}

Output:

Different objects!
Meaningfully equivalent!

How about this one.

Integer firstInteger = 100; // autoboxing
Integer secondInteger = 100; //autoboxing 
	
if (firstInteger == secondInteger) {
     System.out.println("Equal objects!");
}
	
if(firstInteger.equals(secondInteger)) {
     System.out.println("Meaningfully equivalent!");
}

And the output?

Equal objects!
Meaningfully equivalent!

And the explanation?

Two instances of the wrapper objects will always be == when their primitive values are the same.
- Boolean
- Byte
- Character from \u0000 to \u007F (0 to 127)
- Short from -128 to 127
- Integer from -128 to 127

Tsk.

This is useful for storing passwords in a database though still vulnerable to md5 dictionary attacks, anyway, here’s a static method.

public static String encrypt(String text) {
        String ecryptedText = "";
        try {
                MessageDigest md5Encrypt = MessageDigest.getInstance("MD5");
                md5Encrypt.update(text.getBytes(), 0, text.length());
                ecryptedText = new BigInteger(1, md5Encrypt.digest()).toString(16);
        }  catch (NoSuchAlgorithmException exception) {
                exception.printStackTrace();
        }
        return ecryptedText;
}

This will return the MD5-encrypted string. Have a great day!

Static methods and variables are shared by all instances of the class. Static variables are initialized when a class is loaded whereas instance variables are initialized when an instance of the class is created. Static methods belong to a class, therefore, it can only access static members of the class and it can be called before instantiating the class.

class StaticCase {
	static int staticCounter = 0;
	int nonStaticCounter = 0;
	
	StaticCase() {
		staticCounter++; //class level
		nonStaticCounter++; //instance level
	}
}
	
class StaticCaseImpl {
	
        //static method, entry point
	public static void main(String... args) {
                //StaticCase.nonStaticCounter, error, not a static variable
	
		StaticCase sc1 = new StaticCase();
		StaticCase sc2 = new StaticCase();
	
		System.out.println("staticCounter sc1: " + sc1.staticCounter);
		//output is staticCounter sc1: 2
                //or in static context, StaticCase.staticCounter
		System.out.println("nonStaticCounter sc1: " + sc1.nonStaticCounter);
		//output is nonStaticCounter sc1: 1
	
		System.out.println("staticCounter sc2: " + sc2.staticCounter);
		//output is staticCounter sc2: 2
                //or in static context, StaticCase.staticCounter
		system.out.println("nonStaticCounter sc2: " + sc2.nonStaticCounter);
		//output is nonStaticCounter sc2: 1
	}
}

There are 3 candidates for the equality test in Java:
1. Primitives
2. References
3. Objects

When we compare things in Java, what is really being compared? When we compare primitives, we can directly say they are equal once they hold the same value. Therefore they can be compared using the == operator. The same is true for reference variables, however, we are not comparing the actual values being referred to, rather we compare the pointers to the actual values.

Primitive

int someInt = 1;
if (someInt == 1) {
//this block will execute
}

The equality of two objects is tested using the equals method of the Object class. The default behavior of the equals method is just the same as the == operator. However, some classes override this method for a specific comparison. One example is the String class, the equals method is overridden to test the equality of the actual strings being held by two String objects.

Object without an overridden equals method

Object a = new Object();
Object b = new Object();
	
if (a.equals(b)) {
//this block will not execute
}

Object with an overridden equals method

String a = new String("I am a string!");
String b = new String("I am a string!");
	
if (a.equals(b)) {
//this block will execute depending on the implementation
//of the equals method, for this instance, it compares the string literals
//being held by two String objects
}

So if you are unsure of how the equals method behave in a specific class, RTF API documentation!

Sun admitted that Solaris’ late move to open source is a big mistake. They said that while they were busy making money, they were already losing the server market, Linux is taking over very fast.

Having tried several versions of Solaris and OpenSolaris, in my honest opinion, opening its source code to the public is a good move.

What’s cool in OpenSolaris 2008.5?

1. IPS - a network package management system that resembles an apt-get type of command. Thanks to Ian Murdock.

2. Bourne Again Shell - C Shell is no longer the default one. This makes majority of the Linux users comfortable when shifting to OpenSolaris.

3. OpenSolaris Developer Expert Assistance - A dedicated online support service for developers that provides technical assistance for code support, programming questions, diagnostic advice, how-to’s and best practice guidance.

4. OpenSolaris Subscription Support - Telephone and online technical support. Provides automatic notification of security updates.

Though in a project with a tight schedule, I was given the chance to attend Sun Microsystem’s Sun Tech Days. I got a free VIP pass luckily because our company uses Solaris boxes. Anyway, here’s what I’ve picked up today.

1. NetBeans 6.1 has -/+ 40% improvement in performance - This is good news. I might be able to use this as an argument for replacing Red Hat Developer Studio in our company. It’s an Eclipse-based IDE, it’s not bad though but there are some glitches.

2. NetBeans 6.1 Platform for Desktop Application Development - The wizard for a kick-start is cool! You can jump in and start crafting without worrying some productivity-killer configurations. Mantisse rocks!

3. NetBeans 6.1 JavaScript Support - If you’re a web developer, and you’re worried too much of cross-browser compatibility issues, this IDE is intelligent enough to determine if your code will work in a specific browser.

4. NetBeans 6.1 Improved Refactoring - If you are renaming an identifier that has already been used in several lines of code, you don’t have to do a Find-and-Replace anymore. With just some key-stroke combinations, you will be able to see on the fly the identifier being renamed. This works with JavaScript code as well. This is pretty useful.

5. NetBeans 6.1 Profiler - This is useful for code reviews. You don’t have to worry about how to configure stuffs for the profiler to work and it spits out very useful information. Makes sense if your customer wants a search speed like Google’s.

6. Visual JSF Web Plugin - One of the productivity-killers is developing the web application UI. This plugin will keep you focused on the business logic rather than the never-ending battle of JavaScript standardization and strict mark-up layouts. This is pretty useful.

7. NetBeans 6.1 Support for Hibernate and Java Persistence API - This is cool! This makes our life easy! Now I have more time for some other stuffs.

8. NetBeans 6.1 Web Services Support - Pretty cool thing if your application requires more outside intervention such as data coming from sophisticated apparatus (semiconductor-manufacturing or test machines).

There are a lot of useful stuffs to play with at Sang Shin’s site http://www.javapassion.com.

In my previous posts, I have enumerated the different types of data, the place where they temporarily reside and their characteristics. Those data are no way different from garbages if operation or manipulation is prohibited.

Java operators can be classified in to three categories according to their operands:
1. Unary Operator - requires one operand, examples are:

++a; a++; --a; a--;

2. Binary Operator - requires two operands, examples are:

j + k

3. Ternary Operator - requires three operands, a very good example is:

!isJosetHandsome() ? "You are a liar!" : "Honesty is such a lonely word.";

Java operators can be also classified in to the following categories according to their purpose:
1. Arithmetic - operators that perform basic math operations

a % b

2. Relational - operators that are being used for comparison

mine > yours

3. Logical - operators that are used for applying boolean logic

isClear() && isConcise()

4. Assignment - operators used for temporary assignment of values

Double idealMonthlySavings = monthlySalary * 0.40;

5. Advanced - all other operators such as parentheses, ternary if-else, brackets, new, instanceof, etc. fall here

float f = 8.8;
int i = (int) f;

Nonprimitive data types in Java are reference variables (object references), arrays and enums. All nonprimitive data types are references to memory where the objects live.

[objects]

References provide access to objects. The declaration syntax is just the same as with primitives.

Decryptor decryptor;

The above example shows that we are creating a reference to a Decryptor object. Take note that no real object is created yet.

The object is created through the new operator.

decryptor = new Decryptor();

The reference decryptor now points to a Decryptor object in the heap.

[arrays]

Arrays are objects used to hold a collection of primitive or nonprimitive data of the same type. Take note that even if an array holds primitive data, it is always an object.

Steps for creating an array:

1. Declaration of an array variable (reference)

char[] charArray; //or
char charArray[];

2. Instantiation of an array of a certain size

charArray = new char[8];

3. Initialization of each array element.

charArray[0] = 'k';
charArray[1] = 'a';
charArray[2] = 'r';
charArray[3] = 'e';
charArray[4] = 'n';
charArray[5] = 'e';
charArray[6] = 'v';
charArray[7] = 'e';

Once a size is given to an array, it cannot be changed later.

[enums]

The data type enum is used to store a predetermined set of values or constants. Examples are the months in a year, the days in a week, etc.

Steps for creating an enum:

1. Define the enum type with unique named values

enum ShortWeek {MON, TUE, WED, THU, FRI, SAT, SUN};

2. Assign a reference to the enum type

ShortWeek monday = ShortWeek.MON;

You can only create X instances of an enum type, where X is the number of elements that the enum type holds.

Default values apply only to instance variables that are uninitialized. Local variables need to be initialized explicitly before use or else the compiler will yell at you.

boolean - false
byte - 0
short - 0
char - ‘\u0000′
int - 0
long - 0L
float - 0.0F
double - 0.0D