05 Java Language And OOP Part V

  • 65 views
Uploaded on

Java Language And OOP Part V

Java Language And OOP Part V

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
65
On Slideshare
0
From Embeds
0
Number of Embeds
1

Actions

Shares
Downloads
9
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide
  • size = 5
    true
    size = 4
    a
    r
    i
    h
  • true true true false true
    b a 42 java.lang.Object@13985fc

    // Order is not guarantee
  • Error because we must implement comparable or comparator

Transcript

  • 1. Java Language and OOP Part V By Hari Christian
  • 2. 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
  • 3. 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
  • 4. 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
  • 5. 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";
  • 6. 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!"); // ?
  • 7. 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
  • 8. 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
  • 9. StringBuffer & StringBuilder • 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)
  • 10. StringBuffer & StringBuilder • 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
  • 11. 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
  • 12. 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();
  • 13. 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);
  • 14. 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
  • 15. 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
  • 16. 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); System.out.println("Date : " + sdf.format(calendar.getTime())); // Date : 2013 Dec 28 // Subtract 10 days calendar.add(Calendar.DAY_OF_MONTH, -10); System.out.println("Date : " + sdf.format(calendar.getTime())); // Date : 2013 Dec 18
  • 17. 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
  • 18. 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
  • 19. 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
  • 20. 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);
  • 21. 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);
  • 22. 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);
  • 23. 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)
  • 24. How Accurate are Calculation • 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
  • 25. How Accurate are Calculation • 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.
  • 26. How Accurate are Calculation 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);
  • 27. How Accurate are Calculation • 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
  • 28. How Accurate are Calculation • 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
  • 29. How Accurate are Calculation 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);
  • 30. How Accurate are Calculation • 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
  • 31. How Accurate are Calculation • 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
  • 32. 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"
  • 33. 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
  • 34. 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"
  • 35. 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
  • 36. 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)
  • 37. 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 }
  • 38. Exception – Try Catch • Example: public static void main(String[] args) { try { // put potentially statement error } catch (Exception e) { // put potentially statement handle } }
  • 39. Exception – Try Catch • Example: public static void main(String[] args) { try { throw new NullPointerException(); } catch (NullPointerException e) { e.printStackTrace(); } }
  • 40. Exception – Try Catch • Example: public static void main(String[] args) { try { throw new FileNotFoundException(); } catch (NullPointerException e) { e.printStackTrace(); } // Error cause expecting catch here }
  • 41. Exception – Try Catch • Example: public static void main(String[] args) { try { throw new FileNotFoundException(); } catch (Exception e) { // To make it short, just type Exception // But this is not recommended } }
  • 42. Exception – Try Catch • Example: public static void main(String[] args) { try { System.out.println(“START”); String a = “”; a.trim(); System.out.println(“FINISH”); } catch (NullPointerException e) { e.printStackTrace(); }
  • 43. Exception – Try Catch • Example: public static void main(String[] args) { try { System.out.println(“START”); String a; a.trim(); System.out.println(“FINISH”); } catch (NullPointerException e) { e.printStackTrace(); }
  • 44. Exception – Throws public class ThrowsTest { public Integer calculate() throws Exception { return null; } public static void main(String[] args) { try { ThrowsTest tt = new ThrowsTest(); Integer result = tt.calculate(); System.out.println(result.intValue()); } catch (Exception e) { e.printStackTrace(); } }
  • 45. Exception – Finally public static void main(String[] args) { try { System.out.println(“TRY”); } catch (NullPointerException e) { System.out.println(“CATCH”); } finally { System.out.println(“FINALLY”); } }
  • 46. Exception – Finally public static void main(String[] args) { try { System.out.println(“START TRY”); String a; a.trim(); System.out.println(“FINISH TRY”); } catch (NullPointerException e) { System.out.println(“CATCH”); } finally { System.out.println(“FINALLY”); } }
  • 47. 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)
  • 48. Collection - Basic
  • 49. 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
  • 50. 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
  • 51. 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);
  • 52. Collection - List • There are 3 implementation of Lists: – ArrayList – Vector – LinkedList
  • 53. 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
  • 54. Collection - ArrayList • 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
  • 55. Collection - ArrayList 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); }
  • 56. 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
  • 57. 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
  • 58. 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
  • 59. Collection - Set • There are 3 implementation of Lists: – HashSet – LinkedHashSet – TreeSet
  • 60. 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
  • 61. 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 + " ");
  • 62. Collection - LinkedHashSet • A LinkedHashSet is an ordered version of HashSet • Use this class instead of HashSet when you care about the iteration order
  • 63. 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
  • 64. Collection - TreeSet • 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
  • 65. Collection - TreeSet 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 + " ");
  • 66. 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
  • 67. 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
  • 68. 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
  • 69. Collection - Map • There are 4 implementation of Lists: – HashMap – Hashtable – LinkedHashMap – TreeMap
  • 70. 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
  • 71. Collection - HashMap • 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
  • 72. Collection - HashMap 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);
  • 73. Collection - Hashtable • Hashtable is a syncronized version of HashMap • HashMap disallow null key and null value
  • 74. 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
  • 75. 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
  • 76. 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);
  • 77. 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
  • 78. Collection – Helper Class • Some helpful methods in Collections: – Sort – Binary Search – Reverse – Shuffle – Swap – Copy – Rotate – Replace All
  • 79. Collection – Helper Class public static void main(String[] args) { 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 ); }
  • 80. 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
  • 81. 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>();
  • 82. 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
  • 83. 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
  • 84. 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
  • 85. Java IO - Portability of I/O • Example: String EOL = System.getProperty("line.separator"); String path = “C:” + File.separator + “test.txt”;
  • 86. 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
  • 87. 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);
  • 88. 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();
  • 89. 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();
  • 90. 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();
  • 91. Java IO - File // using temporary files public boolean createNewFile(); public boolean delete(); public void deleteOnExit(); File createTempFile(String, String); File createTempFile(String, String, File);
  • 92. 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();
  • 93. 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();
  • 94. 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();
  • 95. 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();
  • 96. 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)
  • 97. 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();
  • 98. 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();
  • 99. 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); }
  • 100. 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 );
  • 101. 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); }
  • 102. 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());
  • 103. 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);
  • 104. 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"
  • 105. 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();
  • 106. 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
  • 107. 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();
  • 108. 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
  • 109. 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();
  • 110. 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(); } }
  • 111. Thank You