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
// 1
st
way
String s = new String();
s = "abcdef";

// 2
nd
way
String s = new String("abcdef");

// 3
rd
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);
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.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
}
}
Exception Try Catch
Example:
try {
throw new NullPointerException();
} catch (NullPointerException e) {
e.printStackTrace();
}
}
Exception Try Catch
Example:
try {
throw new FileNotFoundException();
} // Error cause expecting catch here
}
Exception Try Catch
Example:
try {
throw new FileNotFoundException();
// To make it short, just type Exception
// But this is not recommended
}
}
Exception Try Catch
Example:
try {
System.out.println(START);
String a = ;
a.trim();
System.out.println(FINISH);
}
}
Exception Try Catch
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

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.10\temp
/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();
}
}
Thank You

05 Java Language and OOP Part V

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

05 Java Language and OOP Part V

Hochgeladen von

Copyright:

Verfügbare Formate

Java Language and OOP

Das könnte Ihnen auch gefallen