[04-9-20] [from SUN Technology Community]
-------------------------------------------------- ------------------------------ completely understand Java's IO system author: pdfjn5198
One. INPUT and OUTPUT1. Stream represents any data source that has the ability to output data, or any capacity to receive data receiving source. In Java's IO, all streams include two types: 1.1 Byte-oriented stream in byte-oriented Stream, indicating bytes, read or read from Stream in bytes or Write information into the stream. Byte oriented stream comprises the following types: 1) input stream: 1) ByteArrayInputStream: the use of a buffer memory 2) StringBufferInputStream as InputStream: a String object to a InputStream3) FileInputStream: to a file as InputStream Realize the reading operation of the file 4) PipedinputStream: implements the concept of PIPE, mainly in the thread 5) SEQUENCEINPUTSTREAM: Multiple InputStream is merged into an inputStream2) BYTEARRAYOTPUTSTREAM: put information into a buffer in memory District 2) FileOutputStream: PipedputStream: PipedputStream: Implement the concept of PIPE, mainly in the thread 4) SEQUENCEOTPUTSTREAM: Multiple OutStream merge into an outstream1.2 in Unicode Character-oriented Stream in Unicode Character-oriented Stream indicates that the information is read from the stream in units in Unicode characters to the stream. In Unicode character oriented stream comprises the following types: 1) Input Stream1) CharArrayReader: corresponds with ByteArrayInputStream 2) StringReader: corresponds with StringBufferInputStream 3) FileReader: corresponds with FileInputStream 4) PipedReader: corresponds with PipedInputStream 2) Out Stream1) CharArrayWrite : Corresponding to byterrayoutputstream 2) StringWrite: Corresponding to byte-oriented Stream3) FileWrite: with FileoutPutStream Corresponds 4) PiPedWrite: The word corresponding to the PiPedoutputStream corresponds to the word. Section-oriented stream. The two corresponding classes implementation are the same, the word is different during operation. For example, CharaRrayReader: and ByTearRayinputStream uses a buffer in memory as an inputStream, which is different that the former reads a byte information from memory, while the latter reads a character from memory. 1.3 Conversion between two unsampicated streams InputStreamReader and OutputStreamReader: Convert a byte-oriented Stream into a character-oriented Stream.
2. Stream Add Properties 2.1 "Add Property for Stream Add Properties" to operate the IO's API in the Java described above, we can complete any operation we want to complete. But through the subclasses of FilterInputStream and FilterOutstream, we can add properties to Stream. The following examples illustrate the function of this function. If we want to write data into a file, we can do this: FileoutStream Fs = New FileoutStream ("Test.txt"); then you can call the Write () function to call the west.txt file by generating FS objects. Data. However, if we want to implement "first to write the data to the file first caching into memory, then the API above the data is written in the file", the above API does not have a meeting to meet our needs. But add our needs to FileoutStream through FilterInputStream and FilteroutStream. 2.2 FilterInputStream's various types 2.2.1 for encapsulation of bytes-oriented InputStream1) DataInputStream: Read basic types (int, char, etc.) data from Stream. 2) BufferedInputStream: Using the buffer 3) LINENUMBERINPUTSTREAM: The number of rows within the input stream can then call getLineNumber () and setLinenumber (int) 4) PushbackInputStream: Little use, generally used for compiler development 2.2.2 There is no class corresponding to the DataInputStream in the package with character-oriented InputStream1). Unless the switch is to be used in BufferedReader readLine (), otherwise the DataInputStream2) BufferedReader: correspondence with BufferedInputStream 3) LineNumberReader: corresponds with LineNumberInputStream 4) PushBackReader: 2.3 FilterOutStream corresponding to the various types PushbackInputStream bytes for packaging 2.2.3 Oriented OutputStream1) DataiOutstream: Outputs Basic Types (INT, CHAR, etc.) data into Stream. 2) BufferedOutstream: Using Buffer 3) PrintStream: Generates Format Output 2.2.4 Used to Pack the Character-oriented OutputStream1) BUFFEREDWRITE: and Correspondence 2) PrintWrite: with the corresponding 3. RandomaccessFile1) You can complete the file via the RandomaccessFile object. Reading and writing operation 2) When generating an object, you can indicate the nature of the file to be opened: R, read-only; W, write only; RW Readable Writing 3) You can jump directly to the location specified in the file.
4. An example of I / O application Import java.io. *; Public class testio {public static void main (string [] args) throws oxtception {// 1. Read data from one file from a file BUFFEREDREADER IN = New BufferedReader (New FileReader ("f: //nepalon/testio.java"); string s, s2 = new string (); while ((s = in.readline ())! = Null) S2 = S "/ n"; in .close (); // 1b. Entering the keyboard into bufferedreader stdin = new bufferedreader (system.in)); System.out.Println ("Enter a line:"); system. Out.println (stdin.readline ());
// 2. Read data from a String object StringReader in2 = new stringReader (S2); INT C; while ((c = in2.read ())! = -1) System.out.println ((char) C In2.Close ();
// 3. Remove the formatting input from memory Try {DataInputStream in3 = New DataAnputStream (new byterrayinputstream (s2.getbytes ()); while (true) system.out.println ((char) in3.Readbyte ());} Catch (EOFEXCEPTION E) {System.out.println ("End of Stream");
// 4. Output to file try {buffredreader in4 = new buffredreader (new stringReader (new stringReader (new bufferedwriter (New FileWriter (New FileWriter (New FileWriter ("f: // nepalon // Testio.out")))) INT lineCount = 1; while ((s = in4.readline ())! = null) Out1.println (LineCount ": S); Out1.close (); in4.close ();} catch (EOFException EX) ) {System.out.println ("end of stream");
// 5 the data storage and recovery try {DataOutputStream out2 = new DataOutputStream (new BufferedOutputStream (new FileOutputStream ( "F: // nepalon // Data.txt"))); out2.writeDouble (3.1415926); out2.writeChars ( "/ nThas was pi: writeChars / n"); out2.writeBytes ( "Thas was pi: writeByte / n"); out2.close (); DataInputStream in5 = new DataInputStream (new BufferedInputStream (new FileInputStream ( "F: // Nepalon // data.txt "))))))); BufferedReader In5Br = New BufferedReader (IN5); System.Out.println (In5.ReadDouble ()); System.out.Println (In5br.Readline ()); System.out.println (In5br.Readline ());} catch (eofexception e) {system.out.println ("end of stream");} // 6. RandomaccessFile RF = new randomaccessfile ("f" via randomaccessfile action file : // Nepalon // RTEST.DAT "," RW "); for (int i = 0; i <10; i ) rf.writeDouble (i * 1.414); rf.close ();
Rf = new randomaccessfile ("f: // nepalon // rtest.dat", "r"); for (int i = 0; i <10; i ) system.out.println ("Value" i ": " rf.readdouble ()); rf.close ();
Rf = new randomaccessfile ("f: // nepalon // rtest.dat", "rw"); rf.seek (5 * 8); rf.writeDouble (47.0001); rf.close ();
Rf = new randomaccessfile ("f: // nepalon // rtest.dat", "r"); for (int i = 0; i <10; i ) system.out.println ("Value" i ": " rf.readdouble ()); rf.close ();}} About code interpretation (in the area): In the zone, when the file is read, first read the contents of the file to the cache, when calling in .readline (), the data (hereinafter referred to as "cache byte reading mode") is read from the cache. In the 1b area, since the data is read from the standard IO (keyboard) from the standard IO (keyboard) by cache byte reading, the standard IO (system.in) is first converted to the Character-oriented Stream, and then the BUFFEREDReader package is performed. In the zone, you should read data from a String object in a form of characters, so a StringReader type Stream is created. In the zone, when the data STRING object S2 reads the data, first put the data in the object, and then read from the buffer; when the Testio.out file is operated, the formatted information is output to In the cache, the information in the cache is output to the file. In the 5th district, when the data.txt file is output, it is first to output the basic type of data output housing cache, and then output the data in the cache to the file; when the file is read, the data in the file first Read to the cache, then read from the cache in the basic type of form. Note in5.Readdouble (). Because write the first WriteDouble (), in order to be displayed correctly. It is also necessary to read in the form of a basic type. The 6 district is operated by the RandomaccessFile class. [Edit on 2004-09-20 11:08:23 by aeonsun]
-------------------------------------------------- ------------------------------ This diary Trackback Address: http://aeonsun.polyhero.net/trackback.do?log_id = 16 in [Reposted and Collection] by [aeonsun] AT 04-9-20 10:48 | Comments [10] | TB [0] | 92 Views
≡≡ users review ≡≡≡ aeonsun netizen said: Important Tips:
LINENUMBERINPUTSTREAM, StringBufferInputStream has been abolished! Don't use it again!
LINENUMBERINPUTSTREAM, this Class Does Not Properly Convert Characters Into Bytes!
StringBufferInputStream, Deprecated. This class incorrectly assuments That Bytes adequately represent character! AT 04-09-20 10:49 AEONSUN netizen said: There is no readline () throughout the DataInputStream stream!
Replace with: BufferedReader D = New BufferedReader (in);
-------- Translate the word throt into a character stream access cache read the character stream, then process! This method is very advantageous! --------------------------------------- Why use character streams? ------ ------------ The primary advantage of character streams is that they make it easy to write programs that are not dependent upon a specific character encoding, and are therefore easy to internationalize. Java stores strings in Unicode, an international standard character encoding that is capable of representing most of the world's written languages. Typical user-readable text files, however, use encodings that are not necessarily related to Unicode, or even to ASCII, and there are many such encodings. Character streams hide the complexity of dealing with these encodings by providing two classes that serve as bridges between byte streams and character streams. The InputStreamReader class implements a character-input stream that reads bytes from a byte-input stream and converts them to characters according to a specified Encoding. Similarly, The OutputStreamwriter Class Implements a Character-Output Stream That Converts CHARACTERS INTO BYTES According a Specified Encoding and Writes Them to A Byte-Output Stream.
A second advantage of character streams is that they are potentially much more efficient than byte streams. The implementations of many of Java's original byte streams are oriented around byte-at-a-time read and write operations. The character-stream classes, in contrast , are oriented around buffer-at-a-time read and write operations. This difference, in combination with a more efficient locking scheme, allows the character stream classes to make up for the added overhead of encoding conversion in many cases. at 04- 09-20 10:49 AEONSUN netizen said: ---------- Standard device system.in read data ---------------------- -------------------------------------------------read BUFFEREDINPUTSTREAM Read characters: BufferedReader InputStreamReader ---------------------------------------------------------------------------------------------------------------------------------- ------- Import java.io. *; public class systemin {public static void main (string args []) {try {// stream conversion! BufferedReader is = new BufferedReader (new InputStreamReader (System.in)) String inputline = null; while (! (Inputline = is.readLine ()) = null) System.out.println (inputline); is.close ();} Catch (IOEXCEPTION E) {System, Out.println ("IOXE:" E);}}} --------------------------- -------------------------------------------------- ---
----------------- Standard Output System.out is a PrintStream --------------------- Import Java . "
Public class printstandardoutput {
Public static void main (string [] args) {string myanswer = "no, and what's final,"; system.out.println ("Hello World of Java"); System.out.Println ("The Answer IS" Myanswer "at this time.");
PrintWriter PW = New PrintWriter (System.out); PW.Println ("The Answer IS" Myanswer "At this Time.");
INT i = 42; PW.Println (i '=' "The answer."); PW.Println ("NOTE:" i '=' "the answer."); PW.Println (i "=" "The answer."); PW.Println (i ('=' "the answer.")); PW.Close ();}} ------------ -------------------------------------------------- -------------------------------------------- To read (output to -) A text file -----------------------------
BufferedReader is = New BufferedReader ("xxxx.text"); read bufferedoutputstream byte = new buffutstream (New fileoutputstream ("xx.dat")); // Write to text!
---------------------------------------------- AT 04- 09-20 10:49 aeonsun user said: import java.io *; public class OpenFileByName {public static void main (String [] args) throws IOException {BufferedReader is = new BufferedReader (new FileReader ( "myFile.txt")). BufferedoutputStream Bytesout = New BufferedoutputStream (New FileoutPutStream ("Bytes.dat");
// code here to read from is, Write to bytesout
Bytesout.close ();}} at 04-09-20 10:50 AEONSUN netizen said: Import java.io. *;
Public class fileio {
PRIVATEIO () {}
public static void copyFile (String inName, String outName) throws FileNotFoundException, IOException {BufferedInputStream is = new BufferedInputStream (new FileInputStream (inName)); BufferedOutputStream os = new BufferedOutputStream (new FileOutputStream (outName)); copyFile (is, os, true) }
/ ** Copy a file from an opened InputStream to opened OutputStream * / public static void copyFile (InputStream is, OutputStream os, boolean close) throws IOException {int b;! While ((b = is.read ()) = -1 {os.write (b);} is.close (); if (close) os.close ();} public static void copyfile (Reader IS, Writer Os, Boolean Close) throws oException {Int B; While B = is.read ())! = -1) {os.write (b);} is.close (); if (close) os.close ();}
public static void copyFile (String inName, PrintWriter pw, boolean close) throws FileNotFoundException, IOException {BufferedReader is = new BufferedReader (new FileReader (inName)); copyFile (is, pw, close);}
public static String readLine (String inName) throws FileNotFoundException, IOException {BufferedReader is = new BufferedReader (new FileReader (inName)); String line = null; line = is.readLine (); is.close (); return line;}
Protected static final INT BLKSIZ = 8192;
public void copyFileBuffered (String inName, String outName) throwsFileNotFoundException, IOException {InputStream is = new FileInputStream (inName); OutputStream os = new FileOutputStream (outName); int count = 0; byte b [] = new byte [BLKSIZ]; while ( (count = is.read (b))! = -1) {Os.Write (B, 0, count);} is.close (); os.close ();}
Public static string readertostring (reader is) throws ioException {stringbuffer sb = new stringbuffer (); char [] b = new char [blks); int N;
While ((n = is.read (b))> 0) {sb.append (b, 0, n);}
Return sb.toString ();
Public Static String InputStreamTString (InputStream IS) THROWS IOEXCEPTION {Return ReadertString (New InputStreamReader (IS));
public static void stringToFile (String text, String fileName) throws IOException {BufferedWriter os = new BufferedWriter (new FileWriter (fileName)); os.write (text); os.flush (); os.close ();} public static BufferedReader OpenFile (String FileName) throws ooException {return new bufferedreader (new filereader);}} AT 04-09-20 10:50 AEONSUN netizen said: Import Java, IO. *;
Class fileprocess {
Public static void main (string args []) {int b; byte buffer [] = new byte [1000]; try {b = system.out.read (buffer); // Access data for writing! FileOutputStream OUT = New FileootStream ("line.text"); Out.write (buffer, 0, b); // Write! Pay attention to the relationship between byte buffer file streams] Catch (IOException e) {system.out.println ("error");}]} AT 04-09-20 10:50 aeonsun netizen said: Import Java, IO. *;
public class read {public static void main (String args [] 0 {int b; byte buffer = new byte [2000]; try {FileInputStream readfile = new FileInputStream ( "XXXX.java"); b = readfile (buffer, 0, 25000); try {string str = NRE STRING (Buffer, 0, B, "Default"); // Construct String object! System.out.println (STR);} catch (unsuportEncodeIndexcection) {E.PrintStackTrace (); } catch (ioException e) {system.out.println ("error");}}} AT 04-09-20 10:51 AEONSUN netizen said: --------------- Utilization BufferedReader - FileReader reads text files! -----------
--------------- Always pay attention to byte stream or character stream ---------------------------------------------------------------------------------------------------------------- -------------------------------------------------- --------------------- Import java.io. *; import java.awt. *; import javax.swing. *; import java.awt.event. * ;
class filewindow extends JFrame implements ActionListener {JTextArea text; BufferedReader in; JButton button; FileReader file; filewindow () {super ( "character stream file"); Container con = getContentPane (); text = new JTextArea (50,50); text .SetBackground (color.blue); try {file f = new file ("e: //a.txt"); file = new fileReader (f); in = new buffreader (file); / ** buffredReader (Reader in Constructive function, * file self-character reading flow FileReader access to the bufferedReader * stream in order to use the bufferedreader object method readline () high-efficient to read! * /} catch (filenotfoundexception e) {} catch (ooException e) {} button = new jbutton ("Read"); button.addactionListener (this); con.setLayout (New borderLayout ()); setsize (300, 200); SetVisible (TRUE);
Con. AD (Text, "Center"); Con.com (Button, "South"); addwindowlistener (new windowadapter () {public void windowclosing (windowevent e) {setvisible (false); system.exit (0);} });
} public void actionperformed (ActionEvent E) {string s; if (E.GetSource () == Button) Try {while ((s = in.readline ())! = null) Text.Append (s '/ n') / / Here you can also use bufferstring to temporarily save the read character data! } catch (ioException E1) {}} // --------- main () ---------- Public static void main (string args []) {filewindow win = new filewindow ); win.pack ();}} AT 04-09-20 10:51 AEONSUN netizen said: ------------------ randomaccessfile Randomly read files --- ------------ Import java.io. *;
Public class randomread {final static string filename = "e: //a.txt"; protected string filename; protected randomaccessfile seeker;
Public static void main (string [] argv) throws ioException {randomread r = new randomread (filename);
System.out.println ("Offset IS" R.Readoffset ()); System.out.Println ("Message IS /" R.ReadMessage () "/".
/ ** Constructor: save filename, construct RandomAccessFile * / public RandomRead (String fname) throws IOException {fileName = fname; seeker = new RandomAccessFile (fname, "rw");} / ** Read the Offset field, defined to be at Location 0 in the file. * / public int ready {seeker.seek (0); seeker.writechars (filename); //move to very beginning (); // and read the offset}
/ ** read the message at the given offset * / public string readMessage () throws oException {seeker.seek (120); // move to wherereturn seeker.readline (); // and read the string}} at 04-09 -20 10:51 AEONSUN netizen said: some comments: Axman
It's hard to write, I didn't want to say anything, but I said that the spirit of the technical responsibility is said.
For I / O understanding belongs to level 3 level (if Java IO has ten levels), there is too much error. For I / O levels, it is not familiar with Java IO, mainly including Java.IO packages and java.nio packages.
Java.io mainly extends from four interfaces: InputStream / OutputStream, which is the specific implementation of the package, filtration, and specific object processing. Character: Reader / Writer (original Writer interface is written to WRITE, enough to explain the fundamental Don't understand this interface, if you often use the Writer interface how Writer and Write are unclear, not a mistake, but all is Write
In the above four interfaces, the bottom layer is all the blocked manner flow.
Java.io mainly is mainly based on block operation block, greatly enabled the performance of data output input through the blocking and non-shaped mode, and can be achieved by selecting the CHANNEL by selecting the selector mode. Multi-user in the same output input channel, data transfer is performed. For example, a Socket port can be simultaneously accessed by unlimited (theoretically unrestricted) client. It is a classic I / O multi-channel multiplexing technology.
