2. 程式人生 > 其它 >Java基礎-20（02）總結,遞迴，IO流

Java基礎-20（02）總結,遞迴，IO流

阿新 • • 發佈：2022-05-04
(4)FileInputStream讀取資料

A:操作步驟

a:建立位元組輸入流物件

b:呼叫read()方法

c:釋放資源

B:程式碼體現：

 FileInputStream fis = new FileInputStream("fos.txt");
 //方式1
 int by = 0;
 while((by=fis.read())!=-1) {
 System.out.print((char)by);
 }
 //方式2
 byte[] bys = new byte[1024];
 int len = 0;
 while((len=fis.read(bys))!=-1) {
 System.out.print(new String(bys,0,len));
 }
 fis.close();

(5)案例：2種實現

A:int read():一次讀取一個位元組

package cn.itcast_02;
import java.io.FileInputStream;
import java.io.IOException;
/*
 * 位元組輸入流操作步驟：
 * A:建立位元組輸入流物件
 * B:呼叫read()方法讀取資料，並把資料顯示在控制檯
 * C:釋放資源
 * 
 * 讀取資料的方式：
 * A:int read():一次讀取一個位元組
 * B:int read(byte[] b):一次讀取一個位元組陣列
 */
public class FileInputStreamDemo {
 public static void main(String[] args) throws IOException {
 // FileInputStream(String name)
 // FileInputStream fis = new FileInputStream("fis.txt");
 FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
 // // 呼叫read()方法讀取資料，並把資料顯示在控制檯
 // // 第一次讀取
 // int by = fis.read();
 // System.out.println(by);
 // System.out.println((char) by);
 //
 // // 第二次讀取
 // by = fis.read();
 // System.out.println(by);
 // System.out.println((char) by);
 //
 // // 第三次讀取
 // by = fis.read();
 // System.out.println(by);
 // System.out.println((char) by);
 // // 我們發現程式碼的重複度很高，所以我們要用迴圈改進
 // // 而用迴圈，最麻煩的事情是如何控制迴圈判斷條件呢?
 // // 第四次讀取
 // by = fis.read();
 // System.out.println(by);
 // // 第五次讀取
 // by = fis.read();
 // System.out.println(by);
 // //通過測試，我們知道如果你讀取的資料是-1，就說明已經讀取到檔案的末尾了
 // 用迴圈改進
 // int by = fis.read();
 // while (by != -1) {
 // System.out.print((char) by);
 // by = fis.read();
 // }
 // 最終版程式碼
 int by = 0;
 // 讀取，賦值，判斷
 while ((by = fis.read()) != -1) {
 System.out.print((char) by);
 }
 // 釋放資源
 fis.close();
 }
}
 B:int read(byte[] b):一次讀取一個位元組陣列
package cn.itcast_02;
import java.io.FileInputStream;
import java.io.IOException;
/*
 * 一次讀取一個位元組陣列：int read(byte[] b)
 * 返回值其實是實際讀取的位元組個數。
 */
public class FileInputStreamDemo2 {
 public static void main(String[] args) throws IOException {
 // 建立位元組輸入流物件
 // FileInputStream fis = new FileInputStream("fis2.txt");
 FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
 // 讀取資料
 // 定義一個位元組陣列
 // 第一次讀取
 // byte[] bys = new byte[5];
 // int len = fis.read(bys);
 // // System.out.println(len);
 // // System.out.println(new String(bys));
 // // System.out.println(new String(bys, 0, len));
 // System.out.print(new String(bys, 0, len));
 //
 // // 第二次讀取
 // len = fis.read(bys);
 // // System.out.println(len);
 // // System.out.println(new String(bys));
 // // System.out.println(new String(bys, 0, len));
 // System.out.print(new String(bys, 0, len));
 //
 // // 第三次讀取
 // len = fis.read(bys);
 // // System.out.println(len);
 // // System.out.println(new String(bys));
 // // System.out.println(new String(bys, 0, len));
 // System.out.print(new String(bys, 0, len));
 //
 // // 第四次讀取
 // len = fis.read(bys);
 // // System.out.println(len);
 // // System.out.println(new String(bys, 0, len));
 // System.out.print(new String(bys, 0, len));
 // // 程式碼重複了，用迴圈改進
 // // 但是，我不知道結束條件
 // // len = fis.read(bys);
 // // System.out.println(len);
 // // len = fis.read(bys);
 // // System.out.println(len);
 // // 如果讀取到的實際長度是-1，就說明沒有資料了
 // byte[] bys = new byte[115]; // 0
 // int len = 0;
 // while ((len = fis.read(bys)) != -1) {
 // System.out.print(new String(bys, 0, len));
 // // System.out.print(new String(bys)); //千萬要帶上len的使用
 // }
 // 最終版程式碼
 // 陣列的長度一般是1024或者1024的整數倍
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = fis.read(bys)) != -1) {
 System.out.print(new String(bys, 0, len));
 }
 // 釋放資源
 fis.close();
 }
}

A:複製文字檔案

package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 複製文字檔案。
 * 
 * 資料來源：從哪裡來
 * a.txt -- 讀取資料 -- FileInputStream 
 * 
 * 目的地：到哪裡去
 * b.txt -- 寫資料 -- FileOutputStream
 * 
 * java.io.FileNotFoundException: a.txt (系統找不到指定的檔案。)
 * 
 * 這一次複製中文沒有出現任何問題，為什麼呢?
 * 上一次我們出現問題的原因在於我們每次獲取到一個位元組資料，就把該位元組資料轉換為了字元資料，然後輸出到控制檯。
 * 而這一次呢?確實通過IO流讀取資料，寫到文字檔案，你讀取一個位元組，我就寫入一個位元組，你沒有做任何的轉換。
 * 它會自己做轉換。
 */
public class CopyFileDemo {
 public static void main(String[] args) throws IOException {
 // 封裝資料來源
 FileInputStream fis = new FileInputStream("a.txt");
 // 封裝目的地
 FileOutputStream fos = new FileOutputStream("b.txt");
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 // 釋放資源(先關誰都行)
 fos.close();
 fis.close();
 }
}

B:把c盤下的a.txt的內容複製到d盤下的b.txt中

package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把c盤下的a.txt的內容複製到d盤下的b.txt中
 * 
 * 資料來源：
 *  c:\a.txt -- 讀取資料-- FileInputStream
 * 目的地：
 *  d:\b.txt -- 寫出資料 -- FileOutputStream
 */
public class CopyFileDemo2 {
 public static void main(String[] args) throws IOException {
 // 封裝資料來源
 FileInputStream fis = new FileInputStream("c:\a.txt");
 // 封裝目的地
 FileOutputStream fos = new FileOutputStream("d:\b.txt");
 // 複製資料
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 // 釋放資源
 fos.close();
 fis.close();
 }
}

c:複製圖片

package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把e:\林青霞.jpg內容複製到當前專案目錄下的mn.jpg中
 * 
 * 資料來源：
 *  e:\林青霞.jpg --讀取資料--FileInputStream
 * 目的地：
 *  mn.jpg--寫出資料--FileOutputStream
 */
public class CopyImageDemo {
 public static void main(String[] args) throws IOException {
 // 封裝資料來源
 FileInputStream fis = new FileInputStream("e:\林青霞.jpg");
 // 封裝目的地
 FileOutputStream fos = new FileOutputStream("mn.jpg");
 // 複製資料
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 // 釋放資源
 fos.close();
 fis.close();
 }
}

d:複製視訊

package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把e:\哥有老婆.mp4複製到當前專案目錄下的copy.mp4中
 * 
 * 資料來源：
 *  e:\哥有老婆.mp4--讀取資料--FileInputStream
 * 目的地：
 *  copy.mp4--寫出資料--FileOutputStream
 */
public class CopyMp4Demo {
 public static void main(String[] args) throws IOException {
 // 封裝資料來源
 FileInputStream fis = new FileInputStream("e:\哥有老婆.mp4");
 // 封裝目的地
 FileOutputStream fos = new FileOutputStream("copy.mp4");
 // 複製資料
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 // 釋放資源
 fos.close();
 fis.close();
 }
}

e:計算機是如何識別什麼時候該把兩個位元組轉換為一箇中文呢?

package cn.itcast_03;
import java.util.Arrays;
/*
 * 計算機是如何識別什麼時候該把兩個位元組轉換為一箇中文呢?
 * 在計算機中中文的儲存分兩個位元組：
 *  第一個位元組肯定是負數。
 *  第二個位元組常見的是負數，可能有正數。但是沒影響。
 */
public class StringDemo {
 public static void main(String[] args) {
 // String s = "abcde";
 // // [97, 98, 99, 100, 101]
 String s = "我愛你中國";
 // [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
 byte[] bys = s.getBytes();
 System.out.println(Arrays.toString(bys));
 }
}

(6)位元組緩衝區流

A:BufferedOutputStream

package cn.itcast_05;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 通過定義陣列的方式確實比以前一次讀取一個位元組的方式快很多，所以，看來有一個緩衝區還是非常好的。
 * 既然是這樣的話，那麼，java開始在設計的時候，它也考慮到了這個問題，就專門提供了帶緩衝區的位元組類。
 * 這種類被稱為：緩衝區類(高效類)
 * 寫資料：BufferedOutputStream
 * 讀資料：BufferedInputStream
 * 
 * 構造方法可以指定緩衝區的大小，但是我們一般用不上，因為預設緩衝區大小就足夠了。
 * 
 * 為什麼不傳遞一個具體的檔案或者檔案路徑，而是傳遞一個OutputStream物件呢?
 * 原因很簡單，位元組緩衝區流僅僅提供緩衝區，為高效而設計的。但是呢，真正的讀寫操作還得靠基本的流物件實現。
 */
public class BufferedOutputStreamDemo {
 public static void main(String[] args) throws IOException {
 // BufferedOutputStream(OutputStream out)
 // FileOutputStream fos = new FileOutputStream("bos.txt");
 // BufferedOutputStream bos = new BufferedOutputStream(fos);
 // 簡單寫法
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream("bos.txt"));
 // 寫資料
 bos.write("hello".getBytes());
 // 釋放資源
 bos.close();
 }
}

B:BufferedInputStream

package cn.itcast_05;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/*
 * 注意：雖然我們有兩種方式可以讀取，但是，請注意，這兩種方式針對同一個物件在一個程式碼中只能使用一個。
 */
public class BufferedInputStreamDemo {
 public static void main(String[] args) throws IOException {
 // BufferedInputStream(InputStream in)
 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
 "bos.txt"));
 // 讀取資料
 // int by = 0;
 // while ((by = bis.read()) != -1) {
 // System.out.print((char) by);
 // }
 // System.out.println("---------");
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = bis.read(bys)) != -1) {
 System.out.print(new String(bys, 0, len));
 }
 // 釋放資源
 bis.close();
 }
}

(7)案例：4種實現

基本位元組流一次讀寫一個位元組： 共耗時：117235毫秒

基本位元組流一次讀寫一個位元組陣列： 共耗時：156毫秒

高效位元組流一次讀寫一個位元組： 共耗時：1141毫秒

高效位元組流一次讀寫一個位元組陣列： 共耗時：47毫秒

package cn.itcast_06;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把e:\哥有老婆.mp4複製到當前專案目錄下的copy.mp4中
 * 
 * 位元組流四種方式複製檔案：
 * 基本位元組流一次讀寫一個位元組： 共耗時：117235毫秒
 * 基本位元組流一次讀寫一個位元組陣列： 共耗時：156毫秒
 * 高效位元組流一次讀寫一個位元組： 共耗時：1141毫秒
 * 高效位元組流一次讀寫一個位元組陣列： 共耗時：47毫秒 ***必須掌握****
 */
public class CopyMp4Demo {
 public static void main(String[] args) throws IOException {
 //測試時間
 long start = System.currentTimeMillis();
 // method1("e:\哥有老婆.mp4", "copy1.mp4");
 // method2("e:\哥有老婆.mp4", "copy2.mp4");
 // method3("e:\哥有老婆.mp4", "copy3.mp4");
 method4("e:\哥有老婆.mp4", "copy4.mp4");
 long end = System.currentTimeMillis();
 System.out.println("共耗時：" + (end - start) + "毫秒");
 }
 // 高效位元組流一次讀寫一個位元組陣列：
 public static void method4(String srcString, String destString)
 throws IOException {
 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
 srcString));
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream(destString));
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = bis.read(bys)) != -1) {
 bos.write(bys, 0, len);
 }
 bos.close();
 bis.close();
 }
 // 高效位元組流一次讀寫一個位元組：
 public static void method3(String srcString, String destString)
 throws IOException {
 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
 srcString));
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream(destString));
 int by = 0;
 while ((by = bis.read()) != -1) {
 bos.write(by);
 }
 bos.close();
 bis.close();
 }
 // 基本位元組流一次讀寫一個位元組陣列
 public static void method2(String srcString, String destString)
 throws IOException {
 FileInputStream fis = new FileInputStream(srcString);
 FileOutputStream fos = new FileOutputStream(destString);
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = fis.read(bys)) != -1) {
 fos.write(bys, 0, len);
 }
 fos.close();
 fis.close();
 }
 // 基本位元組流一次讀寫一個位元組
 public static void method1(String srcString, String destString)
 throws IOException {
 FileInputStream fis = new FileInputStream(srcString);
 FileOutputStream fos = new FileOutputStream(destString);
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 fos.close();
 fis.close();
 }
}

A:複製文字檔案

package cn.itcast_04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把c:\a.txt內容複製到d:\b.txt中
 * 
 * 資料來源：
 *  c:\a.txt -- 讀取資料 -- FileInputStream
 * 目的地：
 *  d:\b.txt -- 寫出資料 -- FileOutputStream
 */
public class CopyFileDemo {
 public static void main(String[] args) throws IOException {
 // 封裝資料來源
 FileInputStream fis = new FileInputStream("c:\a.txt");
 FileOutputStream fos = new FileOutputStream("d:\b.txt");
 // 複製資料
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = fis.read(bys)) != -1) {
 fos.write(bys, 0, len);
 }
 // 釋放資源
 fos.close();
 fis.close();
 }
}

B:複製圖片

C:複製視訊

package cn.itcast_04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把e:\哥有老婆.mp4複製到當前專案目錄下的copy.mp4中
 * 
 * 資料來源：
 *  e:\哥有老婆.mp4--讀取資料--FileInputStream
 * 目的地：
 *  copy.mp4--寫出資料--FileOutputStream
 */
public class CopyMp4Demo {
 public static void main(String[] args) throws IOException {
 // 封裝資料來源
 FileInputStream fis = new FileInputStream("e:\哥有老婆.mp4");
 // 封裝目的地
 FileOutputStream fos = new FileOutputStream("copy.mp4");
 // 複製資料
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = fis.read(bys)) != -1) {
 fos.write(bys, 0, len);
 }
 // 釋放資源
 fos.close();
 fis.close();
 }
}

3:自學字元流

IO流分類

位元組流：

InputStream

FileInputStream

BufferedInputStream

OutputStream

FileOutputStream

BufferedOutputStream

字元流：

Reader

FileReader

BufferedReader

Writer

FileWriter

BufferedWriter

相關推薦

Java基礎-20（02）總結,遞迴，IO流

(4)FileInputStream讀取資料 A:操作步驟 a:建立位元組輸入流物件 b:呼叫read()方法 c:釋放資源

Java基礎-20（01）總結,遞迴，IO流

1:遞迴(理解) (1)方法定義中呼叫方法本身的現象 舉例：老和尚給小和尚講故事，我們學程式設計

Java基礎-08（02）總結幫助文件，程式碼塊，繼承

(9)兩個面試題： A:Override和Overload的區別?Overload是否可以改變返回值型別? B:this和super的區別和各自的作用?

Java基礎-07（02）.總結private,this,封裝，static，成員方法變數，區域性變數匿名物件

9:面向物件的練習題(掌握) (1)標準的手機類的定義和測試 (2)Demo類有求和方法，Test類進行測試。

Java基礎-18（02）總結Map,HashMap,HashMap與Hashtable區別，Collections工具類

(8)Hashtable和HashMap的區別? package cn.itcast_07; import java.util.Hashtable; /* * 1:Hashtable和HashMap的區別?

Java基礎-21（02）總結字元流,IO流編碼問題,實用案例必做一遍

C:把集合中的資料儲存到文字檔案 package cn.itcast_02; import java.io.BufferedWriter; import java.io.FileWriter;

Java基礎19（02）總結IO流，異常try…catch，throws，File類

案例： a:考試成績必須滿足在0——100之間，不滿足就丟擲異常。 package cn.itcast_08（1）;

Java基礎-26（02）總結網路程式設計

c:客戶端鍵盤錄入伺服器控制檯輸出 package cn.itcast_08; import java.io.BufferedReader; import java.io.BufferedWriter;

Java基礎-08（01）總結幫助文件，程式碼塊，繼承

1:如何製作幫助文件(瞭解) (1)寫一個類 (2)加入文件註釋 (3)通過javadoc工具生成即可

Java基礎-07（01）.總結private,this,封裝，static，成員方法變數，區域性變數匿名物件

1:成員變數和區域性變數的區別(理解) (1)在類中的位置不同 成員變數：類中方法外

Java基礎-18（01）總結Map,HashMap,HashMap與Hashtable區別，Collections工具類

1:Map(掌握) (1)將鍵對映到值的物件。一個對映不能包含重複的鍵；每個鍵最多隻能對映到一個值。

Java基礎-17（01）總結,登入註冊案例,Set集合,HashSet

1:登入註冊案例(理解)需求：使用者登入註冊案例。 按照如下的操作，可以讓我們更符號面向物件思想

Java基礎-17（01）總結,TreeSet,LinkHashSet

(3)TreeSet集合 A:底層資料結構是紅黑樹(是一個自平衡的二叉樹) B:保證元素的排序方式

Java基礎-21（01）總結字元流,IO流編碼問題,實用案例必做一遍

1:字元流(掌握) // 位元組流讀取中文可能出現的小問題(所以用字元流輸入輸出中文)

Java基礎19（01）總結IO流，異常try…catch，throws，File類

1:異常(理解) (1)程式出現的不正常的情況。 (2)異常的體系 Throwable --Error 嚴重問題，我們不處理。

Java基礎-26（01）總結網路程式設計

1:網路程式設計(理解) (1)網路程式設計：用Java語言實現計算機間資料的資訊傳遞和資源共享

Java進階（六）_泛型與IO流

一、泛型 1.為什麼要有泛型？ 泛型：標籤 泛型的設計背景 集合容器類在設計階段/宣告階段不能確定這個容器到底實際存的是什麼型別的物件，所以在JDK5.0之前只能把元素型別設計為Object，JDK5.0之後使用泛型來解決

跟著阿里學JavaDay07——Java基礎語法（五）

我們後面的筆記我，打算直接用程式，加註釋進行記錄。日後若本人有疑問，可進行網路查詢加以整理回覆

Java基礎問答（一）

技術標籤：java 問題一 程式碼片段 public final class Person { private String name; private int age;

Java基礎系列（2）- JDK安裝

一、JAVA_HOME、PATH、CLASSPATH詳解 1.1 JAVA_HOME 指向jdk安裝目錄，該目錄下有bin、lib目錄。Eclipse/NetBeans/Tomcat等軟體就是通過搜尋JAVA_HOME變數來找到並使用安裝好的jdk。