05 Java Language And OOP Part V

Java Language and OOP
Part V
By Hari Christian

Agenda
• 01 String Package
• 02 Date Package
• 03 Math Package
• 04 How Accurate are Calculation
• 05 Exception - Basic
• 06 Exception - Try Catch
• 07 Exception - Throw
• 08 Exception - Finaly

Agenda
• 09 Collections - Basic
• 10 Collections - List, LinkedList and ArrayList
• 11 Collections - Set, HashSet and SortedSet
• 12 Collections - Helper Class
• 13 Collections - Generics
• 14 Collections - Map, HashMap and TreeMap
• 15 I/O - Simple
• 16 I/O - Advanced
• 17 File

String Package
• Strings Are Immutable Objects, the key concept
to understand is that once a String object is
created, it can never be changed
• In Java, strings are objects

String Package
• How to create String
// 1st way
String s = new String();
s = "abcdef";
// 2nd way
String s = new String("abcdef");
// 3rd way
String s = "abcdef";

String Package
• Following example will explain about Immutable
String s = “Java"; // ?
String s2 = s; // ?
s.concat(“ Rules!!!"); // ?
s.toUpperCase(); // ?
s.replace('a', 'X'); // ?
s = s.concat(" Rules!"); // ?

String Package
• String methods:
– charAt, Returns the character located at the specified index
– concat, Appends one String to the end of another
– equalsIgnoreCase, Determines the equality of two Strings,
ignoring case
– length, Returns the number of characters in a String
– replace, Replaces occurrences of a character with a new
character
– substring, Returns a part of a String
– toLowerCase, Returns a String with lowercase
– toUpperCase, Returns a String with uppercase
– trim, Removes whitespace from the ends of a String

StringBuffer & StringBuilder
• StringBuffer and StringBuilder should be used
when you have to make a lot of modifications
to strings of characters
• As we discussed in the previous section, String
objects are immutable, so if you choose to do a
lot of manipulations with String objects, you will
end up with a lot of abandoned String objects
in the String pool

• The StringBuilder class was added in Java 5
• StringBuilder has exactly the same API as the
StringBuffer class, except StringBuilder is not
thread safe. In other words, its methods are not
synchronized
• Sun recommends that you use StringBuilder
instead of StringBuffer whenever possible
because StringBuilder will run faster (and
perhaps jump higher)

• Example:
StringBuffer sb = new StringBuffer("abc");
sb.append("def"); // abcdef
sb.delete(2, 3); // abdef
sb.insert(2, “c”); // abcdef
sb.reverse(); // fedcba
sb.toString(); // fedcba

Date Package
• Class related to Date:
– java.util.Date, Date represents a mutable date and
time to a millisecond
– java.util.Calendar, This class provides a huge variety
of methods that help you convert and manipulate
dates and times
– java.text.DateFormat, used to format dates
– java.util.Locale, This class is used in conjunction
with DateFormat to format dates for specific locales

Date Package
• Example getting current date:
// Current date time with Date
Date now = new Date();
// Current date time with Calendar
Calendar cal = Calendar.getInstance();
Cal.getTime();

Date Package
• Example convert Date to String and otherwise:
// Format date
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);
// Convert Date to String
String dateStr = sdf.format(new Date());
System.out.println(dateStr);
// Convert String to Date
Date date = sdf.parse(dateStr);
System.out.println(date);

Date Package
• Example of Calendar:
Calendar calc = new GregorianCalendar(2013, 1, 28, 13, 24, 56);
System.out.println(calc.getTime()); // Thu Feb 28 13:24:56 ICT 2013
int year = calendar.get(Calendar.YEAR); // 2013
int month = calendar.get(Calendar.MONTH); // 1 (Jan = 0, dec = 11)
int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH); // 28
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK); // 5
int weekOfYear = calendar.get(Calendar.WEEK_OF_YEAR); // 9
int weekOfMonth= calendar.get(Calendar.WEEK_OF_MONTH); // 5
int hour = calendar.get(Calendar.HOUR); // 1 (12 hour clock)
int hourOfDay = calendar.get(Calendar.HOUR_OF_DAY); // 13 (24 hour clock)
int minute = calendar.get(Calendar.MINUTE); // 24
int second = calendar.get(Calendar.SECOND); // 56
int millisecond= calendar.get(Calendar.MILLISECOND); // 0

Date Package
• Example of Updating Calendar:
SimpleDateFormat sdf = new SimpleDateFormat("yyyy MMM dd HH:mm:ss");
Calendar calendar = new GregorianCalendar(2013,1,28,13,24,56);
System.out.println("#1. " + sdf.format(calendar.getTime()));
// Update a date
calendar.set(Calendar.YEAR, 2014);
calendar.set(Calendar.MONTH, 11);
calendar.set(Calendar.MINUTE, 33);
System.out.println("#2. " + sdf.format(calendar.getTime()));
// #1. 2013 Feb 28 13:24:56
// #2. 2014 Dec 28 13:33:56

Date Package
• Example of Calendar operation:
SimpleDateFormat sdf = new SimpleDateFormat("yyyy MMM dd");
Calendar calendar = new GregorianCalendar(2013,10,28);
System.out.println("Date : " + sdf.format(calendar.getTime()));
// Date : 2013 Nov 28
// Add one month
calendar.add(Calendar.MONTH, 1);
// Date : 2013 Dec 28
// Subtract 10 days
calendar.add(Calendar.DAY_OF_MONTH, -10);
// Date : 2013 Dec 18

Date Package
• Example of Locale:
Calendar c = Calendar.getInstance();
c.set(2010, 11, 14); // December 14, 2010 (month is 0-based)
Date d2 = c.getTime();
Locale locIT = new Locale("it", "IT"); // Italy
Locale locPT = new Locale("pt"); // Portugal
DateFormat dfIT = DateFormat.getDateInstance(DateFormat.FULL, locIT);
System.out.println("Italy " + dfIT.format(d2));
// Italy domenica 14 dicembre 2010
DateFormat dfPT = DateFormat.getDateInstance(DateFormat.FULL, locPT);
System.out.println("Portugal " + dfPT.format(d2));
// Portugal Domingo, 14 de Dezembro de 2010

Date Package
Format Description Example
G Era AD
y Year 1996 or 96
M Month in Year July or Jul or 07
w Week in Year 27
W Week in Month 2
D Day in Year 189
d Day in Month 10
F Day of Week in Month 2
E Day in Week Tuesday or Tue
a AM/PM AM or PM
H Hour in Day (0 – 23) 0
k Hour in Day (1 – 24) 24
K Hour in AM/PM (0 – 11) 0
h Hour in AM/PM (1 – 12) 12
m Minute in Hour 30
s Second in Minute 55
S Millisecond 978
z Timezone Pasific Standard Time or PST or GMT +07:00
Z Timezone -0700

Date Package
• Example of Pattern:
Date Pattern Result
yyyy.MM.dd G 'at' HH:mm:ss z 2001.07.04 AD at 12:08:56 PDT
EEE, MMM d, ''yy Wed, Jul 4, '01
h:mm a 12:08 PM
hh 'o''clock' a, zzzz 12 o'clock PM, Pacific Daylight Time
K:mm a, z 0:08 PM, PDT
yyyyy.MMMMM.dd GGG hh:mm aaa 02001.July.04 AD 12:08 PM
EEE, d MMM yyyy HH:mm:ss Z Wed, 4 Jul 2001 12:08:56 -0700
yyMMddHHmmssZ 010704120856-0700
yyyy-MM-dd'T'HH:mm:ss.SSSZ 2001-07-04T12:08:56.235-0700

Math Package
public static final double E = 2.7182818284590452354;
public static final double PI = 3.14159265358979323846;
public static native double IEEEremainder(double, double);
public static double abs(double);
public static float abs(float);
public static int abs(int);
public static long abs(long);
// returns a random number between 0.0 and 1.0
public static synchronized double random();
// rounds the argument to an integer, stored as a double
public static native double rint(double);

Math Package - Trigonometric
public static double toDegrees(double);
public static double toRadians(double);
public static native double sin(double);
public static native double cos(double);
public static native double tan(double);
public static native double asin(double);
public static native double acos(double);
public static native double atan(double);
public static native double atan2(double, double);
public static native double exp(double);
public static native double pow(double, double);
public static native double log(double);
public static native double sqrt(double);

Math Package – Rounding and Comparing
public static native double ceil(double);
public static native double floor(double);
public static double max(double, double);
public static float max(float, float);
public static int max(int, int);
public static long max(long, long);
public static double min(double, double);
public static float min(float, float);
public static int min(int, int);
public static long min(long, long);
public static long round(double);
public static int round(float);

How Accurate are Calculation
• The accuracy when evaluating a result is
referred to as the precision of an expression
• The precision may be expressed either as
number of bits (64 bits), or as the data type of
the result (double precision, meaning 64-bit
floating-point format)

• In Java, the precision of evaluating an operator
depends on the types of its operands
• Java looks at the types of the operands around
an operator and picks the biggest of what it
sees: double, float, and long, in that order of
preference
• Both operands are then promoted to this type,
and that is the type of the result
• If there are no doubles, floats, or longs in the
expression, both operands are promoted to int,
and that is the type of the result

• A Java compiler follows this algorithm:
– If either operand is a double, do the operation in
double precision.
– Otherwise, if either operand is a float, do the
operation in single precision.
– Otherwise, if either operand is a long, do the
operation at long precision.
– Otherwise, do the operation at 32-bit int precision.
• In summary, Java expressions end up with the
type of the biggest, floatiest type (double, float,
long) in the expression. They are otherwise 32-
bit integers.

double number = 0.0;
for (int i=0; i<10; i++) {
System.out.print("number = " + total + " + 0.1 = ");
number = number + 0.1;
System.out.println(“number = " + number);
}
System.out.println(“grand total =“ + number);

• Our expectation are:
Initial Number = 0.0
Then looping until 10 times
Number = 0.0 + 0.1 = 0.1
Number = 0.1 + 0.1 = 0.2
…
Number = 0.9 + 0.1 = 1.0
The result is 1.0

• However the actual result is
– number = 0.0 + 0.1 = 0.1
– number = 0.1 + 0.1 = 0.2
– number = 0.2 + 0.1 = 0.30000000000000004
– number = 0.30000000000000004 + 0.1 = 0.4
– number = 0.4 + 0.1 = 0.5
– number = 0.5 + 0.1 = 0.6
– number = 0.6 + 0.1 = 0.7
– number = 0.7 + 0.1 = 0.7999999999999999
– number = 0.7999999999999999 + 0.1 = 0.8999999999999999
– number = 0.8999999999999999 + 0.1 = 0.9999999999999999
– grand total = 0.9999999999999999

float number = 0.0F;
for (int i=0; i<10; i++) {
System.out.print("number = " + total + " + 0.1F = ");
number = number + 0.1F;
System.out.println(“number = " + number);
}
System.out.println(“grand total =“ + number);

• However the actual result is
– number = 0.0 + 0.1F = 0.1
– number = 0.1 + 0.1F = 0.2
– number = 0.2 + 0.1F = 0.3
– number = 0.3 + 0.1F = 0.4
– number = 0.4 + 0.1F = 0.5
– number = 0.5 + 0.1F = 0.6
– number = 0.6 + 0.1F = 0.70000005
– number = 0.70000005 + 0.1F = 0.8000001
– number = 0.8000001 + 0.1F = 0.9000001
– number = 0.9000001 + 0.1F = 1.0000001
– grand total = 1.0000001

Exception - Basic
• We'll cover the purpose and use of exceptions
following this order
• The one sentence summary is "Exceptions are
like software interrupts - they are generated by
error conditions like division by zero, and they
divert the flow of control to a place where you
have said you will handle this kind of error"

Exception - Basic
• First, we'll look at the basics of:
– Why exceptions are in the language
– What causes an exception (implicitly and explicitly)
• Once an exception has occurred, you'll want to
know how to take steps to deal with it:
– How to handle ("catch") an exception within the
method where it was thrown
– Handling groups of related exceptions

Exception - Basic
• Exceptions are for changing the flow of control
when some important or unexpected event,
usually an error, has occurred. They divert
processing to a part of the program that can try
to cope with the error, or at least die gracefully
• There are many possible errors that can happen
in non-trivial programs: these range from
"unable to open a file" to "array subscript out of
range" to "no memory left to allocate" to "division
by zero"

Exception - Basic
• Two things happen when an exception is
thrown:
– An exception object is instantiated to record the
details of what went wrong
– The run-time system then diverts the normal flow of
control, to search back up the call chain for a place
where you have put a statement saying you can
handle this kind of exception object

Exception - Basic
• As stated previously, exceptions occur when:
– The program does something illegal (common case)
– The program explicitly generates an exception by
executing the throw statement (less common case)

Exception - Basic
• Example:
public static void main(String[] args) {
int i=1, j=0, k;
k = i/j; // line 5 causes division-by-zero exception
}

Exception – Try Catch
• Example:
try {
// put potentially statement error
} catch (Exception e) {
// put potentially statement handle
}
}

• Example:
try {
throw new NullPointerException();
} catch (NullPointerException e) {
e.printStackTrace();
}
}

• Example:
try {
throw new FileNotFoundException();
} // Error cause expecting catch here
}

• Example:
try {
throw new FileNotFoundException();
// To make it short, just type Exception
// But this is not recommended
}
}

• Example:
try {
System.out.println(“START”);
String a = “”;
a.trim();
System.out.println(“FINISH”);
}

• Example:
try {
System.out.println(“START”);
String a;
a.trim();
System.out.println(“FINISH”);
}

Exception – Throws
public class ThrowsTest {
public Integer calculate() throws Exception {
return null;
}
try {
ThrowsTest tt = new ThrowsTest();
Integer result = tt.calculate();
System.out.println(result.intValue());
}
}

Exception – Finally
try {
System.out.println(“TRY”);
System.out.println(“CATCH”);
} finally {
System.out.println(“FINALLY”);
}
}

Exception – Finally
try {
System.out.println(“START TRY”);
String a;
a.trim();
System.out.println(“FINISH TRY”);
System.out.println(“CATCH”);
} finally {
System.out.println(“FINALLY”);
}
}

Collection - Basic
• A set of collection data
• Collection is data structures
• There are 4 main data structure in Collection:
– List
– Set
– Queue
– Maps (but this is not family of Collection)

Collection - Basic
• There are a few basic operations you'll normally
use with collections:
– Add objects to the collection
– Remove objects from the collection
– Find out if an object (or group of objects) is in the
collection
– Retrieve an object from the collection (without
removing it)
– Iterate through the collection, looking at each element
(object) one after another

Collection - List
• Lists can contain duplicate elements
• Lists are kept in the order that elements are
added
• A List cares about the index
• List is also an Interface

Collection - List
• The one thing that List has that non-lists don't
have is a set of methods related to the index:
– addAll(int index, Collection);
– get(int index);
– set(int index, E element);
– add(int index, E element);
– remove(int index);
– indexOf(Object o);
– lastIndexOf(Object o);

Collection - List
• There are 3 implementation of Lists:
– ArrayList
– Vector
– LinkedList

Collection - ArrayList
• Think of ArrayList as a growable array
• It gives you fast iteration and fast random
access
• Choose ArrayList over a LinkedList when you
need fast iteration but aren't as likely to be
doing a lot of insertion and deletion

• The time to add an element to an ArrayList is
normally quick
• But when the array is full, adding another
element causes a new bigger array to be
allocated and the old one copied over into it

List<String> l = new ArrayList<String>();
l.add("h");
l.add("a");
l.add("r");
l.add("i");
l.add("h");
System.out.println("size before = " + l.size());
System.out.println(“is list contain h? = ” + l.contains("h"));
l.remove("h");
System.out.println("size after = " + l.size());
for(String s : l) {
System.out.println(s);
}

Collection - Vector
• A Vector is basically the same as an ArrayList
• But Vector methods are synchronized for thread
safety
• Choose Vector if you need synchronized in
Thread because the synchronized methods add
a performance hit you might not need

Collection - LinkedList
• A LinkedList is ordered by index position, like
ArrayList
• LinkedList gives you new methods for adding
and removing from the beginning or end
(addFirst and addLast), which makes it an easy
choice for implementing a stack or queue
• Keep in mind that a LinkedList may iterate more
slowly than an ArrayList, but it's a good choice
when you need fast insertion and deletion

Collection - Set
• A Set is a collection that has no duplicate
elements
• The interface java.util.Set does not add any
methods
• A List cares about the uniqueness
• Set is also an Interface

Collection - Set
– HashSet
– LinkedHashSet
– TreeSet

Collection - HashSet
• A HashSet is unsorted and unordered
• Use this class when you want a collection with
no duplicates and you don't care about order
when you iterate through it also you want fast
retrieval

Collection - HashSet
boolean[] ba = new boolean[5];
Set s = new HashSet();
ba[0] = s.add("a");
ba[1] = s.add(new Integer(42));
ba[2] = s.add("b");
ba[3] = s.add("a");
ba[4] = s.add(new Object());
for (int x = 0; x < ba.length; x++) System.out.print(ba[x]);
System.out.println("n");
for (Object o : s) System.out.print(o + " ");

Collection - LinkedHashSet
• A LinkedHashSet is an ordered version of
HashSet
• Use this class instead of HashSet when you
care about the iteration order

Collection - TreeSet
• The TreeSet is one of two sorted collections (the
other being TreeMap)
• The elements will be in ascending order,
according to natural order
• Optionally, you can construct a TreeSet with a
constructor that lets you give the collection your
own rules for what the order should be by using
a Comparable or Comparator

• TreeSet works just like HashSet, but it takes a
little extra work to keep everything in sorted
order
• Therefore, you will choose TreeSet when the
ordering of the elements is important to you,
and HashSet otherwise
• There's no sense in incurring a performance
penalty if you don't need to

boolean[] ba = new boolean[5];
Set s = new TreeSet();
ba[0] = s.add("a");
ba[1] = s.add(new Integer(42));
ba[2] = s.add("b");
ba[3] = s.add("a");
ba[4] = s.add(new Object());
for (int x = 0; x < ba.length; x++) System.out.print(ba[x]);
System.out.println("n");
for (Object o : s) System.out.print(o + " ");

Collection - Queue
• A Queue is designed to hold a list of "to-dos," or
things to be processed in some way
• Queues are typically thought of as FIFO

Collection - Map
• Map is a data structure interface that connects
keys and values
• A Map cares about unique identifiers
• You map a unique key (the ID) to a specific
value, where both the key and the value are, of
course, objects

Collection - Map
• A set of methods related to the Map:
– containsKey(Object);
– containsValue(Object);
– get(Object key);
– put(K key, V value);
– remove(Object key);
– values(); // get values
– keySet(); // get keys
– entrySet(); // get mappings

Collection - Map
– HashMap
– Hashtable
– LinkedHashMap
– TreeMap

Collection - HashMap
• The HashMap gives you an unsorted and
unordered Map
• When you need a Map and you don't care about
the order (when you iterate through it), then
HashMap is the way to go; the other maps add a
little more overhead
• HashMap allow null key and null value

• HashMap is a supremely useful class
• Hash tables allow you store together any
number of key/value pairs. Instead of storing
items with index values 0, 1, 2, 3, as you would
in an array, you provide the key to be associated
with the object
• Then in the future, you need provide only that
key again, and voila, out pops the right object

Map<String, String> phonebook = new HashMap<String, String>();
String [] names = { "Lefty", "Guarav", "Wong", "Rupamay" };
String [] extns = { "4873", "4810", "3769", "0" };
for(int i=0; i< names.length; i++) {
phonebook.put( names[i], extns[i] );
}
System.out.println("map: " + phonebook);

Collection - Hashtable
• Hashtable is a syncronized version of HashMap
• HashMap disallow null key and null value

Collection - LinkedHashMap
• Like its Set counterpart, LinkedHashSet, the
LinkedHashMap collection maintains insertion
order
• Although it will be somewhat slower than
HashMap for adding and removing elements,
you can expect faster iteration with a
LinkedHashMap

Collection - TreeMap
• TreeMap is a sorted Map
• The elements will be in ascending order,
according to natural order
• Optionally, you can construct a TreeMap with a
constructor that lets you give the collection your
own rules for what the order should be by using
a Comparable or Comparator

Collection - TreeMap
Map<String, String> phonebook = new TreeMap<String, String>();
String [] names = { "Lefty", "Guarav", "Wong", "Rupamay" };
String [] extns = { "4873", "4810", "3769", "0" };
for(int i=0; i< names.length; i++) {
phonebook.put( names[i], extns[i] );
}
System.out.println("map: " + phonebook);

Collection – Summary
Class Map Set List Ordered Sorted
HashMap X No No
HashTable X No No
TreeMap X Sorted By Natural order or
Custom
LinkedHashMap X By insertion order or
last access order
No
HashSet X No No
TreeSet X Sorted By Natural order or
Custom
LinkedHashSet X By insertion order No
ArrayList X By index No
Vector X By index No
LinkedList X By index No
PriorityQueue Sorted By to-do order

Collection – Helper Class
• Some helpful methods in Collections:
– Sort
– Binary Search
– Reverse
– Shuffle
– Swap
– Copy
– Rotate
– Replace All

Collection – Helper Class
LinkedList <String> cs = new LinkedList<String>();
cs.add( "data" );
cs.add( "element" );
cs.add( "boolean" );
cs.add( "computer" );
cs.add( "algorithm" );
System.out.println("BEFORE = " + cs );
Collections.sort( cs );
System.out.println("AFTER = " + cs );
}

Comparable vs Comparator
java.lang.Comparable java.util.Comparator
int objOne.compareTo(objTwo) int compare(objOne, objTwo)
Returns
Negative, if objOne < objTwo
Zero, if objOne == objTwo
Positive, if objOne > objTwo
Same as Comparable
You must modify the class whose
instances you want to sort
You build a class separate from the
class whose instances you
want to sort
Only one sort sequence can be
created
Many sort sequences can be created
Implemented frequently in the API by:
String, Wrapper classes, Date,
Calendar
Meant to be implemented to sort
instances of third-party classes

Collection – Generic
• Generic are most implement in Collection API
• public class HashSet <E> { }
means that (to use this class) you will declare and
instantiate a HashSet to work with a specific type
Example:
HashSet<Date> ht = new HashSet<Date>();

Java IO
• Package involving Java IO
Package Name Purpose
java.io Contain 75 classes and interfaces for I/O
java.nio API for memory-mapped I/O, non blocking I/O and file locking
java.text Formatting text, dates, numbers and messages
java.util.regex Pattern matching
java.util.zip Read and write ZIP files
java.util.logging Recording log message for later problem diagnosis
java.util.jar Read and write JAR files
javax.xml.parser Read and write XML
javax.imageio API for image file I/O ex thumbnail, conversion, etc
javax.print Printing services
javax.comm Accessing serial and parallel port
javax.sound.midi API for MIDI (Musical Instrument Digital Interface) data
javax.speech API for speech recognition

Java IO
• The design philosophy for Java I/O is:
– Programs that do I/O should be portable
– I/O is based on streams
– There are lots of small classes that do one thing

Java IO - Portability of I/O
Windows Unix Java
End of line r n n System.getProperty(“line.separator”)
Filename
Separator
/ File.separator
Path
Names
C:temp
192.168.1.10temp
/home/hari Just pass the pathname
as an argument
Data Byte
Order
Little endian Varies with
Hardware
Big endian

Java IO - Portability of I/O
• Example:
String EOL = System.getProperty("line.separator");
String path = “C:” + File.separator + “test.txt”;

Java IO - File
• java.io.File allow you to access metadata to:
– Return a File object from a String containing a
pathname
– Test whether a file exists, is readable/writable, or is a
directory
– Say how many bytes are in the file and when it was
last modified
– Delete the file, or create directory paths
– Get various forms of the file pathname
• File either can be a Directory or a File

Java IO - File
// constant:
public static final char separatorChar;
public static final String separator;
public static final char pathSeparatorChar;
public static final String pathSeparator;
// constructors:
public File(String path);
public File(String directory, String file);
public File(File directory, String file);

Java IO - File
// about the file:
public String getName();
public String getParent();
public File getParentFile();
public String getPath();
public String getAbsolutePath();
public File getAbsoluteFile();
public String getCanonicalPath();
public File getCanonicalFile();

Java IO - File
// about the file:
public boolean canRead();
public boolean canWrite();
public boolean exists();
public boolean isAbsolute();
public boolean isDirectory();
public boolean isFile();
public boolean isHidden();
public long lastModified();
public long length();

Java IO - File
// about the directory
public String[] list();
public String[] list(FilenameFilter);
public File[] listFiles();
public File[] listFiles(FilenameFilter);
public File[] listFiles(FileFilter);
public static File[] listRoots();
public boolean mkdir();
public boolean mkdirs();

Java IO - File
// using temporary files
public boolean createNewFile();
public boolean delete();
public void deleteOnExit();
File createTempFile(String, String);
File createTempFile(String, String, File);

Java IO - File
// miscellaneous:
public boolean renameTo(File);
public boolean setLastModified(long);
public boolean setReadOnly();
public int compareTo(File);
public int compareTo(Object);
public boolean equals(Object);
public int hashCode();
public String toString();
public URL toURL();

Java IO - File
• Example Instantiating a File
File file = new File("c:/data/input-file.txt");
• Check if the file exists
boolean fileExists = file.exists();
• Retrieve the size of the file
long length = file.length();

Java IO - File
• Renaming or Moving a file
boolean rm = file.renameTo(new File("c:/new.txt"));
• Deleting a file
boolean del = file.delete();
• Creating a file
boolean success = file.createNewFile();

Java IO - File
• Reading list of files
File file = new File("c:data");
File[] files = file.listFiles();
• Checking directory or file
boolean isDirectory = file.isDirectory();
• Making a directory
boolean dir = file.mkdir();

Java IO - Scanner
• Java.util.Scanner was introduced in Java 5
• From the first 9 years of Java, did not have
console input
• There are 3 convention for console input:
– 0 for standard input (in C are cin or stdin)
– 1 for standard output (in C are cout or stdout or printf)
– 2 for standard error (in C are stderr)

Java IO - Scanner
• Example:
Scanner scan = new Scanner(System.in);
int age = scan.nextInt(); // Expect int value
boolean valid = scan.nextBoolean();
short status = scan.nextShort();
double salary = scan.nextDouble();
String name = scan.next();
BigInteger bigint = scan.nextBigInteger();
BigDecimal bigdec = scan.nextBigDecimal();

Java IO - Scanner
• Example:
Scanner scan = new Scanner(System.in);
boolean a = scan.hasNext();
boolean a = scan.hasNextBoolean();
boolean a = scan.hasNextShort();
boolean a = scan.hasNextInt();
boolean a = scan.hasNextDouble();
boolean a = scan.hasNextBigInteger();
boolean a = scan.hasNextBigDecimal();

Java IO - Scanner
• Example to read file from Scanner:
Scanner scan = new Scanner(new File("C:/b.txt"));
while(scan.hasNextInt()) {
int value = scan.nextInt();
System.out.println(value);
}

Java IO - Printf
• Example to write to console:
System.out.println(“This is output”);
// printf is used for formatting the output
// %d mean format to integer
int age = 27;
System.out.printf("Your age is: %d n", age );

Java IO - BufferedReader
• Example to read a file:
// Source file
File hsbcFile = new File(“C:/hsbc.txt”);
// Load into memory
BufferedReader brHsbc = new BufferedReader(new FileReader(hsbcFile));
// Read line by line
String currentLine = “”;
while ((currentLine = brHsbc.readLine()) != null) {
System.out.println(currentLine);
}

Java IO - FileWriter
• Example to write to file:
// Create temporary file
File temp = File.createTempFile("TEMP", ".txt");
// Write it
FileWriter writer = new FileWriter(temp);
writer.write(“Write it to file”);
writer.close();
// Copy from temporary to real file
temp.deleteOnExit();
FileChannel src = new FileInputStream(temp).getChannel();
FileChannel dest = new FileOutputStream(outputFile).getChannel();
dest.transferFrom(src, 0, src.size());

Java IO - ZipFile
• Example to create zip file:
ZipFile zipFile = new ZipFile(“C:/output.zip”);
ZipParameters parameters = new ZipParameters();
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE);
parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);
parameters.setEncryptFiles(true);
parameters.setEncryptionMethod(Zip4jConstants.ENC_METHOD_STANDARD);
parameters.setPassword(password);
zipFile.addFiles(new File(“C:/a.txt”), parameters);
zipFile.addFiles(new File(“C:/b.txt”), parameters);
zipFile.addFiles(new File(“C:/c.txt”), parameters);

Java IO - RandomAccessFile
• Until now we have seen how input and output is
done in a serial mode
• However, sometimes we want to be able to
move around inside a file and write to different
locations, or read from different locations,
without having to scan all the data
• Traveling in a file stream in such a manner is
called "random access"

Java IO - RandomAccessFile
• Example:
// R = Read, RW = Read Write
RandomAccessFile myRAF = new RandomAccessFile("C:/test.txt", "rw");
myRAF.seek(myRAF.length()); // append to end of file
myRAF.writeInt(5);
myRAF.writeInt(0xBEEF);
myRAF.writeBytes("at end.");
myRAF.close();

Java IO – Running Program
• How to execute a program from Java and read the
output of that program back into your application
1. Get the object representing the current run-time environment.
A static method in class java.lang.Runtime does this
2. Call the exec method in the run-time object, with your
command as an argument string. Give the full path name to the
executable, and make sure the executable really exists on the
system. The call to exec() returns a Process object
3. Connect the output of the Process (which will be coming to you
as an input stream) to an input stream reader in your program
4. You can either read individual characters from the input
stream, or layer a BufferedReader on it and read a line at a
time as in the code below

Java IO – Running Program
• Example:
Runtime rt = Runtime.getRuntime(); // Step 1
Process p = rt.exec(“chmod –R 777 /home/hari”); // Step 2
// Step 3
InputStreamReader isr = new InputStreamReader(p.getInputStream());
BufferedReader in = new BufferedReader( isr ); // Step 4
while (in.ready()) System.out.println(in.readLine()); // The output
// Clean up
p.waitFor();
in.close();

Java IO – NIO
• JDK 1.4 introduced a package called java.nio
• "NIO" stands for “New I/O" support four important
features not previously well-provisioned in Java:
– A non-blocking I/O facility for writing scalable servers
– A file interface that supports locks and memory mapping
– A pattern-matching facility based on Perl-style regular
expressions
– Character-set encoders and decoders
• These features are implemented using two new
concepts: buffers and channels

Java IO – NIO
// Get a Channel for the file
File f = new File("email.txt");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
ByteBuffer bb1 = ByteBuffer.allocate((int)f.length());
// Once you have a buffer, you can read a file
int count = fc.read(bb1);
System.out.println("read "+ count + " bytes from email.txt");
fc.close();

Java IO – NIO
// Get a Channel for the file
FileOutputStream fos = new FileOutputStream("data.txt");
FileChannel fc = fos.getChannel();
while (true) {
// Try to get a lock
FileLock lock = fc.tryLock();
if (lock !=null) {
System.out.println("got lock");
lock.release();
}
}

05 Java Language And OOP Part V

More Related Content

What's hot (17)

Viewers also liked (7)

Similar to 05 Java Language And OOP Part V (20)

More from Hari Christian (6)

Recently uploaded (20)

05 Java Language And OOP Part V

Editor's Notes