編碼表、字節流、字節緩沖流
概念：
字節流不需要刷新(byte)
字符流需要刷新(char)
IO流：input(通過Java程序往內存裏讀取) output(通過Java程序往硬盤上外寫出) 輸入輸出流
* IO流的分類
* 按照操作的數據不同
* 字節流：操作字節，由於計算機上一切皆是字節，字節流可以操作一切數據
* 字符流：操作字符，只能操作文本文件
* 文本文件:能使用文本工具 打開 看懂的叫做文本文件 txt java html xml css。（ world excel是文本文件嗎？ 不是文本）
* 按照流向分類
* 字節流
* 字節輸入流 InputStream read 讀一個字節 讀一個字節數組
* FileInputStream
* BufferedInputStream
BufferedInputStream infile=new BufferedInputStrean(new FileInputStream("文件路徑") );
* 字節輸出流 OutputStream write 寫一個字節 寫一個字節數組 寫字節數組的一部分
* FileOutputStream
* BufferedOutputStream
* 字符流
* 字符輸入流 Reader read 讀一個字符 讀一個字符數組
* FileReader
* BufferedReader
* 字符輸出流 Writer write 寫一個字符 寫一個字符數組 寫字符數組的一部分 寫字符串
* FileWriter
* BufferedWriter
* java.io.OutputStream 所有字節輸出流的抽象超類
* 方法
* write(int b) 寫一個字節
* write(byte[] byte) 寫一個字節數組
* write(byte[] bytes,int offset, int length) 寫字節數組的一部分
* close() 關閉資源
*
* 常用子類
* FileOutputStream
* 構造方法綁定數據目的
* FileOutputStream(File file)
* FileOutputStream(String name)
* 參數
* File對象
* String路徑
* IO流對象本身沒有讀寫功能，需要調用操作系統的讀寫功能 完成讀寫
* 在調用後，需要關閉資源
文件的續寫與換行
* 續寫
* FileOutputStream類的構造方法
* FileOutputStream(File file, boolean append)
* FileOutputStream(String name, boolean append)
* 當參數 append為true時 則續寫 為false則覆蓋 不加append默認false
java.io.InputStream 所有字節輸入流的超類
* 方法
* int read() 讀一個字節
* int read(byte[] bytes) 讀一個字節數組
* 常用子類
* FileInputStream
* 構造方法綁定數據源
* FileInputStream(File file)
* FileInputStream(String name)
* 參數
* File對象
* String路徑
* int read(byte[] bytes) 讀一個字節數組
*
* 返回值
* int 讀取的有效字節數(返回的是有效個數)
java.io.BufferedOutputStream extends OutputStream 字節輸出緩沖流
* 可以使用所有OutputStream的方法 write 寫一個字節 一個字節數組 一個字節數組的一部分
* 構造方法
* BufferedOutputStream(OutputStream out)
* 參數
* OutputStream out:所有字節輸出流的超類 ，抽象類不能創建對象，需要傳入其子類對象
* FileOutputStream
java.io.BufferedInputStream extends InputStream 字節輸入緩沖流
* 可以使用所有InputStream的方法 read 讀一個字節 讀一個字節數組
* 構造方法
* BufferedInputStream(InputStream in)
* 參數
* InputStream in:所有字節輸入流的超類，抽象類不能創建對象 ，需要傳入其子類對象
* FileInputStream
java.util.Properties extends Hashtable implements Map
* 鍵和值都是字符串類型 唯一一個可以和IO流直接結合使用的集合
*
* 方法
* setProperty(String key,String value) 添加元素 put(K key ,V value)
* String getProperty(String key) 根據鍵找值
* Set<String> stringPropertyNames() 獲取所有鍵的set集合
<讀取文件>和IO流結合使用
* load(InputStream in) 將文件中的鍵值對加載進集合
* load(Reader in)
* 參數 任意輸入流對象
<寫入文件>
* store(OutputStream out ,String com) 將集合中的數據 寫入到配置文件中
* store(Writer out ,String com)
* 參數 任意輸出流對象
<復制文件例子復制(H:\\刪除添加練習使用文件1)到(H:\\刪除添加練習使用文件2)>
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDir {
public static void main(String[] args) throws IOException {
File src = new File("H:\\刪除添加練習使用文件1");
File dest = new File("H:\\刪除添加練習使用文件2");
copyDir(src,dest);
}
public static void copyDir(File srcDir,File destDir) throws IOException{
//確定文件夾的數據源和數據目的
//獲取數據源的文件夾名稱
String srcDirName = srcDir.getName();
//確定文件夾的數據目的
//使用數據目的+數據源的文件夾名稱 拼出最終的數據目的
File destDir2 = new File(destDir,srcDirName);
System.out.println("--------復制文件--------------");
if(srcDir.isDirectory()){
//創建數據目的文件夾
destDir2.mkdirs();
//獲取數據源文件夾的所有文件
File[] srcFileArr = srcDir.listFiles();
//遍歷數組 依次獲取到每個數據源文件
for(File srcFile: srcFileArr){
//確定數據目的的文件
//獲取數據源的文件名
if(srcFile.isDirectory()){
copyDir(srcFile, destDir2);
}else{
String srcFileName = srcFile.getName();
//使用數據目的的文件夾 + 源文件的文件名 確定數據目的的文件
File destFile = new File(destDir2,srcFileName);
//復制文件
copy(srcFile,destFile);
}
}
}else{
String srcFileName = srcDir.getName();
//使用數據目的的文件夾 + 源文件的文件名 確定數據目的的文件
File destFile = new File(destDir2,srcFileName);
//復制文件
copy(srcDir,destFile);
}
}
public static void copy(File src,File dest) throws IOException{
//創建字節緩沖輸入流對象，綁定字節輸入流，綁定數據源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
//創建字節緩沖輸出流對象，綁定字節輸出流，綁定數據目的
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
byte[] bytes = new byte[1024];
int len = 0;
while((len = bis.read(bytes))!=-1){
bos.write(bytes, 0, len);
}
//關閉資源
bos.close();
bis.close();
}
}
<文件復制例子二>
package Test_03_03;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
/*
* 從控制臺獲取輸入的文件目錄然後將該目錄(包含子目錄)下的.java文件復制到D:/java文件夾中,並統計java文件的個數.
提示:如果有相同的名稱的文件,如果兩個Test01.java,則拷貝到目標文件夾時只能有一個Test01.java,
另一個Test01.java要修改為另一個名稱:該名稱可隨機生成,只要不重復即可.
*/
public class Test {
static int sum=0;
public static void main(String[] args) throws IOException {
Scanner sc=new Scanner (System.in);
System.out.println("請輸入要訪問的文件目錄:");
String str=sc.nextLine();
//根據輸入的目錄創建文件
File file1=new File(str);
File file2=new File("H:\\刪除添加練習使用文件2");
file2.mkdirs();
copyPath(file1,file2);
}
//文件路徑復制
public static void copyPath(File file1,File file2) throws IOException{
if(file1.isDirectory()){
File[] file=file1.listFiles(new FileFilter(){
@Override
public boolean accept(File pathname) {
//判斷如果是以
if(pathname.getName().endsWith(".java")||pathname.isDirectory()){
return true;
}
return false;
}
});
//如果是文件夾添加後遍歷進行文件存儲
for (File file3 : file) {
if(file3.isDirectory()){
copyPath(file3,file2);
}else{
String str2=file3.getName();
File file11=new File(file2,str2);
//如果同名隨機一個名字遞歸直到不重名
while(file11.exists()){
file11 = new File(file2,new Random().nextInt(100000) + str2);
}
//file11.mkdir();
System.out.println(file11);
copy(file3,file11);
}
}
}else{
if(file1.getName().endsWith(".java")){
String str2=file1.getName();
File file11=new File(file2,str2);
copy(file1,file11);
}else{
System.out.println("你輸入的不是文件夾:");
}
}
}
public static void copy(File file1,File file2) throws IOException{
//創建文件高效寫流
BufferedOutputStream outfile=new BufferedOutputStream(new FileOutputStream(file2));
//創建文件高效讀取流
BufferedInputStream infile=new BufferedInputStream(new FileInputStream(file1));
byte[] b=new byte[1024];
int len=0;
while((len=infile.read(b))!=-1){
outfile.write(b,0,len);
}
outfile.close();
infile.close();
sum++;
}
}
按照流向分：輸入流與輸出流，每個IO流對象均要綁定一個IO資源
分類關系如下：
字節輸入流 InputStream 抽象類
FileInputStream 操作文件的字節輸入流
字節輸出流 OutputStream 抽象類
FileOutputStream 操作文件的字節輸出流
字符輸入流 Writer寫入字符流的抽象類
FlieWriter操作文件的字符輸入流
字符輸出流 Reader用於讀取字符流的抽象類
FileReader操作文件的字符輸入流
緩沖流，根據流的分類分類字節緩沖流與字符緩沖流。
字節緩沖流:BufferedInputStream
BufferedOutputStrea
字符緩沖流:BufferedReader
BufferedWriter
<字節流不需要刷新字符流需要>
按照傳輸方式:分為字節流和字符流
字符流 按照字符的方式讀寫
字節流 按照字節的方式讀寫
定義一個緩沖區提高效率
字節型 byte[] bytes=new byte[1024];
字符型 char[] ch=new char[1024];
編碼表、字節流、字節緩沖流