A Java method is a collection of statements that are grouped together to perform an operation. When you call the System.out.println method, for example, the system actually executes several statements in order to display a message on the console.
Now you will learn how to create your own methods with or without return values, invoke a method with or without parameters, overload methods using the same names, and apply method abstraction in the program design.
- Creating Method:
Considering the following example to explain the syntax of a method:
-------------------------------------------------
public static int funcName(int a, int b) {
// body
}
------------------------------------------------
Here,
public static : modifier.
int: return type
funcName: function name
a, b: formal parameters
int a, int b: list of parameters
- Methods are also known as Procedures or Functions:
Procedures: They don't return any value.
Functions: They return value.
- Method definition consists of a method header and a method body.
The same is shown below:
modifier returnType nameOfMethod (Parameter List) {
// method body
}
The syntax shown above includes:
+ modifier: It defines the access type of the method and it is optional to use.
+ returnType: Method may return a value.
+ nameOfMethod: This is the method name. The method signature consists of the method name and the parameter list.
+ Parameter List: The list of parameters, it is the type, order, and number of parameters of a method. These are optional, method may contain zero parameters.
+ method body: The method body defines what the method does with statements.
Example:
Here is the source code of the above defined method called max(). This method takes two parameters num1 and num2 and returns the maximum between the two:
--------------------------------------------------
/** the snippet returns the minimum between two numbers */
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
--------------------------------------------------
- Method Calling:
For using a method, it should be called. There are two ways in which a method is called i.e. method returns a value or returning nothing (no return value).
The process of method calling is simple. When a program invokes a method, the program control gets transferred to the called method. This called method then returns control to the caller in two conditions, when:
return statement is executed.
reaches the method ending closing brace.
- The methods returning void is considered as call to a statement. Lets consider an example:
System.out.println("This is tutorialspoint.com!");
The method returning value can be understood by the following example:
int result = sum(6, 9);
Example:
Following is the example to demonstrate how to define a method and how to call it:
--------------------------------------------------
public class ExampleMinNumber{
public static void main(String[] args) {
int a = 11;
int b = 6;
int c = minFunction(a, b);
System.out.println("Minimum Value = " + c);
}
/** returns the minimum of two numbers */
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
}
-------------------------------------------
This would produce the following result:
Minimum value = 6
- The void Keyword:
The void keyword allows us to create methods which do not return a value. Here, in the following example we're considering a void method methodRankPoints. This method is a void method which does not return any value. Call to a void method must be a statement i.e. methodRankPoints(255.7);. It is a Java statement which ends with a semicolon as shown below.
Example:
----------------------------------------
public class ExampleVoid {
public static void main(String[] args) {
methodRankPoints(255.7);
}
public static void methodRankPoints(double points) {
if (points >= 202.5) {
System.out.println("Rank:A1");
}
else if (points >= 122.4) {
System.out.println("Rank:A2");
}
else {
System.out.println("Rank:A3");
}
}
}
-------------------------------------------
This would produce the following result:
Rank:A1
- Passing Parameters by Value:
While working under calling process, arguments is to be passed. These should be in the same order as their respective parameters in the method specification. Parameters can be passed by value or by reference.
Passing Parameters by Value means calling a method with a parameter. Through this the argument value is passed to the parameter.
Example:
The following program shows an example of passing parameter by value. The values of the arguments remains the same even after the method invocation.
----------------------------------------------
public class swappingExample {
public static void main(String[] args) {
int a = 30;
int b = 45;
System.out.println("Before swapping, a = " +
a + " and b = " + b);
// Invoke the swap method
swapFunction(a, b);
System.out.println("\n**Now, Before and After swapping values will be same here**:");
System.out.println("After swapping, a = " +
a + " and b is " + b);
}
public static void swapFunction(int a, int b) {
System.out.println("Before swapping(Inside), a = " + a
+ " b = " + b);
// Swap n1 with n2
int c = a;
a = b;
b = c;
System.out.println("After swapping(Inside), a = " + a
+ " b = " + b);
}
}
------------------------------------------------
This would produce the following result:
Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30
**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45
- Method Overloading:
When a class has two or more methods by same name but different parameters, it is known as method overloading. It is different from overriding. In overriding a method has same method name, type, number of parameters etc.
Lets consider the example shown before for finding minimum numbers of integer type. If, lets say we want to find minimum number of double type. Then the concept of Overloading will be introduced to create two or more methods with the same name but different parameters.
The below example explains the same:
----------------------------------------------------
public class ExampleOverloading{
public static void main(String[] args) {
int a = 11;
int b = 6;
double c = 7.3;
double d = 9.4;
int result1 = minFunction(a, b);
// same function name with different parameters
double result2 = minFunction(c, d);
System.out.println("Minimum Value = " + result1);
System.out.println("Minimum Value = " + result2);
}
// for integer
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
// for double
public static double minFunction(double n1, double n2) {
double min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
}
------------------------------------
This would produce the following result:
Minimum Value = 6
Minimum Value = 7.3
- Overloading methods makes program readable. Here, two methods are given same name but with different parameters. The minimum number from integer and double types is the result.
- Using Command-Line Arguments:
Sometimes you will want to pass information into a program when you run it. This is accomplished by passing command-line arguments to main( ).
A command-line argument is the information that directly follows the program's name on the command line when it is executed. To access the command-line arguments inside a Java program is quite easy.they are stored as strings in the String array passed to main( ).
Example:
The following program displays all of the command-line arguments that it is called with:
------------------------------------------------
public class CommandLine {
public static void main(String args[]){
for(int i=0; i<args.length; i++){
System.out.println("args[" + i + "]: " +
args[i]);
}
}
}
-------------------------------------------------
Try executing this program as shown here:
java CommandLine this is a command line 200 -100
This would produce the following result:
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100
- The Constructors:
A constructor initializes an object when it is created. It has the same name as its class and is syntactically similar to a method. However, constructors have no explicit return type.
Typically, you will use a constructor to give initial values to the instance variables defined by the class, or to perform any other startup procedures required to create a fully formed object.
All classes have constructors, whether you define one or not, because Java automatically provides a default constructor that initializes all member variables to zero. However, once you define your own constructor, the default constructor is no longer used.
Example:
Here is a simple example that uses a constructor:
----------------------------------------
// A simple constructor.
class MyClass {
int x;
// Following is the constructor
MyClass() {
x = 10;
}
}
------------------------------------------
You would call constructor to initialize objects as follows:
------------------------------------------
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.x + " " + t2.x);
}
}
---------------------------------------------
Most often, you will need a constructor that accepts one or more parameters. Parameters are added to a constructor in the same way that they are added to a method, just declare them inside the parentheses after the constructor's name.
Example:
Here is a simple example that uses a constructor:
---------------------------------------------
// A simple constructor.
class MyClass {
int x;
// Following is the constructor
MyClass(int i ) {
x = i;
}
}
-----------------------------------------------
You would call constructor to initialize objects as follows:
-----------------------------------------------
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass( 10 );
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + " " + t2.x);
}
}
----------------------------------------------------
This would produce the following result:
10 20
- Variable Arguments(var-args):
JDK 1.5 enables you to pass a variable number of arguments of the same type to a method. The parameter in the method is declared as follows:
typeName... parameterName
In the method declaration, you specify the type followed by an ellipsis (...) Only one variable-length parameter may be specified in a method, and this parameter must be the last parameter. Any regular parameters must precede it.
Example:
------------------------------------------
public class VarargsDemo {
public static void main(String args[]) {
// Call method with variable args
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++)
if (numbers[i] > result)
result = numbers[i];
System.out.println("The max value is " + result);
}
}
-----------------------------------------
This would produce the following result:
The max value is 56.5
The max value is 3.0
- The finalize( ) Method:
It is possible to define a method that will be called just before an object's final destruction by the garbage collector. This method is called finalize( ), and it can be used to ensure that an object terminates cleanly.
For example, you might use finalize( ) to make sure that an open file owned by that object is closed.
To add a finalizer to a class, you simply define the finalize( ) method. The Java runtime calls that method whenever it is about to recycle an object of that class.
Inside the finalize( ) method, you will specify those actions that must be performed before an object is destroyed.
The finalize( ) method has this general form:
-----------------------------------
protected void finalize( )
{
// finalization code here
}
------------------------------------
Here, the keyword protected is a specifier that prevents access to finalize( ) by code defined outside its class.
This means that you cannot know when or even if finalize( ) will be executed. For example, if your program ends before garbage collection occurs, finalize( ) will not execute.
Monday, May 26, 2014
[Java core 15] Methods
Thursday, May 22, 2014
[Java core 14] Regular expressions
Java provides the java.util.regex package for pattern matching with regular expressions. Java regular expressions are very similar to the Perl programming language and very easy to learn.
A regular expression is a special sequence of characters that helps you match or find other strings or sets of strings, using a specialized syntax held in a pattern. They can be used to search, edit, or manipulate text and data.
The java.util.regex package primarily consists of the following three classes:
- Pattern Class: A Pattern object is a compiled representation of a regular expression. The Pattern class provides no public constructors. To create a pattern, you must first invoke one of its public static compile methods, which will then return a Pattern object. These methods accept a regular expression as the first argument.
- Matcher Class: A Matcher object is the engine that interprets the pattern and performs match operations against an input string. Like the Pattern class, Matcher defines no public constructors. You obtain a Matcher object by invoking the matcher method on a Pattern object.
- PatternSyntaxException: A PatternSyntaxException object is an unchecked exception that indicates a syntax error in a regular expression pattern.
- Capturing Groups:
Capturing groups are a way to treat multiple characters as a single unit. They are created by placing the characters to be grouped inside a set of parentheses. For example, the regular expression (dog) creates a single group containing the letters "d", "o", and "g".
Capturing groups are numbered by counting their opening parentheses from left to right. In the expression ((A)(B(C))), for example, there are four such groups:
((A)(B(C)))
(A)
(B(C))
(C)
To find out how many groups are present in the expression, call the groupCount method on a matcher object. The groupCount method returns an int showing the number of capturing groups present in the matcher's pattern.
There is also a special group, group 0, which always represents the entire expression. This group is not included in the total reported by groupCount.
Example:
Following example illustrates how to find a digit string from the given alphanumeric string:
----------------------------------------
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
public static void main( String args[] ){
// String to be scanned to find the pattern.
String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\\d+)(.*)";
// Create a Pattern object
Pattern r = Pattern.compile(pattern);
// Now create matcher object.
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
} else {
System.out.println("NO MATCH");
}
}
}
-----------------------------------------
This would produce the following result:
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0
- Regular Expression Syntax:
Here is the table listing down all the regular expression metacharacter syntax available in Java:
Subexpression Matches
^ Matches beginning of line.
$ Matches end of line.
. Matches any single character except newline. Using m option allows it to match newline as well.
[...] Matches any single character in brackets.
[^...] Matches any single character not in brackets
\A Beginning of entire string
\z End of entire string
\Z End of entire string except allowable final line terminator.
re* Matches 0 or more occurrences of preceding expression.
re+ Matches 1 or more of the previous thing
re? Matches 0 or 1 occurrence of preceding expression.
re{ n} Matches exactly n number of occurrences of preceding expression.
re{ n,} Matches n or more occurrences of preceding expression.
re{ n, m} Matches at least n and at most m occurrences of preceding expression.
a| b Matches either a or b.
(re) Groups regular expressions and remembers matched text.
(?: re) Groups regular expressions without remembering matched text.
(?> re) Matches independent pattern without backtracking.
\w Matches word characters.
\W Matches nonword characters.
\s Matches whitespace. Equivalent to [\t\n\r\f].
\S Matches nonwhitespace.
\d Matches digits. Equivalent to [0-9].
\D Matches nondigits.
\A Matches beginning of string.
\Z Matches end of string. If a newline exists, it matches just before newline.
\z Matches end of string.
\G Matches point where last match finished.
\n Back-reference to capture group number "n"
\b Matches word boundaries when outside brackets. Matches backspace (0x08) when inside brackets.
\B Matches nonword boundaries.
\n, \t, etc. Matches newlines, carriage returns, tabs, etc.
\Q Escape (quote) all characters up to \E
\E Ends quoting begun with \Q
- Methods of the Matcher Class:
Here is a list of useful instance methods:
- Index Methods:
Index methods provide useful index values that show precisely where the match was found in the input string:
SN Methods with Description
1 - public int start() Returns the start index of the previous match.
2 - public int start(int group) Returns the start index of the subsequence captured by the given group during the previous match operation.
3 - public int end() Returns the offset after the last character matched.
4 - public int end(int group) Returns the offset after the last character of the subsequence captured by the given group during the previous match operation.
- Study Methods:
Study methods review the input string and return a Boolean indicating whether or not the pattern is found:
SN Methods with Description
1 - public boolean lookingAt() Attempts to match the input sequence, starting at the beginning of the region, against the pattern.
2 - public boolean find() Attempts to find the next subsequence of the input sequence that matches the pattern.
3 - public boolean find(int start Resets this matcher and then attempts to find the next subsequence of the input sequence that matches the pattern, starting at the
specified index.
4 - public boolean matches() Attempts to match the entire region against the pattern.
- Replacement Methods:
Replacement methods are useful methods for replacing text in an input string:
SN Methods with Description
1 - public Matcher appendReplacement(StringBuffer sb, String replacement) Implements a non-terminal append-and-replace step.
2 - public StringBuffer appendTail(StringBuffer sb) Implements a terminal append-and-replace step.
3 - public String replaceAll(String replacement) Replaces every subsequence of the input sequence that matches the pattern with the given replacement string.
4 - public String replaceFirst(String replacement) Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string.
5 - public static String quoteReplacement(String s) Returns a literal replacement String for the specified String. This method produces a String that will work as a literal replacement s in the appendReplacement method of the Matcher class.
- The start and end Methods:
Following is the example that counts the number of times the word "cats" appears in the input string:
----------------------------------------------
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "\\bcat\\b";
private static final String INPUT =
"cat cat cat cattie cat";
public static void main( String args[] ){
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // get a matcher object
int count = 0;
while(m.find()) {
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}
-------------------------------------------
This would produce the following result:
Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22
You can see that this example uses word boundaries to ensure that the letters "c" "a" "t" are not merely a substring in a longer word. It also gives some useful information about where in the input string the match has occurred.
The start method returns the start index of the subsequence captured by the given group during the previous match operation, and end returns the index of the last character matched, plus one.
- The matches and lookingAt Methods:
The matches and lookingAt methods both attempt to match an input sequence against a pattern. The difference, however, is that matches requires the entire input sequence to be matched, while lookingAt does not.
Both methods always start at the beginning of the input string. Here is the example explaining the functionality:
---------------------------------------------
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
private static Pattern pattern;
private static Matcher matcher;
public static void main( String args[] ){
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);
System.out.println("Current REGEX is: "+REGEX);
System.out.println("Current INPUT is: "+INPUT);
System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}
----------------------------------------------------
This would produce the following result:
Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false
- The replaceFirst and replaceAll Methods:
The replaceFirst and replaceAll methods replace text that matches a given regular expression. As their names indicate, replaceFirst replaces the first occurrence, and replaceAll replaces all occurrences.
Here is the example explaining the functionality:
----------------------------------------------
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " +
"All dogs say meow.";
private static String REPLACE = "cat";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}
--------------------------------------------------------
This would produce the following result:
The cat says meow. All cats say meow.
- The appendReplacement and appendTail Methods:
The Matcher class also provides appendReplacement and appendTail methods for text replacement.
Here is the example explaining the functionality:
---------------------------------------------------
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoob";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
-------------------------------------------------------
This would produce the following result:
-foo-foo-foo-
- PatternSyntaxException Class Methods:
A PatternSyntaxException is an unchecked exception that indicates a syntax error in a regular expression pattern. The PatternSyntaxException class provides the following methods to help you determine what went wrong:
SN Methods with Description
1 - public String getDescription() Retrieves the description of the error.
2 - public int getIndex() Retrieves the error index.
3 - public String getPattern() Retrieves the erroneous regular expression pattern.
4 - public String getMessage() Returns a multi-line string containing the description of the syntax error and its index, the erroneous regular expression pattern, and a visual indication of the error index within the pattern.
Wednesday, May 21, 2014
[Java core 13] Date and time
Java provides the Date class available in java.util package, this class encapsulates the current date and time.
The Date class supports two constructors. The first constructor initializes the object with the current date and time.
Date( )
The following constructor accepts one argument that equals the number of milliseconds that have elapsed since midnight, January 1, 1970
Date(long millisec)
Once you have a Date object available, you can call any of the following support methods to play with dates:
1- boolean after(Date date): Returns true if the invoking Date object contains a date that is later than the one specified by date, otherwise, it returns false.
2 - boolean before(Date date): Returns true if the invoking Date object contains a date that is earlier than the one specified by date, otherwise, it returns false.
3 - Object clone( ): Duplicates the invoking Date object.
4 - int compareTo(Date date): Compares the value of the invoking object with that of date. Returns 0 if the values are equal. Returns a negative value if the invoking object is earlier than date. Returns a positive value if the invoking object is later than date.
5 - int compareTo(Object obj): Operates identically to compareTo(Date) if obj is of class Date. Otherwise, it throws a ClassCastException.
6 - boolean equals(Object date): Returns true if the invoking Date object contains the same time and date as the one specified by date, otherwise, it returns false.
7 - long getTime( ): Returns the number of milliseconds that have elapsed since January 1, 1970.
8 - int hashCode( ): Returns a hash code for the invoking object.
9 - void setTime(long time): Sets the time and date as specified by time, which represents an elapsed time in milliseconds from midnight, January 1, 1970
10 - String toString( ): Converts the invoking Date object into a string and returns the result.
Getting Current Date & Time
This is very easy to get current date and time in Java. You can use a simple Date object with toString() method to print current date and time as follows:
-----------------------------------------
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// Instantiate a Date object
Date date = new Date();
// display time and date using toString()
System.out.println(date.toString());
}
}
------------------------------------------
This would produce the following result:
Mon May 04 09:51:52 CDT 2009
Date Comparison:
- There are following three ways to compare two dates:
You can use getTime( ) to obtain the number of milliseconds that have elapsed since midnight, January 1, 1970, for both objects and then compare these two values.
You can use the methods before( ), after( ), and equals( ). Because the 12th of the month comes before the 18th, for example, new Date(99, 2, 12).before(new Date (99, 2, 18)) returns true.
You can use the compareTo( ) method, which is defined by the Comparable interface and implemented by Date.
- Date Formatting using SimpleDateFormat:
SimpleDateFormat is a concrete class for formatting and parsing dates in a locale-sensitive manner. SimpleDateFormat allows you to start by choosing any user-defined patterns for date-time formatting. For example:
-----------------------------------------
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String args[]) {
Date dNow = new Date( );
SimpleDateFormat ft =
new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
System.out.println("Current Date: " + ft.format(dNow));
}
}
--------------------------------------------
This would produce the following result:
Current Date: Sun 2004.07.18 at 04:14:09 PM PDT
Simple DateFormat format codes:
To specify the time format, use a time pattern string. In this pattern, all ASCII letters are reserved as pattern letters, which are defined as the following:
Character Description Example
G Era designator AD
y Year in four digits 2001
M Month in year July or 07
d Day in month 10
h Hour in A.M./P.M. (1~12) 12
H Hour in day (0~23) 22
m Minute in hour 30
s Second in minute 55
S Millisecond 234
E Day in week Tuesday
D Day in year 360
F Day of week in month 2 (second Wed. in July)
w Week in year 40
W Week in month 1
a A.M./P.M. marker PM
k Hour in day (1~24) 24
K Hour in A.M./P.M. (0~11) 10
z Time zone Eastern Standard Time
'
Escape for text Delimiter
" Single quote `
Date Formatting using printf:
Date and time formatting can be done very easily using printf method. You use a two-letter format, starting with t and ending in one of the letters of the table given below. For example:
------------------------------------------
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// Instantiate a Date object
Date date = new Date();
// display time and date using toString()
String str = String.format("Current Date/Time : %tc", date );
System.out.printf(str);
}
}
--------------------------------------------
This would produce the following result:
Current Date/Time : Sat Dec 15 16:37:57 MST 2012
It would be a bit silly if you had to supply the date multiple times to format each part. For that reason, a format string can indicate the index of the argument to be formatted.
The index must immediately follow the % and it must be terminated by a $. For example:
------------------------------------------
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// Instantiate a Date object
Date date = new Date();
// display time and date using toString()
System.out.printf("%1$s %2$tB %2$td, %2$tY",
"Due date:", date);
}
}
---------------------------------------------
This would produce the following result:
Due date: February 09, 2004
Alternatively, you can use the < flag. It indicates that the same argument as in the preceding format specification should be used again. For example:
--------------------------------------------
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// Instantiate a Date object
Date date = new Date();
// display formatted date
System.out.printf("%s %tB %<te, %<tY",
"Due date:", date);
}
}
-------------------------------------------------
This would produce the following result:
Due date: February 09, 2004
Date and Time Conversion Characters:
Character Description Example
c Complete date and time Mon May 04 09:51:52 CDT 2009
F ISO 8601 date 2004-02-09
D U.S. formatted date (month/day/year) 02/09/2004
T 24-hour time 18:05:19
r 12-hour time 06:05:19 pm
R 24-hour time, no seconds 18:05
Y Four-digit year (with leading zeroes) 2004
y Last two digits of the year (with leading zeroes) 04
C First two digits of the year (with leading zeroes) 20
B Full month name February
b Abbreviated month name Feb
m Two-digit month (with leading zeroes) 02
d Two-digit day (with leading zeroes) 03
e Two-digit day (without leading zeroes) 9
A Full weekday name Monday
a Abbreviated weekday name Mon
j Three-digit day of year (with leading zeroes) 069
H Two-digit hour (with leading zeroes), between 00 and 23 18
k Two-digit hour (without leading zeroes), between 0 and 23 18
I Two-digit hour (with leading zeroes), between 01 and 12 06
l Two-digit hour (without leading zeroes), between 1 and 12 6
M Two-digit minutes (with leading zeroes) 05
S Two-digit seconds (with leading zeroes) 19
L Three-digit milliseconds (with leading zeroes) 047
N Nine-digit nanoseconds (with leading zeroes) 047000000
P Uppercase morning or afternoon marker PM
p Lowercase morning or afternoon marker pm
z RFC 822 numeric offset from GMT -0800
Z Time zone PST
s Seconds since 1970-01-01 00:00:00 GMT 1078884319
Q Milliseconds since 1970-01-01 00:00:00 GMT 1078884319047
There are other useful classes related to Date and time. For more details, you can refer to Java Standard documentation.
Parsing Strings into Dates:
The SimpleDateFormat class has some additional methods, notably parse( ) , which tries to parse a string according to the format stored in the given SimpleDateFormat object. For example:
-----------------------------------
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String args[]) {
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
String input = args.length == 0 ? "1818-11-11" : args[0];
System.out.print(input + " Parses as ");
Date t;
try {
t = ft.parse(input);
System.out.println(t);
} catch (ParseException e) {
System.out.println("Unparseable using " + ft);
}
}
}
-----------------------------------------------
A sample run of the above program would produce the following result:
$ java DateDemo
1818-11-11 Parses as Wed Nov 11 00:00:00 GMT 1818
$ java DateDemo 2007-12-01
2007-12-01 Parses as Sat Dec 01 00:00:00 GMT 2007
Sleeping for a While:
You can sleep for any period of time from one millisecond up to the lifetime of your computer. For example, following program would sleep for 10 seconds:
------------------------------------
import java.util.*;
public class SleepDemo {
public static void main(String args[]) {
try {
System.out.println(new Date( ) + "\n");
Thread.sleep(5*60*10);
System.out.println(new Date( ) + "\n");
} catch (Exception e) {
System.out.println("Got an exception!");
}
}
}
---------------------------------------
This would produce the following result:
Sun May 03 18:04:41 GMT 2009
Sun May 03 18:04:51 GMT 2009
Measuring Elapsed Time:
Sometimes, you may need to measure point in time in milliseconds. So let's re-write above example once again:
---------------------------------------------------------
import java.util.*;
public class DiffDemo {
public static void main(String args[]) {
try {
long start = System.currentTimeMillis( );
System.out.println(new Date( ) + "\n");
Thread.sleep(5*60*10);
System.out.println(new Date( ) + "\n");
long end = System.currentTimeMillis( );
long diff = end - start;
System.out.println("Difference is : " + diff);
} catch (Exception e) {
System.out.println("Got an exception!");
}
}
}
--------------------------------------------------------
This would produce the following result:
Sun May 03 18:16:51 GMT 2009
Sun May 03 18:16:57 GMT 2009
Difference is : 5993
GregorianCalendar Class:
GregorianCalendar is a concrete implementation of a Calendar class that implements the normal Gregorian calendar with which you are familiar. I did not discuss Calendar class in this tutorial, you can look standard Java documentation for this.
The getInstance( ) method of Calendar returns a GregorianCalendar initialized with the current date and time in the default locale and time zone. GregorianCalendar defines two fields: AD and BC. These represent the two eras defined by the Gregorian calendar.
There are also several constructors for GregorianCalendar objects:
1 - GregorianCalendar(): Constructs a default GregorianCalendar using the current time in the default time zone with the default locale.
2 - GregorianCalendar(int year, int month, int date): Constructs a GregorianCalendar with the given date set in the default time zone with the default locale.
3 - GregorianCalendar(int year, int month, int date, int hour, int minute): Constructs a GregorianCalendar with the given date and time set for the default time zone with the default locale.
4 - GregorianCalendar(int year, int month, int date, int hour, int minute, int second): Constructs a GregorianCalendar with the given date and time set for the default time zone with the default locale.
5 - GregorianCalendar(Locale aLocale): Constructs a GregorianCalendar based on the current time in the default time zone with the given locale.
6 - GregorianCalendar(TimeZone zone): Constructs a GregorianCalendar based on the current time in the given time zone with the default locale.
7 - GregorianCalendar(TimeZone zone, Locale aLocale): Constructs a GregorianCalendar based on the current time in the given time zone with the given locale.
Here is the list of few useful support methods provided by GregorianCalendar class:
1 - void add(int field, int amount): Adds the specified (signed) amount of time to the given time field, based on the calendar's rules.
2 - protected void computeFields(): Converts UTC as milliseconds to time field values.
3 - protected void computeTime(): Overrides Calendar Converts time field values to UTC as milliseconds.
4 - boolean equals(Object obj): Compares this GregorianCalendar to an object reference.
5 - int get(int field): Gets the value for a given time field.
6 - int getActualMaximum(int field): Return the maximum value that this field could have, given the current date.
7 - int getActualMinimum(int field): Return the minimum value that this field could have, given the current date.
8 - int getGreatestMinimum(int field): Returns highest minimum value for the given field if varies.
9 - Date getGregorianChange(): Gets the Gregorian Calendar change date.
10 - int getLeastMaximum(int field): Returns lowest maximum value for the given field if varies.
11 - int getMaximum(int field): Returns maximum value for the given field.
12 - Date getTime(): Gets this Calendar's current time.
13 - long getTimeInMillis(): Gets this Calendar's current time as a long.
14 - TimeZone getTimeZone(): Gets the time zone.
15 - int getMinimum(int field): Returns minimum value for the given field.
16 - int hashCode(): Override hashCode.
17 - boolean isLeapYear(int year): Determines if the given year is a leap year.
18 - void roll(int field, boolean up): Adds or subtracts (up/down) a single unit of time on the given time field without changing larger fields.
19 - void set(int field, int value): Sets the time field with the given value.
20 - void set(int year, int month, int date): Sets the values for the fields year, month, and date.
21 - void set(int year, int month, int date, int hour, int minute): Sets the values for the fields year, month, date, hour, and minute.
22 - void set(int year, int month, int date, int hour, int minute, int second): Sets the values for the fields year, month, date, hour, minute, and second.
23 - void setGregorianChange(Date date): Sets the GregorianCalendar change date.
24 - void setTime(Date date): Sets this Calendar's current time with the given Date.
25 - void setTimeInMillis(long millis): Sets this Calendar's current time from the given long value.
26 - void setTimeZone(TimeZone value): Sets the time zone with the given time zone value.
27 - String toString(): Return a string representation of this calendar.
Example:
--------------------------------------
import java.util.*;
public class GregorianCalendarDemo {
public static void main(String args[]) {
String months[] = {
"Jan", "Feb", "Mar", "Apr",
"May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"};
int year;
// Create a Gregorian calendar initialized
// with the current date and time in the
// default locale and timezone.
GregorianCalendar gcalendar = new GregorianCalendar();
// Display current time and date information.
System.out.print("Date: ");
System.out.print(months[gcalendar.get(Calendar.MONTH)]);
System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
System.out.println(year = gcalendar.get(Calendar.YEAR));
System.out.print("Time: ");
System.out.print(gcalendar.get(Calendar.HOUR) + ":");
System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
System.out.println(gcalendar.get(Calendar.SECOND));
// Test if the current year is a leap year
if(gcalendar.isLeapYear(year)) {
System.out.println("The current year is a leap year");
}
else {
System.out.println("The current year is not a leap year");
}
}
}
---------------------------------------------------
This would produce the following result:
Date: Apr 22 2009
Time: 11:25:27
The current year is not a leap year
For a complete list of constant available in Calendar class, you can refer to standard Java documentation.
Monday, May 19, 2014
[Java core 12] Arrays
Java provides a data structure, the array, which stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.
Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables.
This tutorial introduces how to declare array variables, create arrays, and process arrays using indexed variables.
1 - Declaring Array Variables:
To use an array in a program, you must declare a variable to reference the array, and you must specify the type of array the variable can reference. Here is the syntax for declaring an array variable:
dataType[] arrayRefVar; // preferred way.
or
dataType arrayRefVar[]; // works but not preferred way.
Note: The style dataType[] arrayRefVar is preferred. The style dataType arrayRefVar[] comes from the C/C++ language and was adopted in Java to accommodate C/C++ programmers.
Example:
The following code snippets are examples of this syntax:
double[] myList; // preferred way.
or
double myList[]; // works but not preferred way.
2 - Creating Arrays:
You can create an array by using the new operator with the following syntax:
arrayRefVar = new dataType[arraySize];
- The above statement does two things:
It creates an array using new dataType[arraySize];
It assigns the reference of the newly created array to the variable arrayRefVar.
- Declaring an array variable, creating an array, and assigning the reference of the array to the variable can be combined in one statement, as shown below:
dataType[] arrayRefVar = new dataType[arraySize];
- Alternatively you can create arrays as follows:
dataType[] arrayRefVar = {value0, value1, ..., valuek};
The array elements are accessed through the index. Array indices are 0-based; that is, they start from 0 to arrayRefVar.length-1.
Example:
Following statement declares an array variable, myList, creates an array of 10 elements of double type and assigns its reference to myList:
double[] myList = new double[10];
Following picture represents array myList. Here, myList holds ten double values and the indices are from 0 to 9.
3 - Processing Arrays:
When processing array elements, we often use either for loop or foreach loop because all of the elements in an array are of the same type and the size of the array is known.
Example:
Here is a complete example of showing how to create, initialize and process arrays:
--------------------------------------------------
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// Summing all elements
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// Finding the largest element
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}
----------------------------------------------------
This would produce the following result:
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
4 - The foreach Loops:
JDK 1.5 introduced a new for loop known as foreach loop or enhanced for loop, which enables you to traverse the complete array sequentially without using an index variable.
Example:
The following code displays all the elements in the array myList:
-----------------------------------------
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (double element: myList) {
System.out.println(element);
}
}
}
------------------------------------------
This would produce the following result:
1.9
2.9
3.4
3.5
5 - Passing Arrays to Methods:
Just as you can pass primitive type values to methods, you can also pass arrays to methods. For example, the following method displays the elements in an int array:
-------------------------------------------
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
-------------------------------------------
You can invoke it by passing an array. For example, the following statement invokes the printArray method to display 3, 1, 2, 6, 4, and 2:
printArray(new int[]{3, 1, 2, 6, 4, 2});
6 - Returning an Array from a Method:
A method may also return an array. For example, the method shown below returns an array that is the reversal of another array:
-----------------------------------------
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}
-----------------------------------------
7 - The Arrays Class:
The java.util.Arrays class contains various static methods for sorting and searching arrays, comparing arrays, and filling array elements. These methods are overloaded for all primitive types.
1) public static int binarySearch(Object[] a, Object key):
Searches the specified array of Object ( Byte, Int , double, etc.) for the specified value using the binary search algorithm. The array must be sorted prior to making this call. This returns index of the search key, if it is contained in the list; otherwise, (-(insertion point + 1).
2) public static boolean equals(long[] a, long[] a2):
Returns true if the two specified arrays of longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. This returns true if the two arrays are equal. Same method could be used by all other primitive data types (Byte, short, Int, etc.)
3) public static void fill(int[] a, int val):
Assigns the specified int value to each element of the specified array of ints. Same method could be used by all other primitive data types (Byte, short, Int etc.)
4) public static void sort(Object[] a):
Sorts the specified array of objects into ascending order, according to the natural ordering of its elements. Same method could be used by all other primitive data types ( Byte, short, Int, etc.)
[Java core 11] String class
Strings, which are widely used in Java programming, are a sequence of characters. In the Java programming language, strings are objects.
The Java platform provides the String class to create and manipulate strings.
1 - Creating Strings:
The most direct way to create a string is to write:
Ex: String greeting = "Hello world!";
Whenever it encounters a string literal in your code, the compiler creates a String object with its value in this case, "Hello world!'.
As with any other object, you can create String objects by using the new keyword and a constructor. The String class has eleven constructors that allow you to provide the initial value of the string using different sources, such as an array of characters.
Ex:
--------------------------------------------------
public class StringDemo{
public static void main(String args[]){
char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.'};
String helloString = new String(helloArray);
System.out.println( helloString );
}
}
--------------------------------------------------
This would produce the following result:
hello.
Note: The String class is immutable, so that once it is created a String object cannot be changed. If there is a necessity to make a lot of modifications to Strings of characters, then you should use String Buffer & String Builder Classes.
2 - String Length:
Methods used to obtain information about an object are known as accessor methods. One accessor method that you can use with strings is the length() method, which returns the number of characters contained in the string object.
After the following two lines of code have been executed, len equals 17:
----------------------------------------------------
public class StringDemo {
public static void main(String args[]) {
String palindrome = "Dot saw I was Tod";
int len = palindrome.length();
System.out.println( "String Length is : " + len );
}
}
-----------------------------------------------------
This would produce the following result:
String Length is : 17
3 - Concatenating Strings:
The String class includes a method for concatenating two strings:
Ex:
string1.concat(string2);
This returns a new string that is string1 with string2 added to it at the end. You can also use the concat() method with string literals, as in:
"My name is ".concat("Zara");
Strings are more commonly concatenated with the + operator, as in:
"Hello," + " world" + "!"
which results in:
"Hello, world!"
Example:
-----------------------------------------
public class StringDemo {
public static void main(String args[]) {
String string1 = "saw I was ";
System.out.println("Dot " + string1 + "Tod");
}
}
-----------------------------------------
This would produce the following result:
Dot saw I was Tod
4 - Creating Format Strings:
You have printf() and format() methods to print output with formatted numbers. The String class has an equivalent class method, format(), that returns a String object rather than a PrintStream object.
Using String's static format() method allows you to create a formatted string that you can reuse, as opposed to a one-time print statement. For example, instead of:
System.out.printf("The value of the float variable is " +
"%f, while the value of the integer " +
"variable is %d, and the string " +
"is %s", floatVar, intVar, stringVar);
you can write:
String fs;
fs = String.format("The value of the float variable is " +
"%f, while the value of the integer " +
"variable is %d, and the string " +
"is %s", floatVar, intVar, stringVar);
System.out.println(fs);
5 - String Methods:
Here is the list of methods supported by String class:
1) char charAt(int index): Returns the character at the specified index.
2) int compareTo(Object o): Compares this String to another Object.
3) int compareTo(String anotherString): Compares two strings lexicographically.
4) int compareToIgnoreCase(String str): Compares two strings lexicographically, ignoring case differences.
5) String concat(String str): Concatenates the specified string to the end of this string.
6) boolean contentEquals(StringBuffer sb): Returns true if and only if this String represents the same sequence of characters as the specified StringBuffer.
7) static String copyValueOf(char[] data): Returns a String that represents the character sequence in the array specified.
8) static String copyValueOf(char[] data, int offset, int count): Returns a String that represents the character sequence in the array specified.
9) boolean endsWith(String suffix): Tests if this string ends with the specified suffix.
10) boolean equals(Object anObject): Compares this string to the specified object.
11) boolean equalsIgnoreCase(String anotherString): Compares this String to another String, ignoring case considerations.
12) byte getBytes(): Encodes this String into a sequence of bytes using the platform's default charset, storing the result into a new byte array.
13) byte[] getBytes(String charsetName): Encodes this String into a sequence of bytes using the named charset, storing the result into a new byte array.
14) void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin): Copies characters from this string into the destination character array.
15) int hashCode(): Returns a hash code for this string.
16) int indexOf(int ch): Returns the index within this string of the first occurrence of the specified character.
17) int indexOf(int ch, int fromIndex): Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.
18) int indexOf(String str): Returns the index within this string of the first occurrence of the specified substring.
19) int indexOf(String str, int fromIndex): Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.
20) String intern(): Returns a canonical representation for the string object.
21) int lastIndexOf(int ch): Returns the index within this string of the last occurrence of the specified character.
22) int lastIndexOf(int ch, int fromIndex): Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index.
23) int lastIndexOf(String str): Returns the index within this string of the rightmost occurrence of the specified substring.
24) int lastIndexOf(String str, int fromIndex): Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index.
25) int length(): Returns the length of this string.
26) boolean matches(String regex): Tells whether or not this string matches the given regular expression.
27) boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len): Tests if two string regions are equal.
28) boolean regionMatches(int toffset, String other, int ooffset, int len): Tests if two string regions are equal.
29) String replace(char oldChar, char newChar): Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.
30) String replaceAll(String regex, String replacement): Replaces each substring of this string that matches the given regular expression with the given replacement.
31) String replaceFirst(String regex, String replacement): Replaces the first substring of this string that matches the given regular expression with the given replacement.
32) String[] split(String regex): Splits this string around matches of the given regular expression.
33) String[] split(String regex, int limit): Splits this string around matches of the given regular expression.
34) boolean startsWith(String prefix): Tests if this string starts with the specified prefix.
35) boolean startsWith(String prefix, int toffset): Tests if this string starts with the specified prefix beginning a specified index.
36) CharSequence subSequence(int beginIndex, int endIndex): Returns a new character sequence that is a subsequence of this sequence.
37) String substring(int beginIndex): Returns a new string that is a substring of this string.
38) String substring(int beginIndex, int endIndex): Returns a new string that is a substring of this string.
39) char[] toCharArray(): Converts this string to a new character array.
40) String toLowerCase(): Converts all of the characters in this String to lower case using the rules of the default locale.
41) String toLowerCase(Locale locale): Converts all of the characters in this String to lower case using the rules of the given Locale.
42) String toString(): This object (which is already a string!) is itself returned.
43) String toUpperCase(): Converts all of the characters in this String to upper case using the rules of the default locale.
44) String toUpperCase(Locale locale): Converts all of the characters in this String to upper case using the rules of the given Locale.
45) String trim(): Returns a copy of the string, with leading and trailing whitespace omitted.
46) static String valueOf(primitive data type x): Returns the string representation of the passed data type argument.
Friday, May 16, 2014
[Java core 10] Character class
Normally, when we work with characters, we use primitive data types char.
Example:
char ch = 'a';
// Unicode for uppercase Greek omega character
char uniChar = '\u039A';
// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };
However in development, we come across situations where we need to use objects instead of primitive data types. In order to achieve this, Java provides wrapper class Character for primitive data type char.
The Character class offers a number of useful class (i.e., static) methods for manipulating characters. You can create a Character object with the Character constructor:
Character ch = new Character('a');
The Java compiler will also create a Character object for you under some circumstances. For example, if you pass a primitive char into a method that expects an object, the compiler automatically converts the char to a Character for you. This feature is called autoboxing or unboxing, if the conversion goes the other way.
Example:
// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';
// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');
Escape Sequences:
A character preceded by a backslash (\) is an escape sequence and has special meaning to the compiler.
The newline character (\n) has been used frequently in this tutorial in System.out.println() statements to advance to the next line after the string is printed.
Following table shows the Java escape sequences:
Escape sequence Description
\t Inserts a tab in the text at this point.
\b Inserts a backspace in the text at this point.
\n Inserts a newline in the text at this point.
\r Inserts a carriage return in the text at this point.
\f Inserts a form feed in the text at this point.
\' Inserts a single quote character in the text at this point.
\" Inserts a double quote character in the text at this point.
\\ Inserts a backslash character in the text at this point.
When an escape sequence is encountered in a print statement, the compiler interprets it accordingly.
Example:
If you want to put quotes within quotes you must use the escape sequence, \", on the interior quotes:
--------------------------------------
public class Test {
public static void main(String args[]) {
System.out.println("She said \"Hello!\" to me.");
}
}
------------------------------------------
This would produce the following result:
She said "Hello!" to me.
Character Methods:
Here is the list of the important instance methods that all the subclasses of the Character class implement:
SN Methods Description
1 isLetter() Determines whether the specified char value is a letter.
2 isDigit() Determines whether the specified char value is a digit.
3 isWhitespace() Determines whether the specified char value is white space.
4 isUpperCase() Determines whether the specified char value is uppercase.
5 isLowerCase() Determines whether the specified char value is lowercase.
6 toUpperCase() Returns the uppercase form of the specified char value.
7 toLowerCase() Returns the lowercase form of the specified char value.
8 toString() Returns a String object representing the specified character valuethat is, a one-character string.
For a complete list of methods, please refer to the java.lang.Character API specification.