Regular Expression to validate the US zip codes

Here is a Regular Expression to validate the united states 5 and 9 digit zip codes:

^d{5}(-d{4})?$

Basic Validations:
• First five letters should be digits.
• It can be followed by a dash and optional 4 digits

Java Regular Expressions – Single World Replacement Example /Tutorial

This tutorial will show you a code that I wrote which does a single word replacement on a string using Pattern and Matcher. The example is straightforward. Please review the comments in the code below. I have placed useful comments at various statements in the code.

package com.kushal.regularexpressions;

/**
 * @author Kushal Paudyal
 * www.sanjaal.com/java
 * Last Modified On 2009-SEPT-16
 *
 * Using Regular Expressions To Replace
 * A Single Word From The String.
 */
import java.util.regex.*;

public class ReplaceSingleWord {
	static String originalString = "Google is Good. "
			+ "Google is Innovative. "
			+ "We think Google is the technology of the era";

	static String replaceWhat = "Google";

	static String replaceWith = "Sanjaal";

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

		System.out.println("...Before Replacement: n" + originalString + "n");

		/**
		 * Create a pattern to match Google.
		 * Pattern.compile () compiles the given regular
		 * expression into a pattern
		 */
		Pattern p = Pattern.compile(replaceWhat);

		// Create a matcher with an input string
		/**
		 * Creating a matcher with the original input string.
		 */
		Matcher m = p.matcher(originalString);

		StringBuffer sb = new StringBuffer();

		System.out.println("...Replacing '" + replaceWhat + "' with '"
				+ replaceWith + "'.n");

		/**
		 * Try to find the next subsequence of the input sequence
		 * which patches the pattern.
		 */
		boolean result = m.find();

		/**
		 * Looping through to create a new string
		 * with replacement applied.
		 */
		while (result) {
			m.appendReplacement(sb, replaceWith);
			result = m.find();
		}

		/**
		 * Add the last segment of input to the new String
		 *
		 * appendTail () method Implements a terminal append-and-replace step.
		 * This method reads characters from the input sequence,
		 * starting at the append position, and appends them to
		 * the given string buffer. It is intended to be invoked
		 * after one or more invocations of the appendReplacement
		 * appendReplacement method in order to copy the
		 * remainder of the input sequence.
		 * Parameters:
		 * sb --> The target string buffer
		 * Returns:
		 * The target string buffer
		 */
		m.appendTail(sb);
		System.out.println("...After Replacement:n" + sb.toString());
	}
}

====================

Output of this program:
…Before Replacement:
Google is Good. Google is Innovative. We think Google is the technology of the era

…Replacing ‘Google’ with ‘Sanjaal’.

…After Replacement:
Sanjaal is Good. Sanjaal is Innovative. We think Sanjaal is the technology of the era

How To Find Wild Cards In A String Using Regular Expressions?

This is how it began – our users started using wild cards (%%) sign in the search query. Since our legacy application had queries with like clause (apparently the original developers thought the end users are stupid jerks and would only key in the names). But there were smart users who knew about the wild card searches.

Our team came to a spotlight when a user used double wild cards in one of the search engines and brought the systems down !! Yes, it fetched millions of rows and the computations on those rows on a report led to JVM’s memory being depleted and the system crashed.

So how would you solve it instantly (I know it was just patching rather than redesign – but was important to bring the system up and was quick and cost effective solution). All we had to do was to see if the search fields had any wild cards in them. If they did, the search would not be performed and the user would be taken back to the search screen with some sort of errors.

In the following code, I have used the regular expressions to catch wild cards and the ones that enclose some text in between (alphanumeric and spaces to be exact). But you can always add more characters if you want.

package com.kushal.tools;
/**
 * @author Kushal Paudyal
 * WWW.icodejava.com
 * www.sanjaal.com/java
 * Finds if any wild cards (%%) are used in an String.
 * Wildcards can enclose digits or numbers or their combinations
 */
import java.util.regex.Pattern;

public class WildCardUsageFinderRegex {

    /**
     * Regular Expression to match the Wild Card Usage (% %) 
     * It tests for two % flags separated by N number of spaces or characters A-Z or a-z or 0-9. 
     * Can be modified to include other characters
     */
    private static final String WILD_CARD_EXPRESSION = "^%([ A-Za-z0-9])*%$";

    /**
     * Testing the validation with some sample wild cards
     */
    public static void main(String[] args) {

        String[] wildCards = { "% %", "%%", "%  ", "%dc%", "%123%" };

        int index = 0;
        boolean isMatch = false;
        while (index < wildCards.length) {
            isMatch = isWildCardUsed(wildCards[index]);
            System.out.println("String " + wildCards[index] + " - " + (isMatch ? "Valid" : "Invalid"));
            index++;
        }

    }

    /**
     * This method returns true if the parameter string contains a valid wild card
     */
    public static boolean isWildCardUsed(String string) {

        return Pattern.matches(WILD_CARD_EXPRESSION, string);
    }

}

If you run the program, you will find the following results.

String % % - Valid
String %% - Valid
String %   - Invalid
String %dc% - Valid
String %123% - Valid


You can use a simple solution like this to see if any fields have used wild cards.