package com.kushal.tools;

/**
 * @Author Kushal Paudyal
 * Last Modified On 2011/05/13
 * 
 * A simple utility to find out (through regular expressions) if a string is 
 * contained in another string. The string to search may be located anywhere
 * in the text to look into.
 */
import java.util.regex.Pattern;

public class RegexNotContains {

	static String textToLookInto = "This line is not written in golden letters.";
	static String wordToFind = "golden";
	static String notContainsRegex = "[\\w\\W\\s]*" + wordToFind + "[\\w\\W\\s]*";

	public static void main (String [] args ) {
		
		checkIfContains(textToLookInto, wordToFind);
		
	}
	
	public static boolean checkIfContains(String textToLookInto, String wordTofind )
	{
		boolean matches=Pattern.matches(notContainsRegex,textToLookInto);
		if (matches) {
			System.out.println("Word \'"+wordToFind+"\' was found in the line: "+textToLookInto);
		} else {
			System.out.println("Word \'"+wordToFind+"\' was NOT found in the line: \'"+textToLookInto+"\'");
		}
		return matches;
	}
}

Originally posted 2011-05-17 20:29:01.

The following are a few of the Java Backporting Tools available as of this posting.

• RetroTranslator
• RetroWeaver
• Declawer
• JBossRetro

Retrotranslator one of the backporting tools makes Java applications compatible with Java 1.4, Java 1.3 and other environments. It supports all Java 5.0 language features and a significant part of the Java 5.0 API on both J2SE 1.4 and J2SE 1.3. In other Java environments only the Java 5.0 features that don’t depend on the new API are supported. Retrotranslator employs the ASM bytecode manipulation framework to transform compiled Java classes and the backport of the Java 5.0 concurrency utilities to emulate the Java 5.0 API. [GoTo RetroTranslator Home]

The following features are supported by RetroTranslator:

• Generics
• Annotations
• Reflection on generics and annotations
• Typesafe enums
• Autoboxing/unboxing
• Enhanced for loop
• Varargs
• Covariant return types
• Formatted output
• Static import
• Concurrency utilities
• Collections framework enhancements

Retroweaver is another backporting tool that enables you to take advantage of the new Java 1.5 language features in your source code, while still retaining compatability with 1.4 (and older) virtual machines. Retroweaver operates by transforming Java class files compiled by a 1.5 compiler into class files which can be run on an older virtual machine. [GoTo RetroWeaver Home]

Retroweaver supports most 1.5 features while running on 1.4 including the following features.

• Generics
• Extended for loops
• Static imports
• Autoboxing/unboxing
• Varargs
• Enumerations
• Annotations

Image Source -  Canoo.com

Originally posted 2009-08-26 15:43:40.

In this tutorial, we will focus on doing the PO Box validation in an address using regular expressions in Java. The tutorial contains test cases for variations of the PO Box formats.

package com.kushal.tools;
/**
 * @author Kushal Pauduyal
 * Created on: 05/11/2011
 * Last Modified On: 05/11/2011
 * 
 * This class contains method and unit tests to validate the PO Box in an address.
 * The regular expression can validate several different variations of PO Boxes.
 * This should pretty much satisfy all international PO Box numbers, if not the 
 * pattern can be modified to satisfy one.
 */
import java.util.regex.Pattern;

public class RegexPOBoxValidation {

	/**
	 * Patterns are greatest things in Java. The following pattern can identify the Post Box
	 */
	static final String thePattern = 
"([\\w\\s*\\W]*(P(OST)?.?\\s*((O(FF(ICE)?)?)?.?\\s*(B(IN|OX|.?))|B(IN|OX))+))[\\w\\s*\\W]*";	
	
	/**
	 * 
	 * @param str - PO Box string to validate
	 * @return if the input string is a valid PO Box format.
	 */
	public static boolean isValid(String str) {
		return Pattern.matches(thePattern, str);
	}

	public static void main (String [] args ) {
		/**
		 * Doing unit test with several different PO Box usage alterations.
		 */
		String [] itemsToValidate = {
				"PO Box",
				"P O Box",
				"P. O. Box",
				"P.O.Box",
				"Post Box",
				"Post Office Box",
				"Post Office",
				"P.O.B",
				"P.O.B.",
				"POB",
				"Post Office Bin",
				"Box",
				"Bin",
				"Post",
				"Postal Code",
				"100,, P O Box Des Moines",
				" P O Box DesMoines1000",
				" P O Box Des Moines 1000",
				" Post Office Box",
				" Post Office Box  ",
				"Post Box #"};										 

		for (int index = 0; index < itemsToValidate.length; index++) {
			String item = itemsToValidate[index];
			boolean isValid = isValid(itemsToValidate[index].toUpperCase());
			System.out.println(item + " : " + (isValid ? "Valid" : "Invalid"));
		}
	}
			
}

Here is the output of this java program:

PO Box : Valid
P O Box : Valid
P. O. Box : Valid
P.O.Box : Valid
Post Box : Valid
Post Office Box : Valid
Post Office : Invalid
P.O.B : Valid
P.O.B. : Valid
POB : Valid
Post Office Bin : Valid
Box : Invalid
Bin : Invalid
Post : Invalid
Postal Code : Invalid
100,, P O Box Des Moines : Valid
 P O Box DesMoines1000 : Valid
 P O Box Des Moines 1000 : Valid
 Post Office Box : Valid
 Post Office Box   : Valid
Post Box # : Valid

Originally posted 2011-09-20 20:48:31.

• To print out the list and then use microsoft excel to compare the two columns.
• Upload the file to temporary database tables and the run SQL query to find out the difference

As I started encountering the list compare more often, I thought of writing a tool that takes two lists and then simply print out the differences. Thus I coded the following simple piece of java program to achieve this.

The following program:

• Can take an input of two ArrayLists presumably containing Strings, numbers of mix of both
• It then compares the two lists and then prints out all items from first list which are not in the second lists and also prints out the items in second lists which are not in the first list

I can now use this program as often as I want and solves the hassle of me having to upload the data to database for compare or even import to excel to do the same.

Most of the programs from my blog come from my real world working experience. They are simple programs but sometimes save your huge time. Feel free to copy and modify any of the programs for your own use. Everything is open sourced and free in my blog

package com.kushal.tools;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @author Kushal Paudyal Last Modified On 2011-09-16
 * 
 *         This simple utility compares two String or number lists or a list
 *         that contains either strings or number and then prints out a list of
 *         items that are in first list but not in the second list and also a
 *         list of items that are in second list but not in the first list.
 */
public class ListCompare {

	public static void main(String args[]) {
		List listA = new ArrayList();
		listA.add(1);
		listA.add(2);
		listA.add("Kushal");
		listA.add("Madan");
		listA.add("Pooja");
		listA.add("Kripa");

		List listB = new ArrayList();
		listB.add(2);
		listB.add(3);
		listB.add("Kushal");
		listB.add("Madan");
		listB.add("Jenny");
		listB.add("Betsy");

		ListCompare listComp = new ListCompare();
		listComp.compareLists(listA, listB);

	}

	public void compareLists(List firstList, List secondList) {
		Map mapForFirstList = new HashMap();
		Map mapForSecondList = new HashMap();
		Iterator firstListIterator = firstList.iterator();
		Iterator secondListIterator = secondList.iterator();
		while (firstListIterator.hasNext()) {
			String firstListKeyValue = firstListIterator.next().toString();
			/**
			 * Put the value from the list into the map, only if the same value
			 * already does not exists. That means if there are duplicates, we
			 * put only one instance into the hashmap.
			 */
			if (!mapForFirstList.containsKey(firstListKeyValue)) {
				mapForFirstList.put(firstListKeyValue, firstListKeyValue);
			}

		}

		while (secondListIterator.hasNext()) {
			String secondListKeyValue = secondListIterator.next().toString();
			/**
			 * Put the value from the list into the map, only if the same value
			 * already does not exists. That means if there are duplicates, we
			 * put only one instance into the hashmap.
			 */
			if (!mapForSecondList.containsKey(secondListKeyValue)) {
				mapForSecondList.put(secondListKeyValue, secondListKeyValue);
			}

		}
		compareAndPrintResults(mapForFirstList, mapForSecondList);

	}

	private void compareAndPrintResults(Map mapForFirstList,
			Map mapForSecondList) {
		/** Compare first map against the second one and print the difference **/
		printItemsFromFirstListThatAreNotOnSecondList(mapForFirstList,
				mapForSecondList);
		/** Compare second map against the first and print the difference */
		printItemsFromSecondListThatAreNotOnFirstList(mapForSecondList,
				mapForFirstList);

	}

	private void printItemsFromFirstListThatAreNotOnSecondList(Map mapA,
			Map mapB) {
		System.out
				.println("***Items from first list that are not in second list");
		doComparisionAndPrint(mapA, mapB);

	}

	private void printItemsFromSecondListThatAreNotOnFirstList(Map mapA,
			Map mapB) {
		System.out
				.println("***Items from second list that are not in firstList list");
		doComparisionAndPrint(mapA, mapB);

	}

	/**
	 * @param mapA
	 * @param mapB
	 * 
	 *            This method compares two hashmaps and prints out the values
	 *            from the first one that are not in the second one.
	 */
	private void doComparisionAndPrint(Map mapA, Map mapB) {
		// both maps should be non-empty for comparison.
		if (mapA != null && mapB != null) {
			Iterator mapAIterator = mapA.keySet().iterator();

			while (mapAIterator.hasNext()) {
				String key = mapAIterator.next().toString();
				if (!mapB.containsKey(key)) {
					System.out.println(key);
				}
			}
		}
	}
}

The following is the output of this program:

		***Items from first list that are not in second list
		1
		Kripa
		Pooja
		***Items from second list that are not in firstList list
		3
		Betsy
		Jenny

Originally posted 2011-09-16 19:15:11.

Two ints and a float are in a bar. They spot an attractive double on her own.

The first int walks up to her. “Hey, baby”, he says, “my VM or yours”. She slaps him and he walks back dejected.

The second int walks over. “Hey, cute-stuff, can I lick your Bean?”. After a quick slapping, he too walks back.

The float then ambles over casually. “Were those two primitive types bothering you?”, he remarks.

“Yes. I’m so glad you’re here”, she says. “They just had no Class!”

Here  goes the second one.

News Report: “A Java programmer in Silicon Valley was detained for questioning yesterday after an anonymous tip that he was using a Hashtable…”

Originally posted 2009-02-03 18:16:00.

1. No more setUp() and tearDown() methods.

The methods setUp() and tearDown() methods can now be replaced with annotations @Before and @After and you can name your method as you would like. In Junit 3.x, if you wanted to do initialization and clean up before and after each test run, you had to write methods with specific names as below:

Intialization:

public void setUp () {
   //Your Code Here

}

CleanUp:

public void tearDown() {
   //Your Code Here
}

You no longer need to follow the naming convention in Junit 4.x, as long as you use annotation tags @before to do initialization and @after to do clean up.

Intialization:

@before
public void myOwnInitializationMethod () {
   //Your Code Here

}

CleanUp:

@after
public void myOwnCleanupMethod() {
   //Your Code Here
}

2. You don’t need to name your method to start with the word test.

In Junit 3.x, the jUnit methods had to be specifically named. They needed to begin with the word test in order for JUnit to run that as a test case.

Junit 3.x:

public void testMyMethod() {
   //Your Code Here
}

JUnit 4.x:

@Test
public void myMethod() {
  //Your Code Here
}

3. You don’t need write your test class to extend junit.framework.TestCase

jUnit 3.x:

public class MyTestClass extends TestCase {
  // Your Methods Here

}

jUnit 4.x:

@TestClass
public class MyTestClass {
   //Your Methods Here
}

4. JUnit 4 adds ability to do one time setup and one time tear down.

If you wanted to do one time setup (intialization at the beginning of the class load) and one time tear down (cleaning up after all your test cases have been run), you can now do that with @BeforeClass and @AfterClass annotations.

@BeforeClass
public void mySomeMethod() {
//This method is run one time before any of your test cases are run.
}

@AfterClass
public void mySomeClenaUpMethod {
//This method is run one time after all your test cases have been run
}

5. JUnit 4 allows static import of the assert classes.

6. You can ingnore a test case with @Ignore annotation

@Ignore
public void doNotRunThisTest() {

}
1
<!--INFOLINKS_ON-->
<h2>7. Enforcing Timeout</h2>
You can time limit your test cases by providing timeout value. If the test case does not complete within that time, JUnit reports this as a failure.
<!--INFOLINKS_OFF-->
1
@Test(timeout=50)
public void runThisTestWithin50ms() {
}

8. JUnit Test Suite

Running Junits as a suite is now simpler. See the tutorial on running JUnit 4.0 test suite at:
http://sanjaal.com/java/tag/junit-test-suite-tutorial/

9. Expecting Exception:

Junit 4.x allows you to expect exceptions in your unit test. So, if you are expecting NullpointerException, here is what your code would look like:

@Test(expected=NullPointerException.class)
public void testMyMethodForNullPointer() {
 //Your piece of code that throws null pointer exception
}

10. Parameterized Testing:

With JUnit 4.x, you can run the same tests with multiple parameters using some annotations. To write parameterized testing, you can put class level annotation @RunWith(Parameterized.class) to tell JUnit to run parameterized testing. Then inside your class, you can use annotation @Parameters to tell JUnit a list of collections to use as parameters. The constructor will know how to initialize your parameters.

@RunWith(value=Parameterized.class)
public class ParameterizedTest {

   private String myFirstParam;
   private String mySecondParam;

   @Parameters
   public static Collection paramsValues {
       return Arrays.asList( new Object[][] {
                            { "1", "1" },
                            { "11", "11" },
                            { "12", "12" },
                            { "13", "13" },
                            { "16", "16" },
                            });
   }

   public ParameterizedTest(String paramOne, String paramTwo) {
       this.myFirstParam = paramOne;
       this.mySecondParam = paramTwo;
   }

   @Test
   public void testParams() {
       Assert.assertEquals(myFirstParam, mySecondParam);
   }
}

Originally posted 2013-01-17 17:30:55.

Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

• Extensibility Features
  An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

• Class Browsers and Visual Development Environments
  A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

• Debuggers and Test Tools
  Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

Drawbacks of Reflection
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

• Performance Overhead
  Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

• Security Restrictions
  Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

• Exposure of Internals
  Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

The following tutorial will use the class called Student and display all the methods of that class using the Java Reflection technology.

package com.kushal.utils;
/**
 * @Author Kushal Paudyal
 * www.sanjaal.com/java
 * Last Modified On 10th August 2009
 *
 * A Simple class that lists the method of another
 * class using the reflections mechanism.
 */
import java.lang.reflect.Method;

public class MethodsListViaReflection {

	public void listMethods() {

		Class myStudentClass = Student.class;

		Method[] methods = myStudentClass.getDeclaredMethods();

		for (Method method : methods) {
			System.out.println(method.getName());
		}
	}

	public static void main(String[] args) {
		new MethodsListViaReflection().listMethods();
	}
}

class Student {

private String _firstname;
private String _lastname;
private String _address;
private int _rollNumber;

public String getFirstname() {
return _firstname;
}

public void setFirstname(String firstname) {
_firstname = firstname;
}

public String getLastname() {
return _lastname;
}

public void setLastname(String lastname) {
_lastname = lastname;
}

public String getAddress() {
return _address;
}

public void setAddress(String address) {
_address = address;
}
public int getRollNumber() {
return _rollNumber;
}

public void setRollNumber(int rollNumber) {
_rollNumber= rollNumber;
}
}[/java]
=======================
The following is the output of this program:
getFirstname
setFirstname
getLastname
setLastname
getAddress
setAddress
getRollNumber
setRollNumber

Originally posted 2009-08-10 12:31:40.

Java Thread Life Cycle

Originally posted 2008-07-25 11:24:04.

• – How to define JAVA 2D Shape
• – How to define Gradient Paint
• – How to set Graphics paint
• – How to relocate the java 2D frame for redrawing
• – How to set the strokes in the Graphics
• – How to fill shapes with color or gradient

You will also be learning

• – How to center your GUI on the screen automatically.

package com.kushal.graphics;
/**
 * Java 2D Graphics Example Tutorial On Paint, Gradient and Stroke
 * @author Kushal Paudyal
 * www.sanjaal.com/java
 * Last Modified On 10th August 2009
 */

import java.awt.*;
import java.awt.geom.*;

import javax.swing.JFrame;

public class JavaPaintAndStroke extends JFrame {

	private static final long serialVersionUID = 7944800805864455013L;

	public static void main(String[] args) {
		JavaPaintAndStroke paintFrame = new JavaPaintAndStroke();
		paintFrame.setTitle("Sanjaal.com/java - GUI Tutorial");
		paintFrame.setSize(350, 200);
		paintFrame.setVisible(true);
		paintFrame.centerTheGUIFrame(paintFrame);

	}

	public void paint(Graphics g) {
		Graphics2D g2 = (Graphics2D) g;
		double x = 20, y = 60, w = 80, h = 80;
		/** Defining a rectangle and a gradient **/
		Rectangle2D r = new Rectangle2D.Double(x, y, w, h);
		GradientPaint gp = new GradientPaint(75, 75, Color.red, 95, 95,
				Color.green, true);

		/**
		 * Filling the rectangle with a gradient paint
		 */
		g2.setPaint(gp);
		g2.fill(r);

		/**
		 * Shifting the frame to the right by 100
		 * Then using Stroke With a Solid Color
		 *
		 * setFrame method below sets the location and size of
		 * the outer bounds of this Rectangle2D to the
		 * specified rectangular values.
		 *
		 * x, y locations
		 * w, h width and height of new Rectangle frame
		 */
		r.setFrame(x + 100, y, w, h);
		g2.setPaint(Color.red);
		g2.setStroke(new BasicStroke(8));
		g2.draw(r);

		/**
		 * Shifting the original rectangle frame to the right by 200
		 * Then using a Stroke With a Gradient Color
		 */
		r.setFrame(x + 200, y, w, h);
		g2.setPaint(gp);
		g2.draw(r);
	}

	/**
	 * This method is used to center the GUI
	 * @param frame - Frame that needs to be centered.
	 */
	public void centerTheGUIFrame(JFrame frame) {
		int widthWindow = frame.getWidth();
		int heightWindow = frame.getHeight();

		Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
		int X = (screen.width / 2) - (widthWindow / 2); // Center horizontally.
		int Y = (screen.height / 2) - (heightWindow / 2); // Center vertically.

		frame.setBounds(X, Y, widthWindow, heightWindow);

	}
}

==========================
The following is the output of this program.

Originally posted 2009-08-10 14:38:17.

• jcommon-1.0.15.jar
• jfreechart-1.0.12.jar

The program also demonstrates how easily you can save a generated chart to your computer using the Charts Utilities from JFreeChart

package com.kushal.utilities;

import java.io.File;
import java.io.IOException;
import java.util.Date;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart;
import org.jfree.data.time.Day;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;

public class TimeSeriesChartDemo {

	public void createTimeSeriesXYChart()
	{

		TimeSeries series = new TimeSeries( "", Day.class );

		series.add(new Day(new Date("2009/01/01")), 123);
		series.add(new Day(new Date("2009/01/02")), 133);
		series.add(new Day(new Date("2009/01/03")), 99);
		series.add(new Day(new Date("2009/01/04")), 113);
		series.add(new Day(new Date("2009/01/05")), 159);
		series.add(new Day(new Date("2009/01/06")), 124);
		series.add(new Day(new Date("2009/01/07")), 120);

        TimeSeriesCollection dataset=new TimeSeriesCollection();
        dataset.addSeries(series);

        JFreeChart chart = ChartFactory.createTimeSeriesChart
        ("User Participation Chart", 	// Title
         "Day",              		// X-Axis label
         "Number Of Users",             // Y-Axis label
         dataset,         		// Dataset
         true,                     	// Show legend
         true,				//tooltips
         false				//url
        );

        saveChart(chart);

	}

	public void saveChart(JFreeChart chart)
	{
		String fileName="C:/Users/kushal/Desktop/myTimeSeriesChart.jpg";
		try {
			/**
			 * This utility saves the JFreeChart as a JPEG
			 * First Parameter: FileName
			 * Second Parameter: Chart To Save
			 * Third Parameter: Height Of Picture
			 * Fourth Parameter: Width Of Picture
			 */
            ChartUtilities.saveChartAsJPEG(new File(fileName), chart, 800, 600);
        } catch (IOException e) {
        	e.printStackTrace();
            System.err.println("Problem occurred creating chart.");
        }
	}
	public static void main(String args [])
	{
		new TimeSeriesChartDemo().createTimeSeriesXYChart();

	}

}

The following is the output of this program

Originally posted 2009-01-24 18:22:49.