FileInputStream和FileOutputStream如何在Java中工作？

Question

I'm reading about all input/output streams in java on Java Tutorials Docs . Tutorials writer use this example:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyBytes {
    public static void main(String[] args) throws IOException {

        FileInputStream in = null;
        FileOutputStream out = null;

        try {
            in = new FileInputStream("xanadu.txt");
            out = new FileOutputStream("outagain.txt");
            int c;

            while ((c = in.read()) != -1) {
                out.write(c);
            }
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }
}

xanadu.txt File data:

In Xanadu did Kubla Khan
A stately pleasure-dome decree:
Where Alph, the sacred river, ran
Through caverns measureless to man
Down to a sunless sea.

Output to outagain.txt file:

In Xanadu did Kubla Khan
A stately pleasure-dome decree:
Where Alph, the sacred river, ran
Through caverns measureless to man
Down to a sunless sea.

1. Why do the writers use int c even if we are reading characters?

2. Why use -1 in while condition?

3. How out.write(c); method convert int to again characters?

Answer 1

1: Now I want to ask why writer use int c? even we are reading characters.

FileInputStream.read() returns one byte of data as an int . This works because a byte can be represented as an int without loss of precision. See this answer to understand why int is returned instead of byte .

2: The second why use -1 in while condition?

When the end of file is reached, -1 is returned.

3: How out.write(c); method convert int to again characters? that provide same output in outagain.txt file

FileOutputStream.write() takes a byte parameter as an int . Since an int spans over more values than a byte, the 24 high-order bits of the given int are ignored, making it a byte-compatible value: an int in Java is always 32 bits . By removing the 24 high-order bits, you're down to a 8 bits value, ie a byte.

I suggest you read carefully the Javadocs for each of those method. As reference, they answer all of your questions:

read :

Reads the next byte of data from the input stream. The value byte is returned as an int in the range 0 to 255. If no byte is available because the end of the stream has been reached, the value -1 is returned. This method blocks until input data is available, the end of the stream is detected, or an exception is thrown.

write :

Writes the specified byte to this output stream. The general contract for write is that one byte is written to the output stream. The byte to be written is the eight low-order bits of the argument b. The 24 high-order bits of b are ignored.

Answer 2

Just read the docs.

here is the read method docs http://docs.oracle.com/javase/7/docs/api/java/io/FileInputStream.html#read()

public int read() throws IOException Reads a byte of data from this input stream. This method blocks if no input is yet available.

Specified by: read in class InputStream

Returns: the next byte of data, or -1 if the end of the file is reached.

That int is a your next set of bytes data. Now , here are the answers.

1) When you assign a char to an int, it denotes it's ascii number to the int.

If you are interested, here us the list of chars and their ascii codes https://www.cs.cmu.edu/~pattis/15-1XX/common/handouts/ascii.html

2)-1 if the end of the file is reached. So that's a check to data exists or not.

3)When you send an ascii code to print writer, it's prints that corresponding char to the file.