java輸入輸出流的是

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

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

❷ 什麼是java輸入輸出流

Java把這些不同來源和目標的數據都統一抽象為數據流。
Java語言的輸入輸出功能是十分強大而靈活的，美中不足的是看上去輸入輸出的代碼並不是很簡潔，因為你往往需要包裝許多不同的對象。

❸ java 輸入輸出流 （被採納為答案者加100分）

其中BufferedInputStream是FileInputStream的子類,你可以理解成同樣處理一個文件，BufferedInputStream效率更高,原因是BufferedInputStream採用了更高效的位元組流處理方式,
BufferedInputStream才用緩沖流把內在的緩沖器連接到I/O流，允許java程序對多個位元組同時操作，這樣就提高了效率。

inputstreamreader的構造函數帶兩個參數,一是關聯到的文件,二是字元解碼方式. 所以實際上通過inputstreamreader實例讀出來的東西已經不是磁碟上原始的位元組數據了,而是根據你指定的解碼方式(如果你沒有指定,則使用系統預設的,win2000下是gbk/gb2312)把位元組流轉換成了字元流,注意位元組流和字元流的區別,一個位元組就是8比特位(32位機器上),而一個字元含多少位元組則與不同的編碼/解碼方式有關了,如gbk是一位元組,utf-8是1-3的變長位元組,utf-16是2個定長位元組.
於是值得你注意的就是當你用inputstreamreader讀文件時,你應該知道該文件被存儲時是用什麼方式編碼的,否則你指定錯了解碼方式,讀出來的就是亂碼.但是退一步來說,在全英文環境下,問題也沒這嚴重.因為所有的字元集在前七位上都是與ascii兼容的(我猜的,也許有的不是),然而當你的程序涉及中文字元時,肯定是會出錯了.
那麼fileinputstream的特點呢?它的構造函數就一個,即關聯到的文件,既然沒有指定解碼方式,那它所做的就是只以位元組流的方式讀出文件而不做任何處理, 你應該用一個位元組數組來接受它,對該數組你以後還可以做任何想做的操作。
給你個例子，自己去測試
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.*;

public class test {

/* public static void main(String[] args) {
String str=new String("Face recognition in the thermal infrared domain has received relatively little attention in the literature in comparison with recognition in visible-spectrum imagery");
StringTokenizer token=new StringTokenizer(str);
Hashtable ht=new Hashtable();
while(token.hasMoreTokens()){
String temp=new String(token.nextToken());
ht.put(temp,temp);
}
Enumeration en=ht.keys();
while(en.hasMoreElements()){
Object obj=en.nextElement();
System.out.print("KEY_NO:"+obj);
System.out.println("="+ht.get(obj));
}
}
*/

public static void main(String[] args){
try {
String file1 ="d:\\1.doc";
String file2 ="d:\\2.doc";
File(file1,file2);
readFile(file2);
//fileCheck("d:\\test1.txt");
// readFile("D:\\test1.txt");
// readFileByte("D:\\test1.txt");
// readFileByFile("D:\\test1.txt");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static void testFile() throws IOException{
File("D:\\test1.txt","D:\\test2.txt");

}
public static void File(String inName,String outName) throws IOException
{
File tmp = new File(outName);
if(!tmp.canRead())tmp.createNewFile();

BufferedInputStream in = new BufferedInputStream(new FileInputStream(inName));
BufferedOutputStream out= new BufferedOutputStream(new FileOutputStream(outName));
File(in,out,true);
}
public static void readFile(String inName) throws IOException
{
BufferedReader read = new BufferedReader (new InputStreamReader(new FileInputStream(inName)));
String b ;
while((b=read.readLine())!=null )
print( b);
}
public static void readFileByte(String inName) throws IOException
{
BufferedInputStream read = new BufferedInputStream (new FileInputStream(inName));
int b = 0;
while((b=read.read())!=-1)
System.out.print ((char)b);
}
public static void readFileByFile(String name) throws IOException
{
File tmp = new File (name);
FileReader fr= new FileReader(tmp);
BufferedReader br = new BufferedReader(fr);
String b;
while((b=br.readLine())!=null)
print(b);

}

public static void File(InputStream in ,OutputStream out, boolean close) throws IOException{
int b;
while((b=in.read())!=-1)
{
out.write(b);
}
in.close();
if(close)
out.close();
}
public static void print(Object o)
{
System.out.println(o);
}
public static void fileCheck(String name) throws IOException
{
print("---"+name+"---");
File f= new File(name);

if(!f.exists())
{
print("fle not exist!");
return;
}

print("Canonical name:"+f.getCanonicalPath());
String p= f.getParent();
if(p!=null)
print("Parent directory :"+p);

if(f.canRead())print("file can be read!");

if(f.canWrite())print("file can be writable!");

Date d = new Date();
d.setTime(f.lastModified());
print("last modified time :"+d);

if(f.isFile())
{
print("file size is :"+f.length()+" bytes");
}else if(f.isDirectory()){print("is a directry!");}
else{
print("neither a directory or a file!");
}

print("");

}

}

❹ 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怎麼區分輸入流和輸出流

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

❻ 怎麼理解Java的輸入輸出流

輸入輸出是相對內存來說的，比方說，你站在內存的角度來看，有數據讀進內存就是輸入，數據被從內存取出就是輸出，至於流是數據的一種形式不懂就去看看數據結構的書，知道這個答復不能利你滿意，只是想讓你找著方向而已，我以前也迷糊了好長時間……

❼ 在Java中甚麼是輸入輸出流 標准答案

如果數據是從程序外流入程序那末就是輸入流如果是從程序往外輸出就是輸出流

❽ java輸入輸出流

方法1是字元流，方法2是位元組流。
字元流處理的單元為2個位元組的Unicode字元，分別操作字元、字元數組或字元串，而位元組流處理單元為1個位元組， 操作位元組和位元組數組。所以字元流是由Java虛擬機將位元組轉化為2個位元組的Unicode字元為單位的字元而成的，所以它對多國語言支持性比較好！如果是 音頻文件、圖片、歌曲，就用位元組流好點，如果是關繫到中文（文本）的，用字元流好點.
所有文件的儲存是都是位元組（byte）的儲存，在磁碟上保留的並不是文件的字元而是先把字元編碼成位元組，再儲存這些位元組到磁碟。在讀取文件（特別是文本文件）時，也是一個位元組一個位元組地讀取以形成位元組序列.
位元組流可用於任何類型的對象，包括二進制對象，而字元流只能處理字元或者字元串； 2. 位元組流提供了處理任何類型的IO操作的功能，但它不能直接處理Unicode字元，而字元流就可以。

使用的地方可以搜搜具體的代碼，字元流操作字元啊。位元組流操作byte，一般是byte數組啊。

❾ java中 什麼是輸出 輸入流

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

❿ 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輸入輸出流有個基本的認識。