1 / 56

CS 1312

CS 1312. Introduction to Object Oriented Programming Lecture 10 Java’s String class Java File I/O. class java.lang.String. Recall that the type String is provided by the class String! Namely: java.lang.String

dulcinea-fernandez
Télécharger la présentation

CS 1312

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 1312 Introduction to Object Oriented Programming Lecture 10 Java’s String classJava File I/O

  2. class java.lang.String • Recall that the type String is provided by the class String! • Namely: java.lang.String • Strings are so common, Java makes some special allowances that make them seem somewhat like primitives. • String str = “Catfood”; • String strDitto = new String(“Catfood”); • Class String has many handy String manipulation methods allowing: • pattern matching • substring operations • conversion of case

  3. String concatenation revisited • recall concatenation operator + • beware:System.out.println(“three plus five is “ + 3 + 5);output: three plus five is 35 • correction:System.out.println(“three plus five is “ + (3 + 5));output: three plus five is 8

  4. Other String methods revisited • .length()returns the length of a String • .charAt( int )returns as a proper char, the single character indexed by int • .substring( int )returns the substring starting at index int and continuing until the end of the String • .substring( int1, int2 )returns the substring starting at index int1 (inclusive) and ending at index int2 (exclusive)

  5. substring methods revisited 0 1 2 3 4 S a s h a Example: String str = “Sasha”; String strSub = str.substring(1); System.out.println(strSub); strSub = str.substring(2,4); System.out.println(strSub); System.out.println(str.substring(1,1)); Output: asha sh <blank line>

  6. other methods revisited 0 1 2 3 4 S a s h a Example: String str = “Sasha”; String strSmall = str.substring(4); selects “a” strSmall = str.substring(5); selects “” strSmall = str.substring(6); throws java.lang.StringIndexOutOfBoundsException strSmall = str.substring(2,1);  throws java.lang.StringIndexOutOfBoundsException

  7. other methods revisited 0 1 2 3 4 S a s h a Example: String str = “Sasha”; String emptyOne = new String(); System.out.println(str.length()); System.out.println( str.substring(2,4).length()); System.out.println( str.substring(1,1).length()); System.out.println(“”.length()); System.out.println(emptyOne.length()); Output: 5 2 0 0 0

  8. String methods having to do with case • .equalsIgnoreCase()can test for equality between two strings while ignoring case • .toUpperCase()creates an uppercase version of a string • .toLowerCase()creates a lowercase version of a string Note: none of these actually modify the original String in any way.

  9. .toUpperCase() String str = “Dorfmeister”; String strBig = str.toUpperCase(); System.out.println(str); System.out.println(strBig); System.out.println(str.toUpperCase()); System.out.println(str); Output: Dorfmeister DORFMEISTER DORFMEISTER Dorfmeister

  10. .toLowerCase() String str = “Paul Oakenfold”;String strSmall = str.toLowerCase();System.out.println(str);System.out.println(strSmall);System.out.println(str.toLowerCase());System.out.println(str); Output: Paul Oakenfold paul oakenfold paul oakenfold Paul Oakenfold

  11. String comparisons String method .equals()versus String method .equalsIgnoreCase()String str1 = “HeLLo”;String str2 = “hello”;System.out.println( str1.equals(str2));System.out.println( str1.equalsIgnoreCase(str2)); Output: false true

  12. String comparisons (cont) String method .compareTo(String) Usage:String str1, str2;. . .if (str1.compareTo(str2) < 0) { // str1 is alphabetically 1st} else if (str1.compareTo(str2)==0) { // str1 equals str2} else { // implies str1 > str2 // str1 is alphabetically 2nd}

  13. What? String has a compareTo method?? Yes! Hmm….Does that have anything to do with the Comparable interface? Yes! It’s not just a coincidence!! The class String implements and satisfies the Comparable interface. Straight from the API: public final class String implements java.io.Serializable, Comparable { // blah blah… }

  14. A word about the API(application programmer interface) Straight from the API: public final class String implements java.io.Serializable, Comparable { // blah blah… } Notice how that looks exactly like code for a class you might write? Don’t be afraid of the API…it’s your friend!

  15. More tricks with Strings • .replace(char, char)replaces all occurrences of the first char with the second char specified • .trim()removes white space (spaces, newlines, tabs, etc) from both ends of the String Note: again, none of these actually modify the original String in any way.

  16. Examples using.replace(char, char) String str = “Carl Cartwright”; String strTwo; strTwo = str.replace(‘C’,‘K’); System.out.println(strTwo); str = “\tthis has two tabs\t” strTwo = str.replace(‘\t’, ‘\n’); System.out.println(strTwo); str = “take out spaces”.replace(‘ ‘, ‘’); Output: Karl Kartwright <blank line> this has two tabs <new line> Error!Cannot havean empty char

  17. Examples using.trim() String str = “ \n\n\tStuff \n ”; String strTwo; strTwo = str.trim(); System.out.println(strTwo); strTwo = “ this has blanks “.trim(); System.out.println(strTwo); .trim() doesn’t remove interior whitespace! Output: Stuff this has blanks

  18. Finding patterns with .indexOf(String) catfood 0123456 String str = “catfood”; int location = str.indexOf(“food”); System.out.println(“pattern food begins at ” + location); System.out.println( “pattern dog begins at ” + str.indexOf(“dog”)); -1 is returned when the pattern is not found! Output: pattern food begins at 3 pattern dog begins at -1

  19. Finding patterns with . .lastIndexOf(String) catfood 0123456 String str = “catfood”; int location = str.indexOf(“o”); System.out.println(“last o begins at ” + location); System.out.println( “last dog begins at ” + str.lastIndexOf(“dog”)); Output: last o begins at 5 last dog begins at -1 -1 is returned when the pattern is not found!

  20. Finding a pattern with .indexOf(String, int) Can specify the starting index for the pattern search. Useful if we want to find ALL occurrences! String str = “abracadabra abracadabra”; int index = str.indexOf(“abra”); while (index != -1) { System.out.println( “found at “ + index); index = str.indexOf(“abra”, index + 1); } // note the final –1 is not printed Output: found at 0 found at 7 found at 12 found at 19 again, -1 is returned when the pattern is not found!

  21. Testing if a string ends with the given pattern .endsWith() The method .endsWith(String) returns a boolean String str = “somebody@cc.gatech.edu”; if (str.endsWith(“.edu”)) System.out.println( str + “ is a school address”); else System.out.println( str + “ is not a school address”); Output: somebody@cc.gatech.edu is a school address

  22. Integer.parseInt(String) Integer.parseInt(String) is used to take a String representation and create from it an actual int. Exceptionthrown! String str = “125”; int j = Integer.parseInt(str); int k = Integer.parserInt(“-1020”); int wrong = Integer.parserInt(“-1020.55”); In each case, the String must actually have the proper form of an int, otherwise it throws java.lang.NumberFormatExceptionas shown by the third example above.

  23. Now on to the next topic: File I/O

  24. Java I/O: Fun with Streams • In general, there are streams inherent in any Java process: • System.in • System.out • System.err • You are already familiar with most of these streams. E.g., • System.out.println (“This is the out stream”);

  25. Java IO: The Big Picture • The System.in, System.out, and System.err streams are building blocks for more complex IO objects • Java’s JDK 1.02 contained particularly weak IO design. Many classes just didn’t work. • Instead of scrapping JDK 1.02, the Sun engineers extended the 1.02 library with JDK 1.1 • In general, the JDK 1.1 classes provide adequate IO. (In some instances, one still must use JDK 1.02.)

  26. Java IO -- Basic Divisions (1.0) InputStream: through inheritance, all derivatives of InputStream have the basic method “read()” to access a byte or an array of bytes OutputStream through inheritance, all derivatives of OutputStream have the basic method “write()” to write a single byte Java I/O is divided based on directional flow: Conceptually, the two are separate

  27. Types of InputStreams (1.0) Java’s InputStreams have six general flavors: Watch this class

  28. Decorator Classes • Java IO uses ‘decorator’ objects to provide layers of functionality to IO classes Concept: A ‘decorator pattern’ wraps the inner object, all using the same interface devices. Pro/Con: Flexibility with the cost of complexity Example: notice how many IO classes feature the “readLine()” method.

  29. FilterInputStream Class • The FilterInputStream offers a ‘grab bag’ of methods. • Sun: this is the base class for “enhancing input stream functionality” • Eckel: “[they] couldn’t figure out where else to put this stuff, but it seemed like it belonged together” TIJ (9th ed.) • Avoid it--use InputStreamReader (JDK 1.1)

  30. Keyboard Access: Use InputStreamReader (1.1) • For reading keystrokes, use an InputStreamReader • Wrap with a BufferedReader decorator: public IOHelper(boolean DEBUG) { this.DEBUG = DEBUG; /* For reading data from standard in (stdin)*/ iStreamReader = new InputStreamReader(System.in); keyboard = new BufferedReader(iStreamReader); } // constructor

  31. Hierarchy of BufferedReader InputStreamReader System.in BufferedReader

  32. BufferedReader in ActionReading from the Keyboard public String readLine() { String strInput =""; try { strInput = keyboard.readLine(); } catch (Exception e) { System.err.println (”Keyboard error:\n\t" + e.toString()); e.printStackTrace(); System.exit(0); } return strInput; } // readLine()

  33. Writing to a File import java.io.*; public class DoFileStuff { private PrintWriter outFile; public static void main(String[] args) { try { outFile = new PrintWriter( new FileWriter(“testout.txt”,true)); outFile.println(“this prints to file ”); outFile.close(); } catch (IOException e) { System.out.println(“problem with file”); } } // DoFileStuff

  34. Reading from a File import java.io.*; public class DoFileStuff { private BufferedReader inFile; public static void main(String[] args) { String line; try { inFile = new BufferedReader( new FileReader(“data.txt”)); while((line = inFile.readLine()) != null){ System.out.println(line); } // end while inFile.close(); } // end try catch (IOException e) { System.out.println(“problem with file”); } // end catch } // end class DoFileStuff

  35. BufferedReader • Notice how the BufferedReader created for reading from a file is basically the same as the one we created for reading from the keyboard! • That’s the benefit of using the same decorator objectnamely, BufferedReader, to wrap the inner object that does differ whether we have • input from the keyboard new InputStreamReader(System.in)) or • input from a filenew FileReader(“data.txt”)))

  36. The File Class (1.0) • Another important object in Java’s IO library is the File Class • Misnomer: the File class does not necessarily refer to a single file. It can represent the name of a single file, or the names of a set of files. • The method list() returns a String[] array of file names • Therefore, ‘filepath’ might have been a better name • There is no JDK 1.1 equivalent

  37. Using File to Obtain A Directory Listing public class Lister { public static void main (String args[]){ try{ File path = new File (“.”); String[] listing = path.list(); for(int i=0;i<=listing.length;i++) System.out.println(listing[i]); } //try catch(Exception bummer) { bummer.printStackTrace(); } } //main } //class

  38. A FilenameFilter Example public void printDirListing(){ final String[] list; /* MUST be final */ final File path = new File("."); /* MUST be final */ list = path.list( new FilenameFilter(){ public boolean accept (File dir, String n){ String f = new File(n).getName().toLowerCase(); /* don't list .java files */ return f.indexOf(".class") == -1 && f.indexOf(".java") == -1; } // accept } //FilenameFilter ); // anonymous inner class for (int i=0; i< list.length; i++) System.out.println ("\t"+list[i]); } // printDirListing()

  39. Object Serialization--eh? • Normally, objects live only during the life of the program. Stop the program, and the object disappears • JDK 1.1 offers the Serializable interface to create ‘lightweight persistence’. • Persistent objects live beyond the life of the program, usually in byte form on disk or on a network.

  40. Object Serialization • You may have heard about ‘object persistence’ as a new Java buzzword. • The Serializable interface provides this capability for lightweight persistence. • The Serializable interface is lightweight because one must manually create/load persistent objects. • This technique is necessary for remote method invocation (RMI), where objects live on another machine

  41. Object Serialization (cont) • Serialization is also necessary for Java Bean design, where functional components have state information created and saved during design, not runtime. • How does one serialize an object? Just have your class implement the Serializable interface and save appropriately

  42. Saving Serialized Objects • Simple: create an OutputStream, and wrap it with an ObjectOutputStream. • Twin methods: • writeObject(); • readObject(); /* requires InputStream wrapped by ObjectInputStream */ • Restoring objects requires a .class file! • Therefore, don’t modify your .java files!

  43. Externalization of Objects • JDK 1.1 also has the java.io.Externalizable class. • Externalization is different from serialization. • The Externalizable interface extends Serializable and adds two methods one must implement: public abstract void readExternal(ObjectInput in) throws IOException, ClassNotFoundException public abstract void writeExternal(ObjectOutput out) throws IOException

  44. Externalized Objects (cont) • Externalized Objects are similar to serialized objects, except that the objects themselves control the field creation during reading and writing. • The readExternal and writeExternal are called with readObject() and writeObject() • This produces greater security, and offers the possibility of selective serialization • Note Bene: Constructors for externalized objects must be public

  45. Serialization & the transient State • There may be a time when we want to serialize an object, but omit certain key features, like passwords or other sensitive data. • Even objects and data identified as private get serialized. How does one keep data out of externalized objects? • Solution: use the transient keyword: private transient String password = “pssst.”; • Data and methods identified as transient are not serialized.

  46. Networking Basics • This class is not about networking, but in order to use the java.net.* package and classes, you’ll have to be familiar with some networking concepts. • The following slides cover simple networking terminology.

  47. Basic Client-Server Relations User Process Application Transport Protocol stack in kernel Network Link • At a fundamental level, all networked applications divide into either client or server services. Client and server applications communicate with each other through some type of communications link--often an agreed protocol for sharing information. • It is often helpful to conceive of the network as a series of ‘layers’, representing different levels of abstraction. • At the top level, we have applications--web browsers, ftp programs, telnet applications. • This top-level software utilizes a ‘transport layer’ (TCP protocol) • Which in turn uses a network layer (IP protocol: e.g., IPv4) • Which in turn uses a link layer (ethernet protocol)

  48. The User-Process Level • For the most part, we will be utilizing the user-process level, and rely on TCP/IP protocols. • Defined: The Transport Control Protocol (TCP) is a connection-based protocol that provides reliable flow of data between two computers. • If time permits, we may take a look at UDP (user datagram protocol) communications as well. (In short: UDP has no guarantees that information will arrive, but it is considerably faster.)

  49. Ports & Sockets: What? • Generally, computers possess only a single physical connection to a network. All information arrives and departs through this connection. For many different applications to use this same connection, computers create logical groupings, or ports. • Together with an IP address--a unique number assigned to a machine on a network--a port allows one to identify a specific process on a specific machine. • A socket is a software abstraction that provides a terminus to a connection between machines; it’s a point of abstraction that allows for users to address a connection between machines.

  50. URLs: How To An essential part of any socket is the URL. A URL has two main components: Other components include: Host Name -- the name of the machine ‘hosting’ the resource Filename -- the pathname to the file on the host Port Number -- the port number to which to connect (typically optional). Reference -- a reference to a named anchor within a resource that usually identifies a specific location within a file (typically optional). URL = uniform resource locator

More Related