Java緩沖流，每次讀取一個字符，數(shù)組，復制圖片，輸入，一次一行地讀取【詩書畫唱】
用緩沖流讀取文件的信息，之后打印到控制臺
package huanChongLiu;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
?
public class liZi1 {
public static void main(String[] args) {
try {
InputStream shuRuLiu = new FileInputStream("zhuiJia.txt");
BufferedReader reader = new BufferedReader(
new InputStreamReader(shuRuLiu));
// 以前是邊讀部分，邊寫部分。現(xiàn)在用了緩沖流后，就是全部讀完后，再寫。
String wenJianZiFuChuan = null;
while (true) {
wenJianZiFuChuan = reader.readLine();
// .read() 每次讀取整個文件，
// 它通常將讀取到底文件內(nèi)容放到一個字符串變量中，
// 也就是說 .read() 生成文件內(nèi)容是一個字符串類型。
// .readline()每只讀取文件的一行，通常也是讀取到
// 的一行內(nèi)容放到一個字符串變量中，返回str類型。
// .readlines()每次按行讀取整個文件內(nèi)容，將讀取
// 到的內(nèi)容放到一個列表中，返回list類型。
if(wenJianZiFuChuan!=null)
System.out.println(wenJianZiFuChuan);
else
break;
}
shuRuLiu.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
使用BufferedReader一次讀取單個字符（就是用char，不用char數(shù)值）輸出到控制臺
package IO;
import java.io.BufferedReader;
import java.io.FileReader;
public class charOne {
public static void main(String[] args)? throws Exception{
// 用BufferedReader來儲存文件內(nèi)容：
BufferedReader chuCunWenJianNeiRong=new?
BufferedReader(new FileReader("xiangDui.txt"));
int length;
while( (length=chuCunWenJianNeiRong.read())!=-1){
System. out . print( (char )length);
}
chuCunWenJianNeiRong .close();
}
}
使用BufferedReader一次讀取字符數(shù)組（就是一次讀取多個字符，就是在讀完前一次讀取聲明的數(shù)值長度）輸出到控制臺
package IO;
import java.io.*;
public class DanCharShuZu {
public static void main(String[] args)? throws Exception{
// 用BufferedReader來儲存文件內(nèi)容：
BufferedReader chuCunWenJianNeiRong=new?
BufferedReader(new FileReader("xiangDui.txt"));
// 字節(jié)流(byte)更好，更廣泛，因為很多都是以字節(jié)的形式儲存的，比如圖片
// 字符流（char）
int changDu;
// ：長度
char[] shuZu=new char[100];
//：1次讀100個文字
while((changDu=chuCunWenJianNeiRong.read())!=-1){
//
// 當讀到底時，就是讀到末尾，chuCunWenJianNeiRong
// .read()會返回出-1 ，數(shù)值為-1
//
System.out.print((char)changDu);
}
chuCunWenJianNeiRong.close();
// 我是詩書畫唱，給三連和關注！
// 用字節(jié)流時，打印的中文會亂碼，要用英文
}
}
自己出的題目：打印java文件的第一行和第二行
package IO;
import java.io.BufferedReader;
import java.io.FileReader;
public class charReadLine {
public static void main(String[] args)? throws Exception{
// 用BufferedReader來儲存文件內(nèi)容：
BufferedReader chuCunWenJianNeiRong=new?
BufferedReader(new FileReader("src//IO/charOne.java"));
// /:目錄的分割符
// "xxx(xxx)"格式的代碼都是構造方法
String firstLine=chuCunWenJianNeiRong. readLine();
String sectionLine=chuCunWenJianNeiRong. readLine();
System. out.println(firstLine);
System. out.println(sectionLine);
}}
打印出java文件的全部內(nèi)容，使用BufferedReader一次一行數(shù)據(jù)輸出到控制臺
package IO;
import java.io.*;
public class readLine {
public static void main(String[] args) throws Exception {
BufferedReader shuChuLiu=new?
BufferedReader(new FileReader("src//IO/charOne.java"));
String ziFuChuan=shuChuLiu .readLine();
while((ziFuChuan=shuChuLiu.readLine())!=null){
//:因為ziFuChuan不為int類型為Null類型,所以用null來判斷等
System. out . println(ziFuChuan);
}
shuChuLiu .close() ;
//一般來說每次用了while循環(huán),輸出流或輸入流
// 等后都要用.close關閉前面聲明的輸出流或輸入流
}
}
提示用戶輸入一句話，在項目根目錄下聲明一個文件aa.txt,使用BufferedWriter將這句話寫入到aa.txt中
package IO;
import java.io.*;
import java.util.*;
public class ScannerLizi {
public static void main(String[] args) throws Exception {
// InputStream in=System. in;
// :表示為標準輸入流,Scanner s=new Scanner(System.in);中用了
// ____________
// OutputStream out=System. out ;
// :表示為標準輸出流,System. out.println("b");中用了
// shuRu:輸入
// jieShouHang:接收行
// nextLine:是一行一行地獲取,接收
System.out.println("請輸入內(nèi)容");
Scanner shuRu=new Scanner(System.in);
String jieShouHang=shuRu.nextLine();
File wenJian=new File("aa.txt");
if(wenJian.exists()){
wenJian.delete();
wenJian.createNewFile();
}else{
wenJian.createNewFile();
}
// shuRuLiu：輸入流
BufferedWriter shuRuLiu=new BufferedWriter(new FileWriter(wenJian));
shuRuLiu.write(jieShouHang);
shuRuLiu.flush();
shuRuLiu.close();
System.out.println("輸入的內(nèi)容已經(jīng)寫入到aa.txt中");
}
}
使用BufferedOutStream復制一張圖片
package IO;
import java.io.*;
public class copyImg {
public static void main(String[] args) throws Exception {
File oldWenJianLuJingFile=new File("D://集成開發(fā)工具/PS圖片.png");
// :File類型的老的（原來，根源的）文件路徑
BufferedInputStream oldShuRuLliu=
new BufferedInputStream(
new FileInputStream(oldWenJianLuJingFile));
BufferedOutputStream newShuChuLiu=
new BufferedOutputStream(new FileOutputStream("PS圖片.png"));
// ：這里"PS圖片"相當于是相對路徑
// ziJieShuZu：字節(jié)數(shù)組
byte[] ziJieShuZu=new byte[1024];
int length=0;
while((length=oldShuRuLliu.read(ziJieShuZu))!=-1){
newShuChuLiu.write(ziJieShuZu,0,length);
}
newShuChuLiu.flush();
newShuChuLiu.close();
// 讀入（輸入流）的內(nèi)容通常要用write，flush，close，
// 不用flush等時可能文件復制等后有用，但可能復制等得不完整等。
// 寫出（輸出流）的內(nèi)容通常要用FileReader，close
oldShuRuLliu.close();
System.out.println("復制成功！");
}}
提示用戶輸入一個路徑，復制該文件夾下的所有.jpg.png的圖片到一個新路徑
//提示用戶輸入一個路徑，復制該文件夾下的所有.jpg.png的圖片到一個新路徑
package IO;
import java.io.*;
import java.util.Scanner;
public class scannnerShuLu {
public static void main(String[] args) throws Exception{
System. out . println("請輸入一個路徑（比如“D://集成開發(fā)工具”）\n"
+ ",之后就會復制該文件夾下的所有.jpg.png"
+ "\n的圖片到一個新路徑");
Scanner s=new Scanner(System. in);
String neiRong=s.next() ;
File oldWenJian=new File(neiRong);
File xiangDuiLuJing=new File("NewFile");
// "NewFile"在項目中是和src同級的文件夾
if(oldWenJian.exists()){
// ：如果oldWenJian(老文件）存在，就用listFiles遍歷出來
// 用了listFiles這個方法后就會返回，就是生成
// File類型的數(shù)組，所以聲明為File[] XXX
File[] wenJianShuZu=oldWenJian.listFiles();
for(File i:wenJianShuZu){
if(i.isHidden()){
continue;
}
if(i.isFile()){
// fileinputstream ：
// 網(wǎng)絡 文件輸入流; 字節(jié)輸入流; 字節(jié)流;
// FileInputStream 用于讀取諸如圖像數(shù)據(jù)之類的原始字節(jié)流。
// 要讀取字符流，請考慮使用 FileReader。
// FileInputStream 包含其他一些輸入流，
// 它將這些流用作其基本數(shù)據(jù)源，
// 它可以直接傳輸數(shù)據(jù)或提供一些額外的功能。
// FileInputStream 類本身只是簡單地重
// 寫那些將所有請求傳遞給所包含輸入流的
// InputStream 的所有方法。
// FileInputStream 的子類可進一步重
// 寫這些方法中的一些方法，并且還可以提供一些額外的方法和字段。
FileInputStream shuRuLiu=
new FileInputStream(i.getAbsolutePath());
// houZhuiMing：后綴名
String houZhuiMing=i.getName().substring
(i.getName().lastIndexOf("."));
// System.out.println(houZhuiMing);
if(houZhuiMing.equals(".jpg")||houZhuiMing.equals(".png")){
BufferedInputStream huanChongShuRuLiu=new BufferedInputStream(shuRuLiu);
BufferedOutputStream huanChongShuChuLiu
=new BufferedOutputStream(new FileOutputStream
(xiangDuiLuJing.getAbsolutePath()+"/"+i.getName()));
int shuZuLength;
byte[] ziJieShuZu=new byte[1024];
while((shuZuLength=huanChongShuRuLiu.read(ziJieShuZu))!=-1){
huanChongShuChuLiu.write(ziJieShuZu,0,shuZuLength);
}
huanChongShuChuLiu.flush();huanChongShuChuLiu.close();
huanChongShuRuLiu.close();
}
}
}
}System.out.println("復制成功！");
}?
// 下面是可以直接到主函數(shù)調(diào)用的方法：
// public static void Copy(String oldLuJing,
// String newLuJing)throws Exception{
// //傳入的是兩個字符串，所以要首先要用File將其轉換為File對象
// File oldLuJingFile=new File(oldLuJing);//原路徑
// File newLuJingFile=new File(newLuJing);//復制到的路徑
// newLuJingFile.mkdir();
// //用exists判斷原路徑是不是存在，
//// 用isHidden判斷是不是系統(tǒng)文件
// if(oldLuJingFile.exists()){
// if(!oldLuJingFile.isHidden()){
// //用listFiles獲取所有的子文件
// File[] fs=oldLuJingFile.listFiles();
// //用for遍歷所有的文件
// for(File i:fs){
// //用isFile判斷每個文件是文件夾還是文件
// if(i.isFile()){
////用FileInputStream找到這個文件
//FileInputStream shuLuLiu=new FileInputStream(i.getAbsolutePath());
// FileOutputStream shuChuLiu=new FileOutputStream
// (newLuJingFile.getAbsolutePath()+"/"+i.getName());
// byte[] ziJieShuZu=new byte[100];
// int length;
// while((length=shuLuLiu.read(ziJieShuZu))!=-1){
// shuChuLiu.write(ziJieShuZu,0,length);
// shuChuLiu.flush();
// }
// shuChuLiu.close();
// shuLuLiu.close();
// }else {
// Copy(i.getCanonicalPath(),newLuJing+"/"+i.getName());
////
////
//// 規(guī)范路徑名是絕對路徑名，并且是惟一的。
//// 規(guī)范路徑名的準確定義與系統(tǒng)有關。如有必要
//// ，此方法首先將路徑名轉換成絕對路徑名，
//// 這與調(diào)用 getAbsolutePath() 方法的效果一樣，
//// 然后用與系統(tǒng)相關的方式將它映射到其惟一路徑名。
//// 這通常涉及到從路徑名中移除多余的名稱
//// （比如 "." 和 ".."）、分析符號連接
//// （對于 UNIX 平臺），以及將驅(qū)動器名轉
//// 換成標準大小寫形式（對于 Microsoft Windows 平臺）。?
//
// }
// }
// }
// }
// }
}
