java的輸入輸出流

『壹』 java怎麼區分輸入流和輸出流

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

『貳』 JAVA中輸入輸出流和緩沖式輸入輸出流出有什麼區別

簡單地說，緩沖式輸入輸出流利用了緩沖區，而不是像一般的輸入輸出流那樣，每次讀取或寫入數據都會引起對設備（如存放在磁碟上的文件）的訪問。
具體說來，
緩沖式輸入流BufferedInputStream（InputStream
in），新建一個默認大小的緩沖流。從一個流中讀取字元，而不會每次都引起對設備的訪問。當緩沖區空的時候，一個新的數據塊將會被讀入緩沖區。
緩沖式輸出流BufferedOutputStream（OutputStream
out），新建一個默認緩沖大小的緩沖流。緩沖輸出流收集寫入的字元以避免每次都引起對設備的訪問。當緩存區滿或者被刷新里，數據被寫入設備。

『叄』 JAVA的輸入輸出流是指的什麼啊

Java語言的輸入輸出功能是十分強大而靈活的，美中不足的是看上去輸入輸出的代碼並不是很簡潔，因為你往往需要包裝許多不同的對象。在Java類庫中，IO部分的內容是很龐大的，因為它涉及的領域很廣泛:標准輸入輸出，文件的操作，網路上的數據流，字元串流，對象流，zip文件流....本文的目的是為大家做一個簡要的介紹。

流是一個很形象的概念，當程序需要讀取數據的時候，就會開啟一個通向數據源的流，這個數據源可以是文件，內存，或是網路連接。類似的，當程序需要寫入數據的時候，就會開啟一個通向目的地的流。這時候你就可以想像數據好像在這其中「流」動一樣，如下圖：

Java中的流分為兩種，一種是位元組流，另一種是字元流，分別由四個抽象類來表示（每種流包括輸入和輸出兩種所以一共四個）:InputStream，OutputStream，Reader，Writer。Java中其他多種多樣變化的流均是由它們派生出來的:

在這其中InputStream和OutputStream在早期的Java版本中就已經存在了，它們是基於位元組流的，而基於字元流的Reader和Writer是後來加入作為補充的。以上的層次圖是Java類庫中的一個基本的層次體系。

在這四個抽象類中，InputStream和Reader定義了完全相同的介面：
int read（）
int read（char cbuf[]）
int read（char cbuf[], int offset, int length）

而OutputStream和Writer也是如此：
int write（int c）
int write（char cbuf[]）
int write（char cbuf[], int offset, int length）

這六個方法都是最基本的，read（）和write（）通過方法的重載來讀寫一個位元組，或者一個位元組數組。

更多靈活多變的功能是由它們的子類來擴充完成的。知道了Java輸入輸出的基本層次結構以後，本文在這里想給大家一些以後可以反復應用例子，對於所有子類的細節及其功能並不詳細討論。

import java.io.*；

public class IOStreamDemo {

public void samples（） throws IOException {

//1. 這是從鍵盤讀入一行數據,返回的是一個字元串
BufferedReader stdin =new BufferedReader（new InputStreamReader（System.in））；
System.out.print（"Enter a line:"）；
System.out.println（stdin.readLine（））；

//2. 這是從文件中逐行讀入數據

BufferedReader in = new BufferedReader（new FileReader（"IOStreamDemo.java"））；
String s, s2 = new String（）；
while（（s = in.readLine（））!= null）
s2 += s + "\n"；
in.close（）；

//3. 這是從一個字元串中逐個讀入位元組
StringReader in1 = new StringReader（s2）；
int c；
while（（c = in1.read（）） != -1）
System.out.print（（char）c）；

//4. 這是將一個字元串寫入文件
try {
BufferedReader in2 = new BufferedReader（new StringReader（s2））；
PrintWriter out1 = new PrintWriter（new BufferedWriter（new FileWriter（"IODemo.out"）））；
int lineCount = 1；
while（（s = in2.readLine（）） != null ）
out1.println（lineCount++ + ": " + s）；
out1.close（）；
} catch（EOFException e） {
System.err.println（"End of stream"）；
}
}
}

對於上面的例子，需要說明的有以下幾點：

1. BufferedReader是Reader的一個子類，它具有緩沖的作用，避免了頻繁的從物理設備中讀取信息。它有以下兩個構造函數：
BufferedReader（Reader in）
BufferedReader（Reader in, int sz）

這里的sz是指定緩沖區的大小。

它的基本方法：
void close（） //關閉流

void mark（int readAheadLimit） //標記當前位置

boolean markSupported（） //是否支持標記

int read（） //繼承自Reader的基本方法

int read（char[] cbuf, int off, int len） //繼承自Reader的基本方法

String readLine（） //讀取一行內容並以字元串形式返回

boolean ready（） //判斷流是否已經做好讀入的准備

void reset（） //重設到最近的一個標記

long skip（long n） //跳過指定個數的字元讀取

2. InputStreamReader是InputStream和Reader之間的橋梁，由於System.in是位元組流，需要用它來包裝之後變為字元流供給 BufferedReader使用。

3. PrintWriter out1 = new PrintWriter（new BufferedWriter（new FileWriter（"IODemo.out"）））；

這句話體現了Java輸入輸出系統的一個特點，為了達到某個目的，需要包裝好幾層。首先，輸出目的地是文件IODemo.out，所以最內層包裝的是FileWriter，建立一個輸出文件流，接下來，我們希望這個流是緩沖的，所以用BufferedWriter來包裝它以達到目的，最後，我們需要格式化輸出結果，於是將PrintWriter包在最外層。

Java提供了這樣一個功能，將標準的輸入輸出流轉向，也就是說，我們可以將某個其他的流設為標准輸入或輸出流，看下面這個例子：

import java.io.*；

public class Redirecting {

public static void main（String[] args） throws IOException {
PrintStream console = System.out；
BufferedInputStream in = new BufferedInputStream（ new FileInputStream（ "Redirecting.java"））；
PrintStream out = new PrintStream（ new BufferedOutputStream（ new FileOutputStream（"test.out"）））；
System.setIn（in）；
System.setOut（out）；

BufferedReader br = new BufferedReader（ new InputStreamReader（System.in））；
String s；
while（（s = br.readLine（）） != null）
System.out.println（s）；
out.close（）；
System.setOut（console）；
}
}

在這里java.lang.System的靜態方法
static void setIn（InputStream in）
static void setOut（PrintStream out）

提供了重新定義標准輸入輸出流的方法，這樣做是很方便的，比如一個程序的結果有很多，有時候甚至要翻頁顯示，這樣不便於觀看結果，這是你就可以將標准輸出流定義為一個文件流，程序運行完之後打開相應的文件觀看結果，就直觀了許多。

Java流有著另一個重要的用途，那就是利用對象流對對象進行序列化。下面將開始介紹這方面的問題。

在一個程序運行的時候，其中的變數數據是保存在內存中的，一旦程序結束這些數據將不會被保存，一種解決的辦法是將數據寫入文件，而Java中提供了一種機制，它可以將程序中的對象寫入文件，之後再從文件中把對象讀出來重新建立。這就是所謂的對象序列化Java中引入它主要是為了RMI（Remote Method Invocation）和Java Bean所用，不過在平時應用中，它也是很有用的一種技術。

所有需要實現對象序列化的對象必須首先實現Serializable介面。下面看一個例子：

import java.io.*；
import java.util.*；

public class Logon implements Serializable {

private Date date = new Date（）；
private String username；
private transient String password；

Logon（String name, String pwd） {
username = name；
password = pwd；
}

public String toString（） {
String pwd = （password == null） ? "（n/a）" : password；
return "logon info: \n " + "username: " + username + "\n date: " + date + "\n password: " + pwd；
}

public static void main（String[] args） throws IOException, ClassNotFoundException {
Logon a = new Logon（"Morgan", "morgan83"）；
System.out.println（ "logon a = " + a）；
ObjectOutputStream o = new ObjectOutputStream（ new FileOutputStream（"Logon.out"））；
o.writeObject（a）；
o.close（）；

int seconds = 5；
long t = System.currentTimeMillis（） + seconds * 1000；
while（System.currentTimeMillis（） < t） ；

ObjectInputStream in = new ObjectInputStream（ new FileInputStream（"Logon.out"））；
System.out.println（ "Recovering object at " + new Date（））；
a = （Logon）in.readObject（）；
System.out.println（"logon a = " + a）；
}
}

類Logon是一個記錄登錄信息的類，包括用戶名和密碼。首先它實現了介面Serializable，這就標志著它可以被序列化。之後再main方法里ObjectOutputStream o = new ObjectOutputStream（ new FileOutputStream（"Logon.out"））；新建一個對象輸出流包裝一個文件流，表示對象序列化的目的地是文件Logon.out。然後用方法writeObject開始寫入。想要還原的時候也很簡單ObjectInputStream in = new ObjectInputStream（ new FileInputStream（"Logon.out"））；新建一個對象輸入流以文件流Logon.out為參數，之後調用readObject方法就可以了。

需要說明一點，對象序列化有一個神奇之處就是，它建立了一張對象網，將當前要序列化的對象中所持有的引用指向的對象都包含起來一起寫入到文件，更為奇妙的是，如果你一次序列化了好幾個對象，它們中相同的內容將會被共享寫入。這的確是一個非常好的機制。它可以用來實現深層拷貝。

關鍵字transient在這里表示當前內容將不被序列化，比如例子中的密碼，需要保密，所以沒有被寫入文件。

對Java的輸入輸出功能，就淺淺的介紹到這里，本文的目的只是開一個好頭，希望能讓大家對Java輸入輸出流有個基本的認識。

『肆』 JAVA的輸入輸出流是什麼有幾種

輸出流：所有的數據都寫入指定的文件中了import java.io.*;
public class FileOutputStreamDemo{
public static void main(String[] args){
String str="所有的數據都寫入指定的文件中了";
try{
System.out.println("創建文件輸出流對象:");
FileOutputStream fos=new FileOutputStream("c://1.txt");
System.out.println("將數據寫入文件中...");
fos.write(str.getBytes());
System.out.print("關閉文件");
fos.close();
}
catch(IOException e){
}
}
}輸入流：將文件中的內容寫入data中import java.io.*;
public class FileInputStreamDemo{
public static void main(String[] args){
try{
FileInputStream fis=new FileInputStream("c://1.txt");
byte[]data=new byte[100];
System.out.println("將文件中的內容寫入data中...");
fis.read(data);
PrintStream ps=System.out;
ByteArrayOutputStream baos=new ByteArrayOutputStream();
baos.write(data);
System.out.print("顯示data中的內容：...");
baos.writeTo(ps);
fis.close();
baos.close();
ps.close();
}
catch(IOException e){
}
}
}運行程序體會一下輸入位元組流和字元流和輸入位元組流和字元流你快要下載一個jdk api文檔裡面好多關於這方面的說明

『伍』 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();
}

}
}