Check it out on the Android market.

The Observer

First we’ll make an interface for our observer, which defines all of the methods that we want to observe. Since ArrayList is parameterized, we’ll add a generic parameterization to our observer as well. I’ve added most, if not all, of the methods that modify the list. In your case, you might not need to observe all of these methods, so you can limit the number of methods in your interface to only the ones you need (or extend an abstract class like I do below).

import java.util.Collection;

public interface ArrayListObserver<E> {

	public void onAdd( E element );

	public void onAdd( int index, E element );

	public void onAddAll( Collection<? extends E> elements );

	public void onAddAll( int index, Collection<? extends E> elements );

	public void onClear();

	public void onRemove( int index );

	public void onRemove( Object obj );

	public void onRemoveAll( Collection<?> c );

	public void onRetainAll( Collection<?> c );

	public void onSet( int index, E element );

	public void onSubList( int fromIndex, int toIndex );

}

The Observable

Next we’ll extend ArrayList by making our very own ObservableArrayList. We’ll override all of the methods we want to observe, let the super class do its work, and we’ll notify the observers which method was called.

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ObservableArrayList<E> extends ArrayList<E> {

	private List<ArrayListObserver<E>> observers = null;
	private static final long serialVersionUID = 1L;

	public ObservableArrayList( ArrayListObserver<E> observer ) {

		registerObserver( observer );

	}

	@Override
	public boolean add( E e ) {

		boolean result = super.add( e );

		if ( result ) {

			for ( ArrayListObserver<E> o : getObservers() ) {

				o.onAdd( e );

			}

		}

		return result;

	}

	@Override
	public void add( int index, E element ) {

		super.add( index, element );

		for ( ArrayListObserver<E> o : getObservers() ) {

			o.onAdd( index, element );

		}

	}

	@Override
	public boolean addAll( Collection<? extends E> c ) {

		boolean result = super.addAll( c );

		if ( result ) {

			for ( ArrayListObserver<E> o : getObservers() ) {

				o.onAddAll( c );

			}

		}

		return result;

	}

	@Override
	public boolean addAll( int index, Collection<? extends E> c ) {

		boolean result = super.addAll( index, c );

		for ( ArrayListObserver<E> o : getObservers() ) {

			o.onAddAll( index, c );

		}

		return result;

	}

	@Override
	public void clear() {

		super.clear();

		for ( ArrayListObserver<E> o : getObservers() ) {

			o.onClear();

		}

	}

	public List<ArrayListObserver<E>> getObservers() {

		if ( observers == null ) {

			observers = new ArrayList<ArrayListObserver<E>>();

		}

		return observers;

	}

	public void registerObserver( ArrayListObserver<E> observer ) {

		getObservers().add( observer );

	}

	@Override
	public E remove( int index ) {

		E toRet = super.remove( index );

		for ( ArrayListObserver<E> o : getObservers() ) {

			o.onRemove( index );

		}

		return toRet;

	}

	@Override
	public boolean remove( Object obj ) {

		boolean result = super.remove( obj );

		if ( result ) {

			for ( ArrayListObserver<E> o : getObservers() ) {

				o.onRemove( obj );

			}

		}

		return result;

	}

	@Override
	public boolean removeAll( Collection<?> c ) {

		boolean result = super.removeAll( c );

		for ( ArrayListObserver<E> o : getObservers() ) {

			o.onRemoveAll( c );

		}

		return result;

	}

	@Override
	public boolean retainAll( Collection<?> c ) {

		boolean result = super.retainAll( c );

		for ( ArrayListObserver<E> o : getObservers() ) {

			o.onRetainAll( c );

		}

		return result;

	}

	@Override
	public E set( int index, E element ) {

		E toRet = super.set( index, element );

		for ( ArrayListObserver<E> o : getObservers() ) {

			o.onSet( index, element );

		}

		return toRet;

	}

	@Override
	public List<E> subList( int fromIndex, int toIndex ) {

		List<E> toRet = super.subList( fromIndex, toIndex );

		for ( ArrayListObserver<E> o : getObservers() ) {

			o.onSubList( fromIndex, toIndex );

		}

		return toRet;

	}

	public void unregisterObserver( ArrayListObserver<E> observer ) {

		getObservers().remove( observer );

	}

}

Abstract Observer

At the moment, for the purpose of this article, I don’t want to observe every method that I specified in my interface. I also don’t want to remove those methods from my interface because in the future I might need them. To get around having to implement each method specified in the interface, I’ll make an abstract observer which, by default, does nothing in each method. Then, I’ll write an implementation extending the abstract class which overrides only the methods I want to observe.

import java.util.Collection;

public abstract class AbstractArrayListObserver<E> implements ArrayListObserver<E> {

	@Override
	public void onAdd( E element ) {

	}

	@Override
	public void onAdd( int index, E element ) {

	}

	@Override
	public void onAddAll( Collection<? extends E> elements ) {

	}

	@Override
	public void onAddAll( int index, Collection<? extends E> elements ) {

	}

	@Override
	public void onClear() {

	}

	@Override
	public void onRemove( int index ) {

	}

	@Override
	public void onRemove( Object obj ) {

	}

	@Override
	public void onRemoveAll( Collection<?> c ) {

	}

	@Override
	public void onRetainAll( Collection<?> c ) {

	}

	@Override
	public void onSet( int index, E element ) {

	}

	@Override
	public void onSubList( int fromIndex, int toIndex ) {

	}

}

Observer Implementation

Here, I just want to observe the add(), remove(), and clear() methods of the ArrayList, so I’ll only override these corresponding methods. For testing purposes, I’m just going to print a message to the console whenever the methods I’m observing are called.

public class MyArrayListObserver<E> extends AbstractArrayListObserver<E> {

	@Override
	public void onAdd( E element ) {

		System.out.println( "Added element: " + element );
		// Do something useful...

	}

	@Override
	public void onClear() {

		System.out.println( "Cleared list!" );
		// Do something useful...

	}

	@Override
	public void onRemove( Object obj ) {

		System.out.println( "Removed object: " + obj );
		// Do something useful...

	}

}

Example Usage

In my main class, I’ll create an ObservableArrayList, register an observer, call some methods on my list and see what the output is.

public class ArrayListObserverTest {

	public static void main( String[] args ) {

		ArrayListObserver<String> observer = new MyArrayListObserver<String>();
		List<String> myList = new ObservableArrayList<String>( observer );
		myList.add( "Test1" );
		myList.remove( "Test1" );
		myList.add( "Test2" );
		myList.clear();

	}

}

Output

You can see in the output that the observer was appropriately notified when each of the observed methods were called.

Added element: Test1
Removed object: Test1
Added element: Test2
Cleared list!

Usage

Assuming you have some properties file called test.properties, this will generate the class for it. Since it works in conjunction with my ParsableProperties, this will “guess” at the data type and create appropriate getters. Currently it only supports Boolean, Integer, Double, String, Date, and URL. Below, I just pass in the properties file and the output path where the generated class should be saved. I also specify the class name, package name, and in this case (for demonstration purposes) I’ve overridden the default list delimiter to use a comma rather than a tilde. (In my ParsableProperties, the default list delimiter is a tilde because you might use commas in number data types).

package net.chiappone.properties.generator.test;

import java.io.File;

import net.chiappone.properties.generator.PropertyClassGenerator;

public class TestPropertyClassGenerator {

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

		File propertyFile = new File( "test.properties" );
		File outputPath = new File( "src/net/chiappone/properties/generator/test/generated" );

		PropertyClassGenerator generator = new PropertyClassGenerator( propertyFile, outputPath );
		generator.setPackageName( "net.chiappone.properties.generator.test.generated" );
		generator.setClassName( "TestProperties" );
		generator.setListDelimiter( "," );
		generator.run();

	}

}

Dynamic Properties

Sometimes you may have a properties file with various keys that have the same value, but for flexibility purposes, you don’t want to share the same key because the value can change sometime in the future. At the same time, it can be cumbersome to duplicate larger values. Here’s a simple example:

backend.timeout: 5000
webservice.timeout: 5000
http.timeout: 30000
other.timeout: 30000

Here, you can see that two values are duplicated across four keys. With my DynamicProperties class, you can reference duplicate values like this:

default.short.timeout: 5000
default.long.timeout: 30000

backend.timeout: ${default.short.timeout}
webservice.timeout: ${default.short.timeout}
http.timeout: ${default.long.timeout}
other.timeout: ${default.long.timeout}

Parsable Properties

Every object returned from a properties file is a String type. If you represent other types of data in your properties file, chances are that you manually convert those values into other types. My ParsableProperties class extends DynamicProperties by adding support to automatically parse different types and lists. Using the above properties file, I can do this:

int backendTimeout = properties.getInteger("backend.timeout");

As opposed to the “old” way:

String backendTimeout = properties.getProperty("backend.timeout");
int converted = 0;
try {
    converted = Integer.parseInt( backendTimeout );
} catch ( NumberFormatException e ) {
    // Handle error
}

If you’re worried about losing the ability to handle the error, you can always provide a default value in the event that the value wasn’t parsable:

// Use a default value of 30000 ms if this property can't be found or parsed
int backendTimeout = properties.getInteger("backend.timeout", 30000);

Supported Types

The API supports all of the primitive wrappers (Boolean, Character, Double, Float, Integer, Long, Short), in addition to URI, URL, File, and Date. This class will also parse lists for all of the above types, so long as they are delimited by some token (the default token is the `~` char since a comma could potentially be used in number values).

Contents

• Encryption / Decryption
  • Encrypting / Decrypting a String
  • Encrypting / Decrypting XML
  • Encrypting / Decrypting Other Objects
• Hashing
  • Hashing a String
  • Hashing XML
• Masking
  • Password Masking
  • Masking XML
• Truncating
  • Truncating a String
  • Truncating XML

Encryption / Decryption

Encrypting / Decrypting a String

Here’s an example on encrypting/decrypting a String with AES:

package net.chiappone.crypt.test.encrypt;

import net.chiappone.crypt.algorithms.Algorithm;
import net.chiappone.crypt.algorithms.KeyHolder;
import net.chiappone.crypt.crypters.StringCrypter;

public class EncryptStringAES {

	/**
	 * @param args
	 */
	public static void main( String[] args ) throws Exception {

		String data = "1234-5678-9012-3456-7890";

		// Generate a secret key for AES-128

		KeyHolder key = new KeyHolder( Algorithm.AES128 );

		// Encrypt and decrypt using the key

		StringCrypter crypter = new StringCrypter();
		String encrypted = crypter.encrypt( data, key );
		String decrypted = crypter.decrypt( encrypted, key );

		System.out.println( "Original Data = " + data );
		System.out.println( "AES-128 Encrypted = " + encrypted );
		System.out.println( "AES-128 Decrypted = " + decrypted );

	}
}

Output

Original Data = 1234-5678-9012-3456-7890
AES-128 Encrypted = 800b46e3522335977aa7be783859ac39d69347213b55e1ff30553c20bfcc60d4
AES-128 Decrypted = 1234-5678-9012-3456-7890

Encrypting / Decrypting XML

Though it’s probably better to encrypt fields before putting into XML, I added support for finding and encrypting/decrypting nodes based on tag.

package net.chiappone.crypt.test.encrypt;

import java.util.ArrayList;
import java.util.List;

import net.chiappone.crypt.algorithms.Algorithm;
import net.chiappone.crypt.algorithms.KeyHolder;
import net.chiappone.crypt.crypters.XmlCrypter;

public class EncryptXmlMultipleAES {

	/**
	 * @param args
	 */
	public static void main( String[] args ) throws Exception {

		String xml = "<customers>\n" + "\t<customer>\n" + "\t\t\t<ssn>123-45-6789</ssn>\n"
				+ "\t\t\t<cc>1234-5678-9012-3456</cc>\n" + "\t\t\t<password>abcdefg</password>\n"
				+ "\t</customer>\n" + "\t\t<customer>\n" + "\t\t\t<ssn>987-65-4321</ssn>\n"
				+ "\t\t\t<cc>9876-5432-1098-7654</cc>\n" + "\t\t\t<password>hijklmnop</password>\n"
				+ "\t\t</customer>\n" + "</customers>";

		// Generate a secret key for AES-128

		KeyHolder key = new KeyHolder( Algorithm.AES128 );

		// Indicate the tags that should be encrypted

		List<String> tags = new ArrayList<String>();
		tags.add( "ssn" );
		tags.add( "cc" );
		tags.add( "password" );

		// Encrypt and decrypt using the key

		XmlCrypter crypter = new XmlCrypter();
		String encrypted = crypter.encrypt( xml, key, tags );
		String decrypted = crypter.decrypt( encrypted, key, tags );

		System.out.println( "Original Data = " + xml );
		System.out.println( "AES-128 Encrypted = " + encrypted );
		System.out.println( "AES-128 Decrypted = " + decrypted );

	}
}

Output

Original Data =
<customers>
    <customer>
        <ssn>123-45-6789</ssn>
	<cc>1234-5678-9012-3456</cc>
	<password>abcdefg</password>
    </customer>
    <customer>
        <ssn>987-65-4321</ssn>
	<cc>9876-5432-1098-7654</cc>
	<password>hijklmnop</password>
    </customer>
</customers>

AES-128 Encrypted =
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<customers>
    <customer>
        <ssn>3b72baec243dcf8f2446bdbc2d3fe60e</ssn>
	<cc>b1fdd12b26e930eef02a5a4afa90472948b800c1c0986436d19db153bf3ef653</cc>
	<password>9b97a02e0e8ae3f9a7fd7cc0d7b91351</password>
    </customer>
    <customer>
        <ssn>c16d031b0133b4d1b63ea7dbf79f1849</ssn>
	<cc>8aea6326da7ece55a1be424355f3518fa329c3055096485947e4007ccf0c9d77</cc>
	<password>21ee817069bbd599001d38eb3f93fb60</password>
    </customer>
</customers>

AES-128 Decrypted =
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<customers>
    <customer>
        <ssn>123-45-6789</ssn>
	<cc>1234-5678-9012-3456</cc>
	<password>abcdefg</password>
    </customer>
    <customer>
        <ssn>987-65-4321</ssn>
	<cc>9876-5432-1098-7654</cc>
	<password>hijklmnop</password>
    </customer>
</customers>

Encrypting / Decrypting Other Objects

Suppose you had some other object, DataObject, which contains certain fields that you want to encrypt/decrypt (credit card, social security, password, etc.). It’s easy to write a crypter that would handle the encryption/decryption for it:

package net.chiappone.crypt.crypters;

import net.chiappone.crypt.algorithms.KeyHolder;
import net.chiappone.crypt.serializable.DataObject;

public class DataObjectCrypter implements Crypter<DataObject> {

	public DataObject decrypt( DataObject data, KeyHolder key ) {

		if ( data != null ) {

			// Decrypt the CC, SSN, and Password

			StringCrypter crypter = new StringCrypter();
			data.setCreditCard( crypter.decrypt( data.getCreditCard(), key ) );
			data.setSocialSecurity( crypter.decrypt( data.getSocialSecurity(), key ) );
			data.setPassword( crypter.decrypt( data.getPassword(), key ) );

		}

		return data;

	}

	public DataObject encrypt( DataObject data, KeyHolder key ) {

		if ( data != null ) {

			// Encrypt the CC, SSN, and Password

			StringCrypter crypter = new StringCrypter();
			data.setCreditCard( crypter.encrypt( data.getCreditCard(), key ) );
			data.setSocialSecurity( crypter.encrypt( data.getSocialSecurity(), key ) );
			data.setPassword( crypter.encrypt( data.getPassword(), key ) );

		}

		return data;

	}

}

Hashing

If you don’t need to get back the original data, you can hash the data (very useful for storing passwords).

Hashing a String

package net.chiappone.crypt.test.hash;

import net.chiappone.crypt.algorithms.Algorithm;
import net.chiappone.crypt.hashers.Hasher;
import net.chiappone.crypt.hashers.StringHasher;

public class HashString {

	/**
	 * @param args
	 */
	public static void main( String[] args ) {

		String data = "1234-5678-9012-3456-7890";
		Hasher<String> hasher = new StringHasher();
		System.out.println( "Original Data = " + data );

		// MD5
		String hashed = hasher.hash( Algorithm.MD5, data );
		System.out.println( "MD5 Hashed = " + hashed );

		// SHA-1
		hashed = hasher.hash( Algorithm.SHA1, data );
		System.out.println( "SHA-1 Hashed = " + hashed );

		// SHA-256
		hashed = hasher.hash( Algorithm.SHA256, data );
		System.out.println( "SHA-256 Hashed = " + hashed );

		// SHA-384
		hashed = hasher.hash( Algorithm.SHA384, data );
		System.out.println( "SHA-384 Hashed = " + hashed );

		// SHA-512
		hashed = hasher.hash( Algorithm.SHA512, data );
		System.out.println( "SHA-512 Hashed = " + hashed );
	}

}

Output

Original Data = 1234-5678-9012-3456-7890
MD5 Hashed = 173ec737e7c3b96f8e5deb86293b2482
SHA-1 Hashed = e8b1b706f089372a7e36af6ca1c09b29f8a17e3c
SHA-256 Hashed = 8dbfce16a02065d83a33c02ed059fec7da394ed2a7fa57a8cfd070656dc5b8ab
SHA-384 Hashed = 8f1ce3278edfdf1fc44bedd02f75cb64447fdddf345cbb26492da3caa8dd8bb983b401bc5b4720cf5443f8f7024ed483
SHA-512 Hashed = b47c33d66bc8d4e86c070bb0117110275bab3b0b25e45f5dea478078b9500ae1506fb6c79d3a688691e4d1dfb5c15970aa791aec6567b7c31c58bddf6b0ae690

Hashing XML

Hashing XML nodes is similar to the above example for encrypting XML:

package net.chiappone.crypt.test.hash;

import java.util.ArrayList;
import java.util.List;

import net.chiappone.crypt.algorithms.Algorithm;
import net.chiappone.crypt.hashers.XmlHasher;

public class HashXmlMultipleTags {

	/**
	 * @param args
	 */
	public static void main( String[] args ) {

		String xml = "<customers>\n" + "\t<customer>\n" + "\t\t\t<ssn>123-45-6789</ssn>\n"
				+ "\t\t\t<cc>1234-5678-9012-3456</cc>\n"
				+ "\t\t\t<password>abcdefg</password>\n" + "\t</customer>\n"
				+ "\t\t<customer>\n" + "\t\t\t<ssn>987-65-4321</ssn>\n"
				+ "\t\t\t<cc>9876-5432-1098-7654</cc>\n"
				+ "\t\t\t<password>hijklmnop</password>\n" + "\t\t</customer>\n"
				+ "</customers>";

		List<String> tags = new ArrayList<String>();
		tags.add( "ssn" );
		tags.add( "cc" );
		tags.add( "password" );

		String hashed = new XmlHasher().hash( Algorithm.SHA256, xml, tags );

		System.out.println( "Original Data = " + xml );
		System.out.println( "Hashed = " + hashed )

	}

}

Output

Original Data =
<customers>
	<customer>
		<ssn>123-45-6789</ssn>
		<cc>1234-5678-9012-3456</cc>
		<password>abcdefg</password>
	</customer>
	<customer>
		<ssn>987-65-4321</ssn>
		<cc>9876-5432-1098-7654</cc>
		<password>hijklmnop</password>
	</customer>
</customers>

Hashed =
<?xml version="1.0" encoding="UTF-8" standalone="no"?><customers>
	<customer>
		<ssn>01a54629efb952287e554eb23ef69c52097a75aecc0e3a93ca0855ab6d7a31a0</ssn>
		<cc>5d444387a5d39f5deb5b24a82a9b990d4ada981515d84469cda488f605799c10</cc>
		<password>7d1a54127b222502f5b79b5fb0803061152a44f92b37e23c6527baf665d4da9a</password>
	</customer>
	<customer>
		<ssn>ecdbc061a36dd6495e016ba4696dedbc4c0b822b4d6ec55b4fb57d17f1df5695</ssn>
		<cc>05e819efb49067336a6105c7d4de554b4b3496d6c468b901f0679e51683e9bab</cc>
		<password>5fa0f12f10e1e16191a8671a42ed6b5245ce97006757070abd92003d771bb56a</password>
	</customer>
</customers>

Masking

Sometimes you just need to mask certain sensitive data, like a password:

Password Masking

package net.chiappone.crypt.test.mask;

import net.chiappone.crypt.maskers.PasswordMasker;

public class MaskPassword {

	/**
	 * @param args
	 */
	public static void main( String[] args ) {

		String data = "mypassword";
		String masked = new PasswordMasker().mask( data );

		System.out.println( "Original Data = " + data );
		System.out.println( "Masked = " + masked );

	}

}

Output

Original Data = mypassword
Masked = **********

Masking XML

Something a little more complicated, masking certain XML nodes with different element data and different ways to mask them.

package net.chiappone.crypt.test.mask;

import java.util.HashMap;
import java.util.Map;

import net.chiappone.crypt.maskers.CreditCardMasker;
import net.chiappone.crypt.maskers.Masker;
import net.chiappone.crypt.maskers.PasswordMasker;
import net.chiappone.crypt.maskers.SocialSecurityMasker;
import net.chiappone.crypt.maskers.XmlMasker;

public class MaskXmlMultipleTags {

	/**
	 * @param args
	 */
	public static void main( String[] args ) {

		String xml = "<customers>\n" + "\t<customer>\n" + "\t\t\t<ssn>123-45-6789</ssn>\n"
				+ "\t\t\t<cc>1234-5678-9012-3456</cc>\n"
				+ "\t\t\t<password>abcdefg</password>\n" + "\t</customer>\n"
				+ "\t\t<customer>\n" + "\t\t\t<ssn>987-65-4321</ssn>\n"
				+ "\t\t\t<cc>9876-5432-1098-7654</cc>\n"
				+ "\t\t\t<password>hijklmnop</password>\n" + "\t\t</customer>\n"
				+ "</customers>";

		Map<String, Masker<String>> map = new HashMap<String, Masker<String>>();
		map.put( "ssn", new SocialSecurityMasker() );
		map.put( "cc", new CreditCardMasker() );
		map.put( "password", new PasswordMasker() );

		String masked = new XmlMasker().mask( map, xml );

		System.out.println( "Original Data = " + xml );
		System.out.println( "Masked = " + masked );

	}
}

Output

Original Data =
<customers>
    <customer>
	    <ssn>123-45-6789</ssn>
		<cc>1234-5678-9012-3456</cc>
		<password>abcdefg</password>
    </customer>
    <customer>
	    <ssn>987-65-4321</ssn>
		<cc>9876-5432-1098-7654</cc>
		<password>hijklmnop</password>
	</customer>
</customers>

Masked =
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<customers>
    <customer>
	    <ssn>xxx-xx-6789</ssn>
		<cc>xxxx-xxxx-xxxx-3456</cc>
		<password>*******</password>
	</customer>
	<customer>
		<ssn>xxx-xx-4321</ssn>
		<cc>xxxx-xxxx-xxxx-7654</cc>
		<password>*********</password>
	</customer>
</customers>

Truncating

Slightly different than masking, truncating is when you just need a certain portion of the data. E.g., sometimes your social security number is truncated to show the last four digits only.

Truncating a String

package net.chiappone.crypt.test.truncate;

import net.chiappone.crypt.truncaters.SocialSecurityTruncater;

public class TruncateSocialSecurity {

	/**
	 * @param args
	 */
	public static void main( String[] args ) {

		String data = "123-45-6789";
		String truncated = new SocialSecurityTruncater().truncate( data );

		System.out.println( "Original Data = " + data );
		System.out.println( "Truncated = " + truncated );

	}

}

Output

Original Data = 123-45-6789
Truncated = 6789

Truncating XML

You can do the same for XML nodes:

package net.chiappone.crypt.test.truncate;

import java.util.HashMap;
import java.util.Map;

import net.chiappone.crypt.truncaters.CreditCardTruncater;
import net.chiappone.crypt.truncaters.SocialSecurityTruncater;
import net.chiappone.crypt.truncaters.Truncater;
import net.chiappone.crypt.truncaters.XmlTruncater;

public class TruncateXmlMultipleTags {

	/**
	 * @param args
	 */
	public static void main( String[] args ) {

		String xml = "<customers>\n" + "\t<customer>\n" + "\t\t\t<ssn>123-45-6789</ssn>\n"
				+ "\t\t\t<cc>1234-5678-9012-3456</cc>\n" + "\t\t\t<password>abcdefg</password>\n"
				+ "\t</customer>\n" + "\t\t<customer>\n" + "\t\t\t<ssn>987-65-4321</ssn>\n"
				+ "\t\t\t<cc>9876-5432-1098-7654</cc>\n" + "\t\t\t<password>hijklmnop</password>\n"
				+ "\t\t</customer>\n" + "</customers>";

		Map<String, Truncater<String>> map = new HashMap<String, Truncater<String>>();
		map.put( "ssn", new SocialSecurityTruncater() );
		map.put( "cc", new CreditCardTruncater() );

		String truncated = new XmlTruncater().truncate( map, xml );

		System.out.println( "Original Data = " + xml );
		System.out.println( "Truncated = " + truncated );

	}

}

Output

Original Data =
<customers>
	<customer>
		<ssn>123-45-6789</ssn>
		<cc>1234-5678-9012-3456</cc>
		<password>abcdefg</password>
	</customer>
	<customer>
		<ssn>987-65-4321</ssn>
		<cc>9876-5432-1098-7654</cc>
		<password>hijklmnop</password>
	</customer>
</customers>

Truncated =
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<customers>
	<customer>
		<ssn>6789</ssn>
		<cc>3456</cc>
		<password>abcdefg</password>
</customer>
	<customer>
		<ssn>4321</ssn>
		<cc>7654</cc>
		<password>hijklmnop</password>
	</customer>
</customers>

The Code

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.util.PDFTextStripper;

public class ParsePdfFile {

	/**
	 * @param args
	 */
	public static void main( String[] args ) throws Exception {

		File myFile = new File( "doc/mypdf.pdf" );
		List<String> lines = new ArrayList<String>();

		FileInputStream inputStream = new FileInputStream( myFile );
		PDDocument pdfDoc = PDDocument.load( inputStream );
		StringWriter writer = new StringWriter();
		PDFTextStripper stripper = new PDFTextStripper();
		stripper.writeText( pdfDoc, writer );
		pdfDoc.close();

		StringBuffer buffer = writer.getBuffer();
		String line = buffer.toString();
		line = line.replaceAll( stripper.getLineSeparator(), "\n" );

		BufferedReader br = new BufferedReader( new StringReader( line ) );

		String currentLine;

		while ( ( currentLine = br.readLine() ) != null ) {

			if ( !currentLine.trim().isEmpty() ) {

				lines.add( currentLine.trim() );

			}

		}

	}

}

The Code

Using Apache POI, it’s pretty simple. Just include the library in your classpath and use the following code:

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;

import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class ParseWodDocFile {

	/**
	 * @param args
	 */
	public static void main( String[] args ) throws Exception {

		File myFile = new File( "doc/myfile.doc" );
		List<String> lines = new ArrayList<String>();

		FileInputStream inputStream = new FileInputStream( myFile );
		POIFSFileSystem fs = new POIFSFileSystem( inputStream );
		HWPFDocument doc = new HWPFDocument( fs );
		WordExtractor we = new WordExtractor( doc );

		String[] paragraphs = we.getParagraphText();

		for ( String line : paragraphs ) {

			if ( line != null && !line.trim().isEmpty() ) {

				lines.add( line.trim() );

			}

		}

	}

}

The Challenge

Though it’s a simple game, it was much more complex than Minesweeper. There’s a lot of rules, there’s a deck of cards involved, and there’s specific scoring. From a GUI perspective, cards have to be drag-and-droppable to different areas of the screen and you should be able to drag-and-drop single AND multiple cards at once.

Cards

The first thing I did was work on a package for the deck of cards. I made a Card class which contained a Rank, Suit, and State (face up or down). Then I made a Deck which holds a CardSet (52 unique cards) and includes methods for adding, removing, shuffling, etc.

Banks

Once that was done I worked on the different “banks” where cards can be placed. These are generally known as the Stock and Waste (where the cards are dealt from), Foundation (where the cards are built, Aces downward), and the Table (made up of 7 columns where the cards are initially dealt to).

Game Engine

Then I worked on the game Engine. It’s completely separate from any GUI so that it can be reused and reimplemented in various ways. I won’t go into too much detail, other than that it contains all of the game logic such that you could actually use the engine to play a whole Klondike game without any interface at all — but it would be very difficult to do so

GUI

Once I felt like the engine was solid, I worked on the GUI. Some of the basic elements (e.g. the Card) I worked on before were extended so that they could include images and (x,y,z) coordinates on the screen. I also made a DesktopEngine that interacted with the core game engine. The reason I did this was to implement the drag-and-drop logic and all the other GUI elements and logic.

Future Improvements

I didn’t implement a timer, finished game animation or high scores. If anyone is interested, please feel free!

The game itself is made up of a board which contains cells/points. According to the game rules, cells (which may or may not contain mines) may be clicked or flagged. The objective is to flag all the cells containing mines and to click all of the “safe” cells. Once all of the safe cells are checked and all of the cells with mines are flagged, the game is won. If a cell with a mine is clicked, the game is lost.

I kept the game engine (msw.game.Engine) separate from the GUI, so the engine itself can be reused and plugged into any GUI aside from the one I included in the project. The main class is msw.game.Main. If you find any bugs or see any room for improvement, please feel free to share. (One feature I didn’t yet add was a timer and proper handling when the game finishes [e.g. high scores]).