為什么 write() 和 read() 似乎寫入和讀取超過一個字節？

Question

在Java ，一個byte可以容納的最大值是 127，也就是 8 位。 此外， FileInputStream使用的 read() 方法（它繼承自InputStream ）聲明它只讀取一個byte ，而FileOutputStream使用的 write() 方法（它繼承自OutputStream ）聲明它只寫入一個byte 。 但是，當我將一個大於 127 但小於 256 的數字傳遞給 write() 然后 read() 它時，我得到一個十進制值確實在 127 和 255 之間的字符。這似乎表明 write() 可以實際上寫入 9 位而不是 8，而 read() 實際上可以讀取 9 位而不是 8。所以，我的問題是這怎么可能？ read() 如何讀取多於一個byte而 write() 如何寫入多於一個byte ？ 還有什么我想念的嗎？

再舉一個例子，假設我將整數 1000 傳遞給 write()。 write() 然后輸出一個字符，然后 read() 讀取為十進制值 232。這似乎是因為 1000 - 512 - 256 = 232，這似乎再次表明 write() 和 read() 寫入和讀取 9 位（最多 255）而不是一個字節（8 位，最多 127）。 在我看來，write() 正在寫入 1000 的低 9 位，然后 read() 讀取，在這種情況下給出 232。

我已經發布了我用來測試這一切的程序。 另外，我對Java還很Java ，所以非常感謝任何幫助或想法！

import java.io.*;

public class TestingCharsAndBytes 
{

    public static void main(String[] args) 
    {

        FileOutputStream output = null;
        FileInputStream input = null;       
        try
        {
            output = new FileOutputStream(".../testFileIO1.txt");
            input = new FileInputStream(".../testFileIO1.txt");

            // Stuff to try:


            doFileResult(512,output,input);
            doFileResult(128,output,input);
            doFileResult(256,output,input);
            doFileResult(257,output,input);
            doFileResult(160,output,input);
            doFileResult(289,output,input);
            doFileResult(1000,output,input);
            doFileResult(2000,output,input);            
        }
        catch(IOException e)
        {
            System.out.println("Error occurred.");
            e.getStackTrace();
        }
        finally
        {
            try
            {
                output.close();
                input.close();
            }
            catch(Exception e)
            {
                System.out.println("Error closing file.");
            }           
        }
    }   
    public static void doFileResult(int toWrite, FileOutputStream outStream, FileInputStream inputStream) throws IOException
    {
        System.out.println("******************");
        outStream.write(toWrite);

        int x = inputStream.read();
        char y = (char) x;

        System.out.println("Integer passed to write: " + toWrite);
        System.out.println("Input integer read: " + x);
        System.out.println("Input character read (after casting to char): " + y);
        System.out.println();       
    }
}

Answer 1

根據文檔 ， read()使用-1作為特殊值來表示EOF。 如果使用字節的實際范圍（-128..127），則-1為有效字節。

如基本方法的文檔InputStream.read() ：

值字節以int形式返回，范圍為0到255。如果由於到達流的末尾而沒有字節可用，則返回值-1。

從流中讀取代碼的慣用方式是：

while (true) {
  int v = stream.read();
  if (v == -1) {
    break;
  }
  byte b = (byte) v;
  // Do something.
}

強制轉換為字節將“正確”映射int 0..255到字節-128..127，因為將范圍從32位縮小到8位將僅保留8個最低有效位。

Answer 2

但是，當我將大於127但小於256的數字傳遞給write（）然后再進行read（）時，我得到的字符的十進制值確實介於127和255之間。這似乎表明write（）可以實際上寫9位而不是8位，而read（）實際上可以讀9位而不是8位。

那是不對的。

字節有8位，因此它可以保存0到255的值（包括0和255 。 但是，字節是帶符號的，因此一個字節可以容納的largest positive為127 ，需要7位。 最小的是-128 ，占用8位。 因此，根據它們的打印方式，您可以獲得有符號或無符號的值。

這是一個例子。

      byte d = (byte) (255); // -1
      System.out.println(d);
      d = (byte) (128); // -128
      System.out.println(d);

從數組中寫入兩個字節，然后分別讀取它們。

      byte[] b = { 125, 127
      };
      output.write(b);
      int inbyte = input.read();
      System.out.println(inbyte); //125
      inbyte = input.read();
      System.out.println(inbyte); // 127



      // writing using an int.
      int large = (102 << 8 | 254);
      output.write(large);
      int byt = input.read(); // writes lower byte of large
                              // which would be 254
      System.out.println(byt);
      System.out.println((byte) byt); // casting to a byte yields -2.