java讀取流
① java輸入輸出流是怎麼讀取的呢
讀取文件吧。
publicclassReadFromFile{
/**
*以位元組為單位讀取文件，常用於讀二進制文件，如圖片、聲音、影像等文件。
*/
(StringfileName){
Filefile=newFile(fileName);
InputStreamin=null;
try{
System.out.println("以位元組為單位讀取文件內容，一次讀一個位元組：");
//一次讀一個位元組
in=newFileInputStream(file);
inttempbyte;
while((tempbyte=in.read())!=-1){
System.out.write(tempbyte);
}
in.close();
}catch(IOExceptione){
e.printStackTrace();
return;
}
try{
System.out.println("以位元組為單位讀取文件內容，一次讀多個位元組：");
//一次讀多個位元組
byte[]tempbytes=newbyte[100];
intbyteread=0;
in=newFileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//讀入多個位元組到位元組數組中，byteread為一次讀入的位元組數
while((byteread=in.read(tempbytes))!=-1){
System.out.write(tempbytes,0,byteread);
}
}catch(Exceptione1){
e1.printStackTrace();
}finally{
if(in!=null){
try{
in.close();
}catch(IOExceptione1){
}
}
}
}
/**
*以字元為單位讀取文件，常用於讀文本，數字等類型的文件
*/
(StringfileName){
Filefile=newFile(fileName);
Readerreader=null;
try{
System.out.println("以字元為單位讀取文件內容，一次讀一個位元組：");
//一次讀一個字元
reader=newInputStreamReader(newFileInputStream(file));
inttempchar;
while((tempchar=reader.read())!=-1){
//對於windows下，
這兩個字元在一起時，表示一個換行。
//但如果這兩個字元分開顯示時，會換兩次行。
//因此，屏蔽掉
，或者屏蔽
。否則，將會多出很多空行。
if(((char)tempchar)!='
'){
System.out.print((char)tempchar);
}
}
reader.close();
}catch(Exceptione){
e.printStackTrace();
}
try{
System.out.println("以字元為單位讀取文件內容，一次讀多個位元組：");
//一次讀多個字元
char[]tempchars=newchar[30];
intcharread=0;
reader=newInputStreamReader(newFileInputStream(fileName));
//讀入多個字元到字元數組中，charread為一次讀取字元數
while((charread=reader.read(tempchars))!=-1){
//同樣屏蔽掉
不顯示
if((charread==tempchars.length)
&&(tempchars[tempchars.length-1]!='
')){
System.out.print(tempchars);
}else{
for(inti=0;i<charread;i++){
if(tempchars[i]=='
'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}
}catch(Exceptione1){
e1.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOExceptione1){
}
}
}
}
/**
*以行為單位讀取文件，常用於讀面向行的格式化文件
*/
(StringfileName){
Filefile=newFile(fileName);
BufferedReaderreader=null;
try{
System.out.println("以行為單位讀取文件內容，一次讀一整行：");
reader=newBufferedReader(newFileReader(file));
StringtempString=null;
intline=1;
//一次讀入一行，直到讀入null為文件結束
while((tempString=reader.readLine())!=null){
//顯示行號
System.out.println("line"+line+":"+tempString);
line++;
}
reader.close();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOExceptione1){
}
}
}
}
/**
*隨機讀取文件內容
*/
(StringfileName){
RandomAccessFilerandomFile=null;
try{
System.out.println("隨機讀取一段文件內容：");
//打開一個隨機訪問文件流，按只讀方式
randomFile=newRandomAccessFile(fileName,"r");
//文件長度，位元組數
longfileLength=randomFile.length();
//讀文件的起始位置
intbeginIndex=(fileLength>4)?4:0;
//將讀文件的開始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[]bytes=newbyte[10];
intbyteread=0;
//一次讀10個位元組，如果文件內容不足10個位元組，則讀剩下的位元組。
//將一次讀取的位元組數賦給byteread
while((byteread=randomFile.read(bytes))!=-1){
System.out.write(bytes,0,byteread);
}
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(randomFile!=null){
try{
randomFile.close();
}catch(IOExceptione1){
}
}
}
}
/**
*顯示輸入流中還剩的位元組數
*/
(InputStreamin){
try{
System.out.println("當前位元組輸入流中的位元組數為:"+in.available());
}catch(IOExceptione){
e.printStackTrace();
}
}
publicstaticvoidmain(String[]args){
StringfileName="C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
② java怎麼用流讀取一個文件的內容然後添加到別的文件中
FileInputStream fis = new FileInputStream("d:/a.txt");//從a.txt中讀出
FileOutputStream fos = new FileOutputStream("d:/b.txt");//寫到b.txt中去
BufferedReader reader = new BufferedReader(new InputStreamReader(fis));
BufferedWriter write = new BufferedWriter(new OutputStreamWriter(fos));
String temp;
while((temp = reader.readLine())!= null){//一次讀一行
write.write(temp);
}
reader.close();
write.close();
③ java多線程使用一個Sokcet讀取流
可以啊 ，不過需要新建兩個實現Runnable 借口的類，重寫run方法，一個實現讀取，另一個實現輸出的功能。再用兩條線程分別操作這兩個方法。
④ java 文件讀寫流
讀寫是兩個不同的分支，通常都是分開單獨使用的。
可以通過BufferedReader 流的形式進行流緩存，之後通過readLine方法獲取到緩存的內容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此時獲取到的bre就是整個文件的緩存流
while ((str = bre.readLine())!= null) // 判斷最後一行不存在，為空結束循環
{
System.out.println(str);//原樣輸出讀到的內容
}；
備註： 流用完之後必須close掉，如上面的就應該是：bre.close()，否則bre流會一直存在，直到程序運行結束。
可以通過「FileOutputStream」創建文件實例，之後過「OutputStreamWriter」流的形式進行存儲，舉例：
OutputStreamWriter pw = null;//定義一個流
pw = new OutputStreamWriter(new FileOutputStream(「D:/test.txt」),"GBK");//確認流的輸出文件和編碼格式，此過程創建了「test.txt」實例
pw.write("我是要寫入到記事本文件的內容");//將要寫入文件的內容，可以多次write
pw.close();//關閉流
備註：文件流用完之後必須及時通過close方法關閉，否則會一直處於打開狀態，直至程序停止，增加系統負擔。
⑤ java的幾種IO流讀取文件方式
一、超類：
位元組流： InputStream（讀入流） OutputStream(寫出流）
字元流： Reader（字元 讀入流） Writer （字元寫出流）
二、文件操作流
位元組流： FileInputStream ，FileOutputStream
字元流： FileReader, FileWriter(用法與位元組流基本相同，不寫）
//1.指定要讀 的文件目錄及名稱
File file =new File("文件路徑");
//2.創建文件讀入流對象
FileInputStream fis =new FileInputStream(file);
//3.定義結束標志,可用位元組數組讀取
int i =0 ;
while((i = fis.read())!=-1){
//i 就是從文件中讀取的位元組，讀完後返回-1
}
//4.關閉流
fis.close();
//5.處理異常
//1.指定要寫到的文件目錄及名稱
File file =new File("文件路徑");
//2.創建文件讀入流對象
FileOutputStream fos =new FileOutputStream(file);
//3.定義結束標志
fos.write(要寫出的位元組或者位元組數組);
//4.刷新和關閉流
fos.flush();
fos.close();
//5.處理異常
三、緩沖流：
位元組緩沖流： BufferedInputStream,BufferedOutputStream
字元緩沖流：BufferedReader ,BufferedWriter
緩沖流是對流的操作的功能的加強，提高了數據的讀寫效率。既然緩沖流是對流的功能和讀寫效率的加強和提高，所以在創建緩沖流的對象時應該要傳入要加強的流對象。
//1.指定要讀 的文件目錄及名稱
File file =new File("文件路徑");
//2.創建文件讀入流對象
FileInputStream fis =new FileInputStream(file);
//3.創建緩沖流對象加強fis功能
BufferedInputStream bis =new BufferedInputStream(fis);
//4.定義結束標志,可用位元組數組讀取
int i =0 ;
while((i = bis.read())!=-1){
//i 就是從文件中讀取的位元組，讀完後返回-1
}
//5.關閉流
bis.close();
//6.處理異常
//1.指定要寫到的文件目錄及名稱
File file =new File("文件路徑");
//2.創建文件讀入流對象
FileOutputStream fos =new FileOutputStream(file);
//3.創建緩沖流對象加強fos功能
BufferedOutputStream bos=new BufferedOutputStream(fos);
//4.向流中寫入數據
bos.write(要寫出的位元組或者位元組數組);
//5.刷新和關閉流
bos.flush();
bos.close();
//6.處理異常
四、對象流
ObjectInputStream ,ObjectOutputStream
不同於以上兩種類型的流這里只能用位元組對對象進行操作原因可以看上篇的編碼表比照原理
ObjectOutputStream對象的序列化：
將java程序中的對象寫到本地磁碟里用ObjectOutputStream
eg：將Person類的對象序列化到磁碟
創建Person類
注1：此類要實現Serializable介面，此介面為標志性介面
注2：此類要有無參的構造函數
注3：一旦序列化此類不能再修改
class Person implements Serializable{
public Person(){}
}
2.創建對象流對象
註：要增強功能可以將傳入文件緩沖流
ObjectOutputStream oos =new ObjectOutputStream(
new FileOutputStream(new File("文件路徑")));
3.寫入對象 ，一般會將對象用集合存儲起來然後直接將集合寫入文件
List<Person> list =new ArrayList<>();
list.add(new Person());
...(可以添加多個）
oos.writeObject(list);
4.關閉流，處理異常
oos.flush();
oos.close();
五、轉換流：
這類流是用於將字元轉換為位元組輸入輸出，用於操作字元文件，屬於字元流的子類，所以後綴為reader，writer；前綴inputstream，outputstream；
注 ：要傳入位元組流作為參賽
InputStreamReader: 字元轉換輸出流
OutputStreamWriter：字元轉換輸入流
//1.獲取鍵盤輸入的位元組流對象
inInputStream in =Stream.in;
/*2.用轉換流將位元組流對象轉換為字元流對象，方便調用字元緩沖流的readeLine()方法*/
InputStreamReader isr =new InputStreamReader(in);
/*5.創建字元轉換輸出流對象osw，方便把輸入的字元流轉換為位元組輸出到本地文件。*/
OutputStreamWriter osw =new OutputStreamWriter(new
FileOutputStream(new File("文件名")));
/*3.現在isr是字元流，可以作為參數傳入字元緩沖流中*/
BufferedReader br =new BufferedReader(isr);
/*4.可以調用字元緩沖流br的readLine()方法度一行輸入文本*/
String line =null;
while((line =br.readLine()){
osw.write(line);//osw是字元流對象，可以直接操作字元串
}
註：InputStreamReader isr =new InputStreamReader(new "各種類型的位元組輸入流都行即是：後綴為InputStream就行");
OutputStreamWriter osw =new OutputStreamWriter(new
"後綴為OutputStream就行");
六、區別記憶
1.對象流是可以讀寫幾乎所有類型的只要是對象就行，而位元組字元流，只能讀寫單個位元組字元或者位元組字元數組，以上沒有讀寫位元組字元數組的；注意對象流只有位元組流！
2.字元和位元組循環讀入的結束條件int i=0; (i =fis.read())!=-1
用字元數組復制文件(fr 讀入流 ，fw寫出流）,位元組流也是相同的用法
int i = 0; char[] c = new char[1024];
while((i = fr.reade()) !=-1)）{
fw.write(c,0,i);
}
123456
3.對象流裡面套緩沖流的情景：
new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(「文件路徑」))));
4.記憶流及其功能的方法：
前綴表示功能，後綴表示流的類型；
比如說FileInputStream 前綴：File,表示操作的磁碟，後綴：intputstream,表示是位元組輸入流。
同理 FileReader：表示操作文件的字元流
ObjectInputStream ：操作對象的位元組輸入流
5.拓展：獲取鍵盤輸入的字元的緩沖流的寫法：
new BufferedReader(new InputStreamReader(System.in)));
將位元組以字元形式輸出到控制台的字元緩沖流的寫法：
new BufferedWriter（ new OutputStreamWriter（System.out))
⑥ java怎麼使用io流讀取一個文件夾裡面
使用工具類Properties
工具類有Load（）方法 用於載入文件
首先將文件寫成流（輸入）
File file=new File(confPath);
in = new FileInputStream(file);載入流load（in）如果需要操作則完成具體操作
輸出流並保存文件
out2 = new OutputStreamWriter(new FileOutputStream(confPath),"GBK");
cp.store(out2);完成
具體實例代碼
public String updateConfParam(ConfParam cpl) throws IOException {
String error = null;
Properties cp=new Properties();
InputStream in= null;
OutputStreamWriter out1=null;
OutputStreamWriter out2=null;
JSONObject jObj = new JSONObject();
try {
String confPath=validateSystem(cpl.getConfAddress()+"/"+cpl.getConfName());
File file=new File(confPath);
in = new FileInputStream(file);
cp.load(in);
out1=new OutputStreamWriter(new FileOutputStream(confPath+".bak"),"GBK");
cp.store(out1);
cpl.setParaOldValue(cp.getProperty(cpl.getParaKey()));
cp.setProperty(cpl.getParaKey(), cpl.getParaValue());
out2 = new OutputStreamWriter(new FileOutputStream(confPath),"GBK");
cp.store(out2);
jObj.put("paraOldValue", cpl.getParaOldValue());
jObj.put("paraValue", cpl.getParaValue());
} catch (FileNotFoundException e) {
error=e.getMessage();
} catch (IOException e1) {
error = e1.getMessage();
}
finally{
if(in !=null){
in.close();
}
if(out1 !=null){
out1.close();
}
if(out2 !=null){
out2.close();
}
if(error != null){
jObj.put("error", error);
}
}
return jObj.toString();
}
⑦ java位元組流怎麼讀取數據
位元組流讀取數據例子如下：
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
/**
*復制文件
*@authoryoung
*
*/
publicclassCopyFile{
publicstaticvoidmain(String[]args){
/*指定源exe文件的存放路徑*/
Stringstr="f:/jdk-1_5_0_06-windows-i586-p.exe";
/*指定復制後的exe的目標路徑*/
Stringstrs="e:/.exe";
/*創建輸入和輸出流*/
FileInputStreamfis=null;
FileOutputStreamfos=null;
try{
/*將io流和文件關聯*/
fis=newFileInputStream(str);
fos=newFileOutputStream(strs);
byte[]buf=newbyte[1024*1024];
intlen;
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
}
}catch(FileNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}finally{
try{
fis.close();
fos.close();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
}
⑧ java 讀取輸入流的時候cpu佔用很高，怎麼解決
驚呆了
Thread??
run??
while(true)??
oh,mygod
看這個
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.File;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
publicclassProcessing
{
publicstaticvoidmain(String[]args)
{
try
{
//opencmd
//Processprocess=Runtime.getRuntime().exec(newString[]{
//"cmd","/c","dir"},null,newFile("e:/"));
Processprocess=Runtime.getRuntime().exec("cmd");
InputStreamReaderisr=newInputStreamReader(process.getInputStream(),"gbk");
BufferedReaderbr=newBufferedReader(isr);
//nextcommand
OutputStreamWriterosw=newOutputStreamWriter(process.getOutputStream());
BufferedWriterbw=newBufferedWriter(osw);
bw.write("java-jar"D:\ProgramFiles\Java\jdk1.6.0_02\demo\jfc\Notepad\Notepad.jar"");
bw.newLine();
bw.flush();
bw.close();
osw.close();
//read
Stringline=null;
while(null!=(line=br.readLine()))
{
System.out.println(line);
}
//waitfortermination
//process.waitFor();
//process.exitValue();
process.destroy();
br.close();
isr.close();
}
catch(IOExceptione)
{
e.printStackTrace();
}
//catch(InterruptedExceptione)
//{
//e.printStackTrace();
//}
}
}