用缓冲流读取文件的信息，之后打印到控制台

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));

// 以前是边读部分，边写部分。现在用了缓冲流后，就是全部读完后，再写。

String wenJianZiFuChuan = null;

while (true) {

wenJianZiFuChuan = reader.readLine();

// .read() 每次读取整个文件，

// 它通常将读取到底文件内容放到一个字符串变量中，

// 也就是说 .read() 生成文件内容是一个字符串类型。

// .readline()每只读取文件的一行，通常也是读取到

// 的一行内容放到一个字符串变量中，返回str类型。

// .readlines()每次按行读取整个文件内容，将读取

// 到的内容放到一个列表中，返回list类型。

if(wenJianZiFuChuan!=null)

System.out.println(wenJianZiFuChuan);

else

break;

}

shuRuLiu.close();

} catch (Exception e) {

e.printStackTrace();

}

}

}

使用BufferedReader一次读取单个字符（就是用char，不用char数值）输出到控制台

package IO;

import java.io.BufferedReader;

import java.io.FileReader;

public class charOne {

public static void main(String[] args)  throws Exception{

// 用BufferedReader来储存文件内容：

BufferedReader chuCunWenJianNeiRong=new 

BufferedReader(new FileReader("xiangDui.txt"));

int length;

while( (length=chuCunWenJianNeiRong.read())!=-1){

System. out . print( (char )length);

}

chuCunWenJianNeiRong .close();

}

}

使用BufferedReader一次读取字符数组（就是一次读取多个字符，就是在读完前一次读取声明的数值长度）输出到控制台

package IO;

import java.io.*;

public class DanCharShuZu {

public static void main(String[] args)  throws Exception{

// 用BufferedReader来储存文件内容：

BufferedReader chuCunWenJianNeiRong=new 

BufferedReader(new FileReader("xiangDui.txt"));

// 字节流(byte)更好，更广泛，因为很多都是以字节的形式储存的，比如图片

// 字符流（char）

int changDu;

// ：长度

char[] shuZu=new char[100];

//：1次读100个文字

while((changDu=chuCunWenJianNeiRong.read())!=-1){

//

// 当读到底时，就是读到末尾，chuCunWenJianNeiRong

// .read()会返回出-1 ，数值为-1

//

System.out.print((char)changDu);

}

chuCunWenJianNeiRong.close();

// 我是诗书画唱，给三连和关注！

// 用字节流时，打印的中文会乱码，要用英文

}

}

自己出的题目：打印java文件的第一行和第二行

package IO;

import java.io.BufferedReader;

import java.io.FileReader;

public class charReadLine {

public static void main(String[] args)  throws Exception{

// 用BufferedReader来储存文件内容：

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文件的全部内容，使用BufferedReader一次一行数据输出到控制台

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循环,输出流或输入流

// 等后都要用.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("请输入内容");

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("输入的内容已经写入到aa.txt中");

}

}

使用BufferedOutStream复制一张图片

package IO;

import java.io.*;

public class copyImg {

public static void main(String[] args) throws Exception {

File oldWenJianLuJingFile=new File("D://集成开发工具/PS图片.png");

// :File类型的老的（原来，根源的）文件路径

BufferedInputStream oldShuRuLliu=

new BufferedInputStream(

new FileInputStream(oldWenJianLuJingFile));

BufferedOutputStream newShuChuLiu=

new BufferedOutputStream(new FileOutputStream("PS图片.png"));

// ：这里"PS图片"相当于是相对路径

// ziJieShuZu：字节数组

byte[] ziJieShuZu=new byte[1024];

int length=0;

while((length=oldShuRuLliu.read(ziJieShuZu))!=-1){

newShuChuLiu.write(ziJieShuZu,0,length);

}

newShuChuLiu.flush();

newShuChuLiu.close();

// 读入（输入流）的内容通常要用write，flush，close，

// 不用flush等时可能文件复制等后有用，但可能复制等得不完整等。

// 写出（输出流）的内容通常要用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://集成开发工具”）\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类型的数组，所以声明为File[] XXX

File[] wenJianShuZu=oldWenJian.listFiles();

for(File i:wenJianShuZu){

if(i.isHidden()){

continue;

}

if(i.isFile()){

// fileinputstream ：

// 网络 文件输入流; 字节输入流; 字节流;

// FileInputStream 用于读取诸如图像数据之类的原始字节流。

// 要读取字符流，请考虑使用 FileReader。

// FileInputStream 包含其他一些输入流，

// 它将这些流用作其基本数据源，

// 它可以直接传输数据或提供一些额外的功能。

// 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("复制成功！");

} 

// 下面是可以直接到主函数调用的方法：

// 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判断是不是系统文件

// 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());

////

////

//// 规范路径名是绝对路径名，并且是惟一的。

//// 规范路径名的准确定义与系统有关。如有必要

//// ，此方法首先将路径名转换成绝对路径名，

//// 这与调用 getAbsolutePath() 方法的效果一样，

//// 然后用与系统相关的方式将它映射到其惟一路径名。

//// 这通常涉及到从路径名中移除多余的名称

//// （比如 "." 和 ".."）、分析符号连接

//// （对于 UNIX 平台），以及将驱动器名转

//// 换成标准大小写形式（对于 Microsoft Windows 平台）。 

//

// }

// }

// }

// }

// }

}