Richiami di Java

1. Richiami di Java Input/Output

2. Raw IO from stdin,stdout import java.io.*; public class Simple { public static void main(String a[]){ new Simple(); } public Simple() { byte buffer[]=new byte[100]; String s=null; System.out.println("Dammi una stringa"); try { int letti=System.in.read(buffer); s=new String(buffer,0,letti); } catch (IOException e) { e.printSTackTrace(); } System.out.println(s.length()+":"+s.indexOf('\n')+":"+s); } }

3. Simple IO from stdin,stdout import java.io.*; public class Simple { public static void main(String a[]){ new Simple(); } public Simple() { BufferedReader is=new BufferedReader( new InputStreamReader(System.in)); System.out.println("Dammi una stringa"); try { s=is.readLine(); } catch (IOException e) { e.printStackTrace();} System.out.println(s.length()+":"+s.indexOf('\n')+":"+s); } }

4. Reading an int from stdin import java.io.*; public class Simple { public static void main(String a[]){ new Simple(); } public Simple() { BufferedReader is=new BufferedReader(new InputStreamReader(System.in)); int i=0; System.out.println("Dammi un int"); try { s=is.readLine(); } catch (IOException e) { e.printStackTrace();} try{ i=Integer.parseInt(s); } catch (NumberFormatException e) { System.out.println("Input non valido"); } System.out.println("Hai scritto "+i); } }

5. package IO; import java.awt.*; import java.io.*; public class Application1 { public static void main(String[] args) { new Application1(); } public Application1() { Frame fr=new Frame(); FileDialog fd=new FileDialog(fr); fd.show(); String filename=fd.getFile(); String pathname=fd.getDirectory(); System.out.println(pathname+" "+filename); File file=new File(pathname,filename); try { FileWriter fw=new FileWriter(file); fw.write("Hello World"); fw.close(); } catch (IOException e) {} try {Thread.sleep(20000);} catch(Exception e){} } }

6. Streams To bring in information, a program opens a stream on an information source (a file, memory, a socket) and reads the information serially, like this:

7. Similarly, a program can send information to an external destination by opening a stream to a destination and writing the information out serially, like this: Streams

8. Reading Writing open a stream while more information read information close the stream open a stream while more information write information close the stream Streams No matter where the information is coming from or going to and no matter what type of data is being read or written, the algorithms for reading and writing data is pretty much always the same.

9. Streams The java.io  package contains a collection of stream classes that support these algorithms for reading and writing. These classes are divided into two class hierarchies based on the data type (either characters or bytes) on which they operate.

10. However, it's often more convenient to group the classes based on their purpose rather than on the data type they read and write. Thus, we can cross-group the streams by whether they read from and write to data "sinks" or process the information as its being read or written.

11. Character Streams Reader and Writer are the abstract superclasses for character streams in java.io. Reader provides the API and partial implementation for readers--streams that read 16-bit characters--and Writer provides the API and partial implementation for writers--streams that write 16-bit characters. Subclasses of Reader and Writer implement specialized streams and are divided into two categories: those that read from or write to data sinks (shown in gray in the following figures) and those that perform some sort of processing (shown in white).

12. Character Streams

13. Byte Streams Programs should use the byte streams, descendants of InputStream and OutputStream, to read and write 8-bit bytes. InputStream and OutputStream provide the API and some implementation for input streams (streams that read 8-bit bytes) and output streams (streams that write 8-bit bytes). These streams are typically used to read and write binary data such as images and sounds. As with Reader and Writer, subclasses of InputStream and OutputStream provide specialized I/O that falls into two categories: data sink streams and processing streams.

14. IO superclasses - reading Understanding the I/O Superclasses Reader and InputStream define similar APIs but for different data types. For example, Reader contains these methods for reading characters and arrays of characters: int read() int read(char cbuf[]) int read(char cbuf[], int offset, int length) InputStream defines the same methods but for reading bytes and arrays of bytes: int read() int read(byte cbuf[]) int read(byte cbuf[], int offset, int length) Also, both Reader and InputStream provide methods for marking a location in the stream, skipping input, and resetting the current position.

15. IO superclasses - writing Understanding the I/O Superclasses Writer and OutputStream are similarly parallel. Writer defines these methods for writing characters and arrays of characters: int write(int c) int write(char cbuf[ ]) int write(char cbuf[ ], int offset, int length) And OutputStream defines the same methods but for bytes: int write(int c) int write(byte cbuf[ ]) int write(byte cbuf[ ], int offset, int length) All of the streams--readers, writers, input streams, and output streams--are automatically opened when created. You can close any stream explicitly by calling its close method. Or the garbage collector can implicitly close it, which occurs when the object is no longer referenced.

16. Standard IO • The Standard I/O Streams • The concept of standard input and output streams is a C library concept that has been assimilated into the Java environment. There are three standard streams, all of which are managed by the java.lang.System class: • Standard input--referenced by System.in (instance of InputStream) • Used for program input, typically reads input entered by the user. • Standard output--referenced by System.out(instance of PrintStream) • Used for program output, typically displays information to the user. • Standard error--referenced by System.err(instance of PrintStream) • Used to display error messages to the user.

17. Data sink streams

18. Processing streams

19. Processing streams

20. Classi accessorie • File • Represents a file on the native file system. You can create a File object for a file on the native file system and then query the object for information about that file (such as its full pathname). • FileDescriptor • Represents a file handle (or descriptor) to an open file or an open socket. You will not typically use this class. • StreamTokenizer • Breaks the contents of a stream into tokens. Tokens are the smallest unit recognized by a text-parsing algorithm (such as words, symbols, and so on). A StreamTokenizer object can be used to parse any text file. For example, you could use it to parse a Java source file into variable names, operators, and so on, or to parse an HTML file into HTML tags. • FilenameFilter • Used by the list method in the File class to determine which files in a directory to list. The FilenameFilter accepts or rejects files based on their names. You could use FilenameFilter to implement simple regular expression style file search patterns such as foo*.

21. Classi accessorie • CheckedInputStream and CheckedOutputStream • An input and output stream pair that maintains a checksum as the data is being read or written. • DeflaterOutputStreamand InflaterInputStream • Compresses or uncompresses the data as it is being read or written. • GZIPInputStream and GZIPOutputStream • Reads and writes compressed data in the GZIP format. • ZipInputStream and ZipOutputStream • Reads and writes compressed data in the ZIP format.

22. Esempio 1 Input/Output

23. Esempio: copy - 1 import java.io.*; public class Copy { public static void main(String[] args) throws IOException { File inputFile = new File(“originale.txt"); File outputFile = new File(“copia.txt"); FileReader in = new FileReader(inputFile); FileWriter out = new FileWriter(outputFile); int c; while ((c = in.read()) != -1) out.write(c); in.close(); out.close(); } } Copy

24. Esempio: copy - 2 Remember that FileReader and FileWriter read and write 16-bit characters. However, most native file systems are based on 8-bit bytes. These streams encode the characters as they operate according to the default character-encoding scheme. You can find out the default character-encoding by using System.getProperty("file.encoding"). To specify an encoding other than the default, you should construct an OutputStreamWriter on a FileOutputStream and specify it.

25. Esempio: copy - 3 public class CopyBytes { public static void main(String[] args) throws IOException{ File inputFile = new File(“originale.txt"); File outputFile = new File(“copia.txt"); FileInputStream in = new FileInputStream(inputFile); FileOutputStream out = new FileOutputStream(outputFile); int c; while ((c = in.read()) != -1) out.write(c); in.close() out.close(); } } CopyBytes

26. Rhyming words - 1 Rhyming words Without pipe streams, the program would have to store the results somewhere (such as in a file or in memory) between each step, as shown here: With pipe streams, the output from one method could be piped into the next, as shown in this figure:

27. Esempio 2 Input/Output

28. Rhyming words - 2 import java.io.*; public class RhymingWords { public static void main(String[] args) throws IOException { FileReader words = new FileReader("words.txt"); // do the reversing and sorting Reader rhymedWords = reverse(sort(reverse(words))); // write new list to standard out BufferedReader in = new BufferedReader(rhymedWords); String input; while ((input = in.readLine()) != null) System.out.println(input); in.close(); } RhymingWords

29. Rhyming words - 3 public static Reader reverse(Reader source) throws IOException { BufferedReader in = new BufferedReader(source); PipedWriter pipeOut = new PipedWriter(); PipedReader pipeIn = new PipedReader(pipeOut); PrintWriter out = new PrintWriter(pipeOut); new ReverseThread(out, in).start(); return pipeIn; } public static Reader sort(Reader source) throws IOException { BufferedReader in = new BufferedReader(source); PipedWriter pipeOut = new PipedWriter(); PipedReader pipeIn = new PipedReader(pipeOut); PrintWriter out = new PrintWriter(pipeOut); new SortThread(out, in).start(); return pipeIn; } } RhymingWords

30. Rhyming words - 4 import java.io.*; public class ReverseThread extends Thread { private PrintWriter out = null; private BufferedReader in = null; public ReverseThread(PrintWriter out, BufferedReader in) { this.out = out; this.in = in; } ReverseThread

31. Rhyming words - 5 public void run() { if (out != null && in != null) { try { String input; while ((input = in.readLine()) != null) { out.println(reverseIt(input)); out.flush(); } out.close(); } catch (IOException e) { System.err.println("ReverseThread run: " + e); } } } ReverseThread

32. Rhyming words - 6 private String reverseIt(String source) { int i, len = source.length(); StringBuffer dest = new StringBuffer(len); for (i = (len - 1); i >= 0; i--) dest.append(source.charAt(i)); return dest.toString(); } } ReverseThread

33. Rhyming words - 7 import java.io.*; public class SortThread extends Thread { private PrintWriter out = null; private BufferedReader in = null; public SortThread(PrintWriter out, BufferedReader in) { this.out = out; this.in = in; } SortThread