java 文件 输入输出流的使用（字节流，字符流的输入输出）缓冲流的使用

Java

字节输入输出流：    （1）定义的方法有：

1. int read()
2. Int read(byte[] buffer)：len=fis.read(byt)    fis输入流read读放入byt数组，把读到的字节个数返回给len
3. Int read(byte[] buffer,int offest,int length)  索引从offest开始到定义的length结束，防止数组有空字节出错

InputStream(父类)      （2）子类：                     1、实例对象（添加文件地址）

                      1、FileInputStream(文件输入流)    2、调用父类的read()方法读取文件

InputStream是抽象的，所以在new对象的时候InputStream  s=new FileInputStream();

InputStream is=new FileInputStream(file);

byte[] byt=new byte[1024];

int len=is.read(byt);//返回读取到的字节数

System.out.println(new String(byt,0,len));//将读取到的信息原型输出

字节输出流：写入文件

OutputStream

OutputStream os=new FileOutputStream(file);//写入文件将原来的内容覆盖，不续写

OutputStream os1=new FileOutputStream(file,true);//续写原来的内容

os1.write("不纠结".getBytes());//将信息写入文件

字节输入输出流

字节输入流FileInputStream()

（1）第一种读取方式：效率低FileInputStream fis=new FileInputStream("D:/exam/a/bbbb.txt");

int a=0;

while((a=fis.read())!=-1) {         //读取数据是一个一个的读取

System.out.println((char)a);

（2）另一种读取方式：将读取到的数据存放在字节数组中，最后将字节数组转换成字符串，以字符串的形式输出。

FileInputStream fis=new FileInputStream("D:/exam/a/bbbb.txt");

byte[] byt=new byte[1024];

int i=0;    while((i=fis.read(byt))!=-1) { System.out.println(new String(byt));}

1. 对2的改写：用到了FileInputStream的方法available()为了读取文件里数据的个数，直接可以定义一个刚刚好的字节数组，即不用循环语句

FileInputStream fis=new FileInputStream("D:/exam/a/bbbb.txt");

byte[] byt=new byte[fis.available()];//定义字节数组改写

fis.read(byt);//不用使用循环

//int i=0;

System.out.println(new String(byt));

（4）图片的复制是通过字节输入输出流实现的：

图片的复制

//首先将图片或者视频写入到缓冲区中，然后再通过字节输出流将缓冲区的内容输出到致指定的文件中。

1. 写入缓冲区中 FileInputStream(),写入缓存的时候要定义字节型数组，江都区道德内容放到字节数组中
2. 写入内存中FileOutputStream()

fis=new FileInputStream("G:/原来.mp4");

fos=new FileOutputStream("G:/原来2.mp4");

byte[] buf=new byte[1024];

int len=0;

while((len=fis.read(buf))!=-1) {//就是一个读，一个写//len表示读取的长度

fos.write(buf,0,len);

}

} catch(IOException e) {

throw new RuntimeException("复制文件失败");

}

finally {

try {

if(fis!=null)

fis.close();

}catch(IOException e) {

throw new RuntimeException("读取关闭失败");

}

图片的复制使用缓冲的输入输出流

FileInputStream fis=new FileInputStream("G:/原来.mp4");

FileOutputStream fos=new FileOutputStream("G:/原来3.mp4");

BufferedInputStream bis=new BufferedInputStream(fis);

BufferedOutputStream bos=new BufferedOutputStream(fos);

byte[] byt=new byte[1024];

int i=0;

while((i=fis.read(byt))!=0) {

fos.write(byt);

}

键盘的录入：关键InputStream in=System.in;

//字节流转换成字符流，InputStreamReader操控字节流的字符流

InputStreamReader isr=new InputStreamReader(in);

//缓冲字符输入流

BufferedReader bfr=new BufferedReader(isr);

String line=null;

//一行一行的读取，每次读取一行，提高了读取的效率bfr.readLine()是BufferedReader的方法，字符流

while((line=bfr.readLine())!=null) {

if("over".equals(line))

break;

System.out.println(line.toUpperCase());//将小写字符转换成大写字符

}

OutputStreamWriter字节流转换成字符流

BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bfw=new BufferedWriter(new OutputStreamWriter(System.out));

String line=null;

while((line=bfr.readLine())!=null) {//读取键盘录入数据，

if("over".equals(line))

break;

bfw.write(line.toUpperCase());//输出键盘录入的数据

bfw.newLine();//BufferedWriter的方法

bfw.flush();

字节输出流FileOutputStream()

FileOutputStream fos=new FileOutputStream("D:/exam/a/bbbb.txt");

String b="abcde";

fos.write(b.getBytes());     //字符串中的方法，getBytes()将字符串转换成字节数组

字符流：

写入数据：

(1)创建FileWriter对象，该对象一被初始化就必须明确别操作的文件。而且该文件会被创建到指定目录下，如果以有同名文件，将被覆盖。

该步是明确数据要存放的目的地。

FileWriter fw=new FileWriter("D://exam/a/writer.txt");

(2)如果传递参数true则代表不覆盖已有文件内容，继续续写文件内容。

FileWriter fw=new FileWriter("D://exam/a/writer.txt",true);

(3)调用write方法，将字符串写入到流中。

fw.write("一切都很好");

刷新流对象中的缓冲区的数据，将数据刷到目的地中。

fw.flush();

1. 关闭流资源。
2. 调用write方法写入时，换行使用\r\n;

写出数据：输出数据到控制台：

（1）FileReader fr=new FileReader("D://exam/a/writer.txt");

while(true) {

int c=fr.read();//对象调用方法，一个字符一个字符的读取

if(c==-1)

break;

else

System.out.println((char)c);//强制类型转换

（2）char[] cc=new char[1024];

int num=0;

//读取的字符数组转换成字符串new String(),对象调用方法，读取文件数据，存在数组中，并且返回读取的数组长度

while((num=fr1.read(cc))!=-1) {

System.out.println(new String(cc,0,num));

缓冲输入输出流

缓冲流实际上是将定义好的流作为缓冲流的构造参数

FileWriter fw=new FileWriter("D:/exam/a/bbb.txt",true);

BufferedWriter bfw=new BufferedWriter(fw);

bfw.newLine();实际上是写入了一个换行符

BufferedReader的直接子类：LineNumberReader

跟踪行号的缓冲字符输入流，能够获取getLineNumber()行号，以及设置行号setLineNumber()

FileReader fr=new FileReader("D:/exam/a/bbb.txt");

LineNumberReader lnbr=new LineNumberReader(fr);

String line=null;

lnbr.setLineNumber(10);//默认情况下是从零开始

while((line=lnbr.readLine())!=null) {//读取的信息传给line

System.out.println("第"+lnbr.getLineNumber()+"行"+line);

}

File 类的使用

1. File的对象调用exists方法判断文件是否存在（eg:  s.exists()）；

判断是否是文件还是目录使用isDirectory()和isFile()方法。【boolean】还要首先判断文件或目录是否存在。

【getPath()获取到的是封装的路径

getAbsolutePath()获取的是绝对路径

getParent()返回绝对目录下的父目录，如果获取到的是相对路径，则返回为null，如果相对目录有上一层目录则该目录是返回结果

renameTo()重新命名文件Boolean类型返回结果】

【long lastModified()最后一次被修改的时间

Long length()文件长度】

List方法：File对象调用list方法时，file对象必须有目录。File f=new File("C:/");

String[] names=f.list();

for(String name : names) {

System.out.println(name);

List()方法的作用是将盘下的文件名全部输出来。

ListRoots()方法：将电脑上的所有有用的盘都输出来。

File[] files=File.listRoots();

for(File f : files) {

System.out.println(f);

}

1. 创建文件以及目录：如果目录不存在使用file对象调用mkdir方法可以创建目录（eg:  s.mkdir()）；

（1）mkdir只能创建单层目录

（2）mkdirs可以创建多层目录

（3）返回值是boolean，创建带有扩展名的文件使用createNewFile()但只是一个标记，是零字节，是空的，不能使用，例如mp4，但是例如.txt可以使用。 使用file对象调用（eg:  s.createNewFile()）;

【在指定位置创建文件，如果该文件已将存在，则不创建，返回值为false，和输出流不一样，输出流对象---创建文件，如果文件已经存在则会被覆盖】

2、删除文件：  

File.delete()删除文件的最后一个目录或文件（eg:  s.delete(),  exam/a/b只能删除b）

【s.delete(),如果要输出，则输出的值可能是false/true】

选取流的基本规律：

1. 明确源和目标。

源：输入流。InputStream     Reader

目的：输出流。OutputStream    Writer

1. 操作数据是否是纯文本。

是：字符流。

不是：字节流。

1. 当体系明确后，在明确要使用哪个具体的对象
2. 将一个文本文件中数据存储到另一个文件中，复制文件。

源：使用读取流。InputStream     Reader

是不是操作文本文件-------是--------------选择Reader

对象：明确对象。

明确设备：Reader体系中操作文件的对象是FileReader

目的：OutputStream     Writer

是否为纯文本-----------是--------Writer-----------可以操作文件的对象FileWriter