導航:首頁 > 編程語言 > java文件輸入與輸出流

java文件輸入與輸出流

發布時間:2022-11-03 04:16:26

『壹』 輸入流和輸出流在java程序的i工巧/o操作中各承擔什麼功能

咨詢記錄 · 回答於2021-09-06

『貳』 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 輸入輸出流 (被採納為答案者加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中如何實現文件的輸入和輸出

程序如下:
<span style="color:#990000;">

</span>File file1 = new File("/home/a123/a");

if (file1.exists()) {
System.out.println("存在文件夾a");
} else {
file1.mkdir(); // 文件夾的創建 創建文件夾/home/a123/a
}
File file2 = new File("/home/a123/a/test");
if (file2.exists()) {
System.out.println("存在文件夾或者文件test");
} else {
try {
file2.createNewFile(); // 文件的創建,注意與文件夾創建的區別
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

/**
* 最簡單的文件讀寫方法是使用類FileWriter
* (它的父類依次是java.io.OutputStreamWriter——>java.io.Writer——>java.lang.Object );
*/

// 下面是向文件file2裡面寫數據
try {
FileWriter fileWriter = new FileWriter(file2);
String s = new String("This is a test! \n" + "aaaa");
fileWriter.write(s);
fileWriter.close(); // 關閉數據流

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

/*
* 這樣寫數據的話,是完全更新文件test裡面的內容,即把以前的東西全部刪除,重新輸入。
* 如果不想刪除以前的數據,而是把新增加的內容增添在文件末尾處。只需要在創建FileWriter對象時候,使用另外一個構造函數即可:
* FileWriter fileWriter=new FileWriter(file2,true);
*/

// 下面是從文件file2讀東西
try {
FileReader fileReader = new FileReader(file2);
String s = null;
char ch;
try {
char[] c = new char[100];
fileReader.read(c,0,2); // 具體想得到文件裡面的什麼值(單個char?int?還是String?),
System.out.println(c);
fileReader.close();

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
/**
* 具體想得到文件裡面的什麼值(單個char?int?還是String?),需要知道不通read的不同用法:
* 1. int read() 讀取單個字元。
* 2. int read(char[] cbuf) 將字元讀入數組。 可以再將字元型數組轉化位字元串
* 3. int read(char[] cbuf,int off,int len) 將字元讀入數組的某一部分。
* 這三個方法都返回一個int值,作用是:讀取的字元數,如果已到達流的末尾,則返回 -1.
*/

}

『伍』 java輸入輸出流的本質是什麼

Java輸入輸出流的本質是I/O操作,是指使用Java進行輸入輸出操作。Java所有的I/O機制都是基於數據流進行輸入輸出,這些數據流表示了字元或者位元組數據的流動序列。Java的I/O流提供了讀寫數據的標准方法。任何Java中表示數據源的對象都會提供以數據流的方式讀寫它的數據的方法。

『陸』 java輸入輸出流與文件,求源代碼!感謝大佬!

你好,java的API中提供了用於對象輸入輸出文件的操作,實例代碼如下:

  1. 定義單詞類如下(注意:你定義的類要實現Serializable介面)

public class Words implements Serializable {
private int size;
private String[] words;

public Words(){};

public Words(String...strs){
this.words = strs;
this.size = strs.length;
}

@Override
public String toString() {
return "Words{" +
"size=" + size +
", words=" + Arrays.toString(words) +
'}';
}
}

2. 對象輸入輸出api測試類

public class ObjIOTest {
public static void main(String[] args) {
String path = "d:/myIOTest.txt";
ObjIOTest objIOTest = new ObjIOTest();

Words words = new Words("hello", "my", "dear", "friend");

try {
objIOTest.writeObject(path,words);
Words wordsFromFile = (Words)objIOTest.readObject(path);
System.out.println(wordsFromFile.toString());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}

//java serialize a object to file
public void writeObject(String path,Object map) throws IOException{
File f=new File(path);
FileOutputStream out=new FileOutputStream(f);
ObjectOutputStream objwrite=new ObjectOutputStream(out);
objwrite.writeObject(map);
objwrite.flush();
objwrite.close();
}

// read the object from the file
public Object readObject(String path) throws IOException, ClassNotFoundException{
FileInputStream in=new FileInputStream(path);
ObjectInputStream objread=new ObjectInputStream(in);
Object map=objread.readObject();
objread.close();
return map;
}
}

把兩段代碼拷貝到一個包下即可運行了,希望您的問題得到解答

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

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

『捌』 什麼是java輸入輸出流

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

『玖』 JAVA的輸入輸出流有多少種

在「面向對象編程:Java collection更有效管理elements」一文中,我們討論了Java 集合類架構中的類和功能並介紹了它的排序功能。在本文中,我們將學習Java 平台提供的這些I/O類,介面和操作。讓我們先從了解Java 數據流開始。 數據流Java所有的I/O機制都是基於數據流的,這些數據流表示了字元或者位元組數據的流動序列。Java的I/O流提供了讀寫數據的標准方法。任何Java中表示數據源的對象都會提供以數據流的方式讀寫它的數據的方法。 Java.io是大多數面向數據流的輸入/輸出類的主要軟體包。這個軟體包包含了兩個抽象類,InputStream和OutputStream。所有其它面象數據流的輸入/輸出類都要擴展這兩個基類。 java.io軟體包提供了一些類和介面,它們在由InputStream和OuputStream類提供的讀寫操作的頂端定義了一些有用的抽象。例如,ObjectInputStream類提供了讓你把輸入/輸出流中的數據當成對象來讀取的方法,而ObjectOutputStream類提供了讓你能夠把Java對象寫入數據流中的方法。 優化讀寫過程 JDK 1.1 增加了一套讀寫類,它們提供了比現有數據流類更有用的抽象和更好的輸入/輸出性能。例如,BufferedReader和BufferedWriter 類被用來從基於字元的輸入和輸出流中讀取和寫入文本。BufferdReader 類緩存字元以更高效的讀取字元串,數組和文本行。BufferedWriter類緩存字元以更高效的寫入字元串,數組和文本行。BufferedReader和BufferedWriter 類可以按需求進行設置。 Java輸入/輸出架構提供的讀取器和寫入器類包括 LineNumberReader 類,CharArrayReader類,FileReader類,FilterReader類,PushbackReader類,PipedReader類,StringReader類以及其它一些類。這些類是在InputStream和OuputStream類頂部的包裹類因此提供了與InputStream和OuputStream類相似的方法。但是,這些類為讀寫特定的對象,比方文件,字元數組和字元串等等提供了更高效而有用的抽象。 讀取數據當你從一個相應的數據源對象里提取輸入流或者是創建一個讀取器對象的時候就會自動打開一個輸入流。例如,要為一個文件打開輸入流,我們只需要以下面的方式把文件名傳遞給Java.io.FileReader對象的構造函數: java.io.FileReader fileReader = new java.io.FileReader(/home/me/myfile.txt); 要按順序讀取FileReader底層的輸入流中的一個位元組數據,只需要使用不帶參數的read方法。表A中的代碼段從一個文件讀取文本數據,一次一個字元,然後把它寫入System.out里。 要從輸入流讀取指定數目的位元組數據到char數組里,只需要使用帶一個char[]參數的read方法。數組的長度被用來確定應該讀取的字元的個數。表B演示了這個技術。 要關閉一個輸入流以及這個流使用的所有系統資源,你只需要以下面的方式調用close方法: fileReader.close();寫入數據象一個輸入流一樣,輸出流通常在你從相應的數據源提取它或者是在你創建一個寫入對象的時候被自動的打開。例如,要為一個文件打開輸出流,我們把文件的名字傳遞給java.io.FileWriter對象的構造函數,如下所示: java.io.FileWriter fileWriter = new java.io.FileWriter(/home/me/out.txt); 要將一個特定的字元寫入到輸出流中,可以使用帶一個int參數的write方法,int參數代表要定入的字元。 int aChar = (int)'X'; fileWriter.write(aChar); 要在輸出流給定的偏移地址寫入一個char數組中特定數目的字元,你可以使用帶一個char[]參數,一個int 偏移量參數和一個int長度參數的write方法,如下面的例子所示: fileWriter.write(buffer, 0, byteCount); 要關閉一個輸出流並釋放所有與之相關的系統資源,可以使用close方法,就象這樣: fileWriter.close(); 要強迫寫出一個輸出流中的所有數據,可以使用下面的flush方法: fileWriter.flush(); 把它們全部綜合起來 我們可以使用我們學習過的這些函數從一個文件中讀取數據並同時寫到另一個文件中去,如表C所示。 總結Java的輸入/輸出機制為從不同的數據源讀取和寫入字元增加了一套簡單而標准化的API。你對一種數據源使用Java流的經驗能夠讓你容易的使用其它由Java提供的數據源類型。

『拾』 java中的輸入輸出流該怎麼理解

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

閱讀全文

與java文件輸入與輸出流相關的資料

熱點內容
androidjni獲取簽名 瀏覽:111
解壓文件電腦上哪裡找 瀏覽:447
linuxcutc 瀏覽:173
金穗蜀道通etc用什麼app辦理 瀏覽:123
阿雲伺服器系統盤與數據盤的區別 瀏覽:213
gcc編譯器可以用於單片機嗎 瀏覽:259
xmanagerlinux配置 瀏覽:664
文件夾視頻沒有聲音怎麼回事 瀏覽:83
閃閃app是什麼軟體 瀏覽:206
win7下引導linux 瀏覽:793
陝西bgp伺服器雲主機 瀏覽:934
ug編程有幾種加工方式 瀏覽:447
錘子手機如何添加桌面文件夾 瀏覽:465
公司早會拍照用哪個app好 瀏覽:424
學習打卡聲音解壓視頻 瀏覽:824
如何使用代理伺服器加速上網 瀏覽:266
找企業負責人電話用什麼app 瀏覽:427
linux創建文本文件命令 瀏覽:390
計算機中文檔加密保護操作步驟 瀏覽:387
地暖解壓管 瀏覽:465