java中的輸入流

⑴ java位元組輸入流什麼意思輸入的是位元組，輸出的是字元

實現上 位元組輸出流是繼承OutputStream 而字元輸出流繼承OutputStreamWriter
應用上 字元流是專門用來處理文字的，包含了對多國語言的支持，而位元組流主要是用來處理文字以外的如binary文件。

⑵ Java如何把字元串轉化為輸入流

//txt為TextArea內的字元串
try{
InputStream
myIn=new
ByteArrayInputStream(txt.getBytes());
//將System.in轉化為面向字元的流
InputStreamReader
ir
=
new
InputStreamReader(myIn);
in
=
new
BufferedReader(ir);//為輸入流提供緩沖區
while
((s
=
in.readLine())
!=
"bye")
System.out.println("Read:
"
+
s);
}
catch(IOException
e)
{System.out.println("Error!
");}
}

⑶ 輸入流的java的輸入流

當然，我們經常想做的一件事情是將格式化的輸出列印到控制台，但那已在第5章創建的com.bruceeckel.tools中得到了簡化。第1到第4部分演示了輸入流的創建與使用（盡管第4部分展示了將輸出流作為一個測試工具的簡單應用）。1.緩沖的輸入文件為打開一個文件以便輸入，需要使用一個FileInputStream，同時將一個String或File對象作為文件名使用。為提高速度，最好先對文件進行緩沖處理，從而獲得用於一個BufferedInputStream的構建器的結果句柄。為了以格式化的形式讀取輸入數據，我們將那個結果句柄賦給用於一個DataInputStream的構建器。DataInputStream是我們的最終（final）對象，並是我們進行讀取操作的介面。在這個例子中，只用到了readLine()方法，但理所當然任何DataInputStream方法都可以採用。一旦抵達文件末尾，readLine()就會返回一個null（空），以便中止並退出while循環。「Strings2」用於聚集完整的文件內容（包括必須添加的新行，因為readLine()去除了那些行）。隨後，在本程序的後面部分中使用s2。最後，我們調用close()，用它關閉文件。從技術上說，會在運行finalize()時調用close()。而且我們希望一旦程序退出，就發生這種情況（無論是否進行垃圾收集）。然而，Java1.0有一個非常突出的錯誤（Bug），造成這種情況不會發生。在Java1.1中，必須明確調用System.runFinalizersOnExit(true)，用它保證會為系統中的每個對象調用finalize()。然而，最安全的方法還是為文件明確調用close()。2.從內存輸入這一部分採用已經包含了完整文件內容的Strings2，並用它創建一個StringBufferInputStream（字串緩沖輸入流）——作為構建器的參數，要求使用一個String，而非一個StringBuffer）。隨後，我們用read()依次讀取每個字元，並將其發送至控制台。注意read()將下一個位元組返回為int，所以必須將其造型為一個char，以便正確地列印。3.格式化內存輸入StringBufferInputStream的介面是有限的，所以通常需要將其封裝到一個DataInputStream內，從而增強它的能力。然而，若選擇用readByte()每次讀出一個字元，那麼所有值都是有效的，所以不可再用返回值來偵測何時結束輸入。相反，可用available()方法判斷有多少字元可用。下面這個例子展示了如何從文件中一次讀出一個字元：//:TestEOF.java////abyteatatime.importjava.io.*;publicclassTestEOF{publicstaticvoidmain(String[]args){try{DataInputStreamin=newDataInputStream(newBufferedInputStream(newFileInputStream("TestEof.java")));while(in.available()!=0)System.out.print((char)in.readByte());}catch(IOExceptione){System.err.println("IOException");}}}///:~注意取決於當前從什麼媒體讀入，avaiable()的工作方式也是有所區別的。它在字面上意味著「可以不受阻塞讀取的位元組數量」。對一個文件來說，它意味著整個文件。但對一個不同種類的數據流來說，它卻可能有不同的含義。因此在使用時應考慮周全。為了在這樣的情況下偵測輸入的結束，也可以通過捕獲一個違例來實現。然而，若真的用違例來控制數據流，卻顯得有些大材小用。4.行的編號與文件輸出這個例子展示了如何LineNumberInputStream來跟蹤輸入行的編號。在這里，不可簡單地將所有構建器都組合起來，因為必須保持LineNumberInputStream的一個句柄（注意這並非一種繼承環境，所以不能簡單地將in4造型到一個LineNumberInputStream）。因此，li容納了指向LineNumberInputStream的句柄，然後在它的基礎上創建一個DataInputStream，以便讀入數據。這個例子也展示了如何將格式化數據寫入一個文件。首先創建了一個FileOutputStream，用它同一個文件連接。考慮到效率方面的原因，它生成了一個BufferedOutputStream。這幾乎肯定是我們一般的做法，但卻必須明確地這樣做。隨後為了進行格式化，它轉換成一個PrintStream。用這種方式創建的數據文件可作為一個原始的文本文件讀取。標志DataInputStream何時結束的一個方法是readLine()。一旦沒有更多的字串可以讀取，它就會返回null。每個行都會伴隨自己的行號列印到文件里。該行號可通過li查詢。可看到用於out1的、一個明確指定的close()。若程序准備掉轉頭來，並再次讀取相同的文件，這種做法就顯得相當有用。然而，該程序直到結束也沒有檢查文件IODemo.txt。正如以前指出的那樣，如果不為自己的所有輸出文件調用close()，就可能發現緩沖區不會得到刷新，造成它們不完整。

⑷ java中 什麼是輸出 輸入流

程序操作的數據都應該是在內存裡面，內存是你操作的主對象，把數據從其他資源裡面傳送到內存裡面，就是輸入，反之，把數據從內存傳送到其他資源，就是輸出。
讀文件
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("infilename")));
不管從磁碟讀，從網路讀，或者從鍵盤讀，讀到內存，就是InputStream。
寫文件
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("outfilename")));
不管寫到磁碟，寫到網路，或者寫到屏幕，都是OuputStream

⑸ java如何使用位元組輸入流抽象類InputStream

InputStream 類是位元組輸入流的抽象類，定義了操作輸入流的各種方法，這些方法如表：

返回
方法
說明

int available() 返回當前輸入流的數據讀取方法可以讀取的有效位元組數量
Abstract int read() 從當前數據流中讀取一個位元組。若已達到流結尾，則返回-1
int read(byte[ ] bytes) 從當前輸入流讀取一定的byte數據，並存取在數組中，然後返回讀取的byte數據的數量，若已到達流結尾，則返回-1。
void reset() 將當前的輸入流重新定位到最後一次調用mark()方法時的位置
void mark(int readlimit) 在當前輸入流中做標記位置，當調用reset()方法時將返回到該位置，從標記位置開始，到再讀入readlimit個字元為止，這個標記都維持有效。
Boolean markSupported() 測試當前輸入流是否支持mark()和reset()方法，只要其中一個不支持，則返回false
long skip(long n) 跳過和丟棄當前輸入的n個位元組數據
void close() 關閉當前輸入流，並釋放任何與之相關聯的系統資源

⑹ java怎麼區分輸入流和輸出流

這個是依照內存為標準的，以載入磁碟上的文件到內存為例， 首先你必須把 磁碟上的文件，載入到 內存中，這個就是輸入到內存， 你把內存里的文件，寫到磁碟上，這個是把內存輸出到磁碟上， 以內存為標准，寫進內存，就是輸入， 內存本身有內容，輸出到別的地方，就是輸出，一些網路的輸入輸出流，跟這個是一樣的概念，以 客戶端發送HTTP請求為例，客戶端准備好了HTTP請求的內容，發送給伺服器，這個就是輸出流， 伺服器返回一些內容，寫進你本地的內存，這個就是輸入，但是對於伺服器來說，這個又是不一樣的，你的請求對伺服器來說，是輸入，伺服器給你的內容就是輸出了。一端的輸入，對於另一端來說就是輸出，一端的輸出，對另一端就是輸入。

⑺ Java里那個輸入流和輸出流怎麼用

//java中使用文件輸入流和文件輸出流進行文件讀寫的用例！
Java
packagecom.test.io;

importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;

/**
*
*@author亞當愛上java
*用例內容：文件輸入流和文件輸入流結合用例，位元組流方式
*時間：2010-06-20
*注意事項：文件輸入流和文件輸出流都是相對與內存來說的，例如通過程序讀取文件時往內存輸入數據就是文件輸入流
*/

publicclassFileInputOrOutput{

publicstaticvoidmain(String[]args){

//文件或者路徑名的抽象表現形式,意思就是說之後如果進行操作的話就是全部在這個抽象路徑名所指向的文件或者文件加中
Filefile=newFile("e:/test.txt");
Filefile2=newFile("e:/test1.txt");

//文件位元組數的個數
//System.out.println(file.length());
try{

/*------------------------------------------讀操作部分-----------------------------------------------*/
//文件輸入流對象
InputStreamfis=newFileInputStream(file);

//文件輸入流對象所讀取的位元組數大小
//System.out.println(fis.available());

/**
*1.按照一個位元組為單位進行讀取數據,弊端是遇到中文就會把中文的漢字拆開從而出現亂碼
*/

////流對象讀出的返回值是每次所讀到的一個字元所對應的ascii碼值
//inti=fis.read();
//
////如果已經讀到文件尾則i==-1,此時終止循環
//while(i!=-1){
//System.out.print((char)i);
//保證每一次循環都繼續往後讀取一個字元，否則i的值不變會成為死循環
//i=fis.read();
//}
/**
*2.按照一個位元組數組所指定的大小為單位進行讀取，每次最多可以讀取數組定義的大小的位元組個數
*/

//每次讀取都以1K位元組作為單位來進行
byteb[]=newbyte[1024];

//流對象讀出並返回的是每次讀取位元組的個數，最大每次讀取自己數可以和數組b.length相同
//b中存儲了每次所讀取的所有數據
inti=fis.read(b);

Stringstr="";
//如果已經讀到文件尾則i==-1,此時終止循環
while(i!=-1){
//把每次讀取的位元組數組解碼為字元串
//參數1：要解碼為字元的位元組
//參數2：要解碼的首字元的索引
//參數3：要解碼的位元組的個數,如果文件個數大於所設定的一次讀取文件的大小時i的取值就是
//b.length,否則小於數組的位元組大小時則為實際的讀取出自己數的大小
str=str+newString(b,0,i);

//保證每一次都往文件的下一部分進行讀取，否則i值沒有變化會成為死循環
i=fis.read(b);
}

//System.out.print(str);

//關閉輸入流對象
fis.close();

/*------------------------------------------寫操作部分-----------------------------------------------*/
//文件輸出流對象
OutputStreamfos=newFileOutputStream(file2);

//str是從file所指定的文件中讀出的所有內容，將此內容寫入另一個文件中
//將字元解碼為位元組數組
byteb2[]=str.getBytes();

//將解碼後的位元組數組，通過文件輸出流對象寫入到緩沖區中
fos.write(b);
//強制將緩沖區中的內容輸出到文件中
fos.flush();
//關閉輸出流對象
fos.close();

}catch(FileNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}

}
}

⑻ java中如何做文件位元組輸入流

首先，我以往經驗是寫入位元組流和輸出位元組流的方式一定要一致，不然寫入的位元組流就會出錯甚至讀取不到，下面是位元組流的寫入和讀取方法：

importjava.io.*;
classTest{
publicstaticvoidmain(Stringargs[]){
FileInputStreamfis=null;
FileOutputStreamfos=null;
byte[]buffer=newbyte[100];
inttemp=0;
try{
fis=newFileInputStream("D:/wenhao/src/from.txt");
fos=newFileOutputStream("D:/wenhao/src/to.txt");
while(true){
temp=fis.read(buffer,0,buffer.length);
if(temp==-1){
break;
}
fos.write(buffer,0,temp);
}
}
catch(Exceptione){
System.out.println(e);
}
finally{
try{
fis.close();
fos.close();
}
catch(Exceptione2){
System.out.println(e2);
}
}
}
}

⑼ java中的輸入輸出流該怎麼理解

數據流是一串連續不斷的數據的集合，就象水管里的水流，在水管的一端一點一點地供水，而在水管的另一端看到的是一股連續不斷的水流。數據寫入程序可以是一段、一段地向數據流管道中寫入數據，這些數據段會按先後順序形成一個長的數據流。對數據讀取程序來說，看不到數據流在寫入時的分段情況，每次可以讀取其中的任意長度的數據，但只能先讀取前面的數據後，再讀取後面的數據。不管寫入時是將數據分多次寫入，還是作為一個整體一次寫入，讀取時的效果都是完全一樣的。
「流是磁碟或其它外圍設備中存儲的數據的源點或終點。」
在電腦上的數據有三種存儲方式，一種是外存，一種是內存，一種是緩存。比如電腦上的硬碟，磁碟，U盤等都是外存，在電腦上有內存條，緩存是在CPU裡面的。外存的存儲量最大，其次是內存，最後是緩存，但是外存的數據的讀取最慢，其次是內存，緩存最快。這里總結從外存讀取數據到內存以及將數據從內存寫到外存中。對於內存和外存的理解，我們可以簡單的理解為容器，即外存是一個容器，內存又是另外一個容器。那又怎樣把放在外存這個容器內的數據讀取到內存這個容器以及怎麼把內存這個容器里的數據存到外存中呢？
在Java類庫中，IO部分的內容是很龐大的，因為它涉及的領域很廣泛:
標准輸入輸出，文件的操作，網路上的數據流，字元串流，對象流，zip文件流等等，java中將輸入輸出抽象稱為流，就好像水管，將兩個容器連接起來。將數據沖外存中讀取到內存中的稱為輸入流，將數據從內存寫入外存中的稱為輸出流。
流是一個很形象的概念，當程序需要讀取數據的時候，就會開啟一個通向數據源的流，這個數據源可以是文件，內存，或是網路連接。類似的，當程序需要寫入數據的時候，就會開啟一個通向目的地的流。

⑽ JAVA的輸入輸出流有多少種

有文件輸出流：FileInputStream ，數據輸入流：DataInputStream，緩沖輸入流;BuferedInputStream,緩沖輸出流：BuferedOutputStream，有文件輸出流：FileoutputStream ，數據輸入流：DataOutputStream等！