Validate IP Address

Usage of regular expression in Java to validate an IP address
Code:


private boolean
validateAnIpAddressWithRegularExpression(String iPaddress){
final Pattern IP_PATTERN =
Pattern.compile("b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).)"
+ "{3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)b");
return IP_PATTERN.matcher(iPaddress).matches();
}

Advertisements

Various date format conversions


import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class GeneralUtil {

//Date Time Util
public static Timestamp getTimeStamp(String date) throws ParseException {
String DATE_FORMAT = "MM-dd-yyyy";
SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
Date today = dateFormat.parse(date);
Timestamp t1 = new Timestamp(today.getTime());
return t1;
}

public static String getCurrentDateTime(String format) {
DateFormat dateFormat = new SimpleDateFormat(format);
Date date = new Date();
return dateFormat.format(date);
}

public static String getDateMMDDYYY(Timestamp timestamp) {
String dateStr = "";

dateStr = timestamp.toString().substring(0, 10);
return dateStr;
}

public static String getDateFromDBStringMMDDYYYY(String theDate) {
String strOutDt = "";
try {
Date dtTmp = new SimpleDateFormat("yyyy-MM-dd").parse(theDate);
strOutDt = new SimpleDateFormat("MM-dd-yyyy").format(dtTmp);
} catch (ParseException pe) {
}
return strOutDt;
}

// public static void main(String[] args) throws ParseException {
//
public static String getDateFromTimeStamp(Timestamp t) {
String result = "";
try {
Timestamp dateTime = (Timestamp) t;

SimpleDateFormat dateFormat = new SimpleDateFormat("MM-dd-yyyy");
result = dateFormat.format(dateTime);
return result;
} catch (Exception exception) {
}
return result;

}

public static String getDBDateFormat(String dateStr) {
String result = "";
try {
Date dtTmp = new SimpleDateFormat("MM-dd-yyyy").parse(dateStr);
result = new SimpleDateFormat("yyyy-MM-dd").format(dtTmp);
return result;
} catch (Exception exception) {
}
return result;

}

public static double roundTwoDecimals(double d) {
DecimalFormat twoDForm = new DecimalFormat("#.##");
return Double.valueOf(twoDForm.format(d));
}
//End Date Time Util

public static void main(String[] args) throws ParseException {
String str = "11-24-2010";

}
}

Date Format Example2


/*
Output:

on Tue Oct 01 00:00:00 PDT 2013 in Vancouver, B.C.
on Sun Mar 01 00:00:00 PST 1248 in Ottawa, ON
on Mon Jun 06 00:00:00 PST 1323 in Toronto, ON

*/

import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatDemo2 {

public static void main(String[] a) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
String input[] = { "2013-10-01 Vancouver, B.C.",
"1248-03-01 Ottawa, ON",
"1323-06-06 Toronto, ON" };
for (int i = 0; i < input.length; i++) {
ParsePosition pp = new ParsePosition(0);
Date d = formatter.parse(input[i], pp);
if (d == null) {
System.err.println("Invalid date in " + input[i]);
continue;
}
String location = input[i].substring(pp.getIndex());
System.out.println(" on " + d + " in " + location);

}
}
}

Date Format Example


import java.util.*;
import java.text.*;
class DateFormatDemo
{
public static void main(String A[])
{
//String dob="23/12/1998";
//String dob="DEC/23/1998";
String dob="1998-23-12";
//SimpleDateFormat sdf=new SimpleDateFormat("yyyy'/'dd'/'MM");
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
// Date d=null;
try{

Date d=sdf.parse(dob);//01/31/98
System.out.println("Formated Date="+d);
System.out.println("Formated Date="+sdf.format(d));
}
catch(ParseException pe)
{
System.out.println("Parse Exception Is"+pe);
}

}
}

How to validate IP address with regular expression

IP Address Regular Expression Pattern

^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.
([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$

Description:

^ #start of the line
( # start of group #1
[01]?\\d\\d? # Can be one or two digits. If three digits appear, it must start
either 0 or 1
# e.g ([0-9], [0-9][0-9],[0-1][0-9][0-9])
| # …or
2[0-4]\\d # start with 2, follow by 0-4 and end with any digit (2[0-4][0-9])
| # …or
25[0-5] # start with 2, follow by 5 and end with 0-5 (25[0-5])
) # end of group #2
\. # follow by a dot “.”

…. # repeat with 3 time (3x)
$ #end of the line

Whole combination means , digit from 0 to 255 and follow by a dot “.”, repeat 4 time and ending with no dot “.” Valid IP address format is “0-255.0-255.0-255.0-255″.
Java Regular Expression Example


package com.mkyong.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class IPAddressValidator{

private Pattern pattern;
private Matcher matcher;

private static final String IPADDRESS_PATTERN =
"^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
"([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";

public IPAddressValidator(){
pattern = Pattern.compile(IPADDRESS_PATTERN);
}

/**
* Validate ip address with regular expression
* @param ip ip address for validation
* @return true valid ip address, false invalid ip address
*/
public boolean validate(final String ip){
matcher = pattern.matcher(ip);
return matcher.matches();
}
}

IP address that match:

1. “1.1.1.1″, “255.255.255.255″,”192.168.1.1″ ,
2. “10.10.1.1″, “132.254.111.10″, “26.10.2.10″,
3. “127.0.0.1″

IP address that doesn’t match:

1. “10.10.10″ – must have 4 “.”
2. “10.10″ – must have 4 “.”
3. “10″ – must have 4 “.”
4. “a.a.a.a” – only digit is allow
5. “10.0.0.a” – only digit is allow
6. “10.10.10.256″ – digit must between [0-255]
7. “222.222.2.999″ – digit must between [0-255]
8. “999.10.10.20″ – digit must between [0-255]
9. “2222.22.22.22″ – digit must between [0-255]
10. “22.2222.22.2″ – digit must between [0-255]
Unit Test – IPAddressValidator


package com.mkyong.regex;

import org.testng.Assert;
import org.testng.annotations.*;

/**
* IPAddress validator Testing
* @author mkyong
*
*/
public class IPAddressValidatorTest {

private IPAddressValidator ipAddressValidator;

@BeforeClass
public void initData(){
ipAddressValidator = new IPAddressValidator();
}

@DataProvider
public Object[][] ValidIPAddressProvider() {
return new Object[][]{
new Object[] {"1.1.1.1"},new Object[] {"255.255.255.255"},
new Object[] {"192.168.1.1"},new Object[] {"10.10.1.1"},
new Object[] {"132.254.111.10"},new Object[] {"26.10.2.10"},
new Object[] {"127.0.0.1"}
};
}

@DataProvider
public Object[][] InvalidIPAddressProvider() {
return new Object[][]{
new Object[] {"10.10.10"},new Object[] {"10.10"},
new Object[] {"10"},new Object[] {"a.a.a.a"},
new Object[] {"10.0.0.a"},new Object[] {"10.10.10.256"},
new Object[] {"222.222.2.999"},new Object[] {"999.10.10.20"},
new Object[] {"2222.22.22.22"},new Object[] {"22.2222.22.2"},
new Object[] {"10.10.10"},new Object[] {"10.10.10"},
};
}

@Test(dataProvider = "ValidIPAddressProvider")
public void ValidIPAddressTest(String ip) {
boolean valid = ipAddressValidator.validate(ip);
System.out.println("IPAddress is valid : " + ip + " , " + valid);
Assert.assertEquals(true, valid);
}

@Test(dataProvider = "InvalidIPAddressProvider",
dependsOnMethods="ValidIPAddressTest")
public void InValidIPAddressTest(String ip) {
boolean valid = ipAddressValidator.validate(ip);
System.out.println("IPAddress is valid : " + ip + " , " + valid);
Assert.assertEquals(false, valid);
}
}

Unit Test – Result

IPAddress is valid : 1.1.1.1 , true
IPAddress is valid : 255.255.255.255 , true
IPAddress is valid : 192.168.1.1 , true
IPAddress is valid : 10.10.1.1 , true
IPAddress is valid : 132.254.111.10 , true
IPAddress is valid : 26.10.2.10 , true
IPAddress is valid : 127.0.0.1 , true
IPAddress is valid : 10.10.10 , false
IPAddress is valid : 10.10 , false
IPAddress is valid : 10 , false
IPAddress is valid : a.a.a.a , false
IPAddress is valid : 10.0.0.a , false
IPAddress is valid : 10.10.10.256 , false
IPAddress is valid : 222.222.2.999 , false
IPAddress is valid : 999.10.10.20 , false
IPAddress is valid : 2222.22.22.22 , false
IPAddress is valid : 22.2222.22.2 , false
PASSED: ValidIPAddressTest([Ljava.lang.String;@1d4c61c)
PASSED: InValidIPAddressTest([Ljava.lang.String;@116471f)

===============================================
com.mkyong.regex.IPAddressValidatorTest
Tests run: 2, Failures: 0, Skips: 0
===============================================

===============================================
mkyong
Total tests run: 2, Failures: 0, Skips: 0
===============================================

Reference

http://en.wikipedia.org/wiki/IP_address

Text Files Example

This example shows how to manipulate text files in Java. A file named “text.txt” is created and ten lines contaning the string “hello” are written to it. Then the function “readFile()” displays the content of the the created file to the screen


//TextFile.java
//manipulating text files
import java.io.*;
public class TextFile {
String fileName;
TextFile(String fn)
{
fileName = fn;
}
public void createFile()
{
}
public void writeToFile()
{
try{
PrintWriter out = new PrintWriter( new FileWriter( fileName ) );
for(int i = 0; i < 10; i++)
out.println("hello");
out.close();
}
catch(IOException ioe){
ioe.printStackTrace();
}
}
public void readFile()
{
System.out.println("Content of file: " + fileName);
try{
BufferedReader in = new BufferedReader(new FileReader( fileName ));
String line = "";
while((line = in.readLine()) != null)
System.out.println(line);
}
catch(IOException ioe){
ioe.printStackTrace();
}
}
public static void main ( String[] args )
{
TextFile txtFile = new TextFile("text.txt");
txtFile.writeToFile();
txtFile.readFile();
}
}

Extracting Integers from Strings

The following snippet of source code extracts a single digit from a String and converts it to an int. The String.charAt() method takes a zero-based index of the position of the character to be extracted from the String and the Character.digit() method takes the String from which to extract the digit and the radix.

In the example below I pass 0 to the charAt() method since I want the first character extracted and I pass 10 as the radix since I’m working in base 10.

String myString = "3blindmice";
int digit = Character.digit(myString.charAt(0), 10);
System.out.println("Digit: " + digit);

Output: 3

If the position passed to charAt is not a valid position within the String then a java.lang.StringIndexOutOfBoundsException is thrown.

If the radix is not between Character.MIN_RADIX and Character.MAX_RADIX, -1 is returned.