File类和IO流_file类和io流编程题-CSDN博客

本文链接：https://blog.csdn.net/gsr13453879577/article/details/115607438

File类和IO流

一、File

1.1 File类概述和构造方法

File：他是文件和目录径名的抽象表示

文件和目录是可以通过File封装成对象的
对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路劲名而已。他是可以存在的，也可以是不存在的，将来是要通过具体的操作把这个路劲的内容住哪换为具体存在的

方法名	说明
File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
File(String parent String child)	从父路径名字符串和子路径名字符串创建新的File实例
File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的File实例

package com.File;

import java.io.File;

public class itheima {
    public static void main(String[] args) {
        File f1 = new File("G:\\gsr\\java.txt");
        System.out.println(f1);

        File f2 = new File("G:\\gsr", "java.txt");
        System.out.println(f2);

        File f3 = new File("G:\\gsr");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}

1.2 File类创建功能

方法名	说明
public boolean createNewFile（）	当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
public boolean mkdir(）	创建由此抽象路径名命名的目录
public boolean mkdirs（）	创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

package com.File;

import java.io.File;
import java.io.IOException;

public class FileDemo {
    public static void main(String[] args) throws IOException {
        File f1 = new File("G:\\gsr\\java.txt"); //创建文件
        System.out.println(f1.createNewFile());

        File f2 = new File("G:\\gsr\\javaSE");//创建目录
        System.out.println(f2.mkdir());

        File f3 = new File("G:\\gsr\\javaWeb\\HTML");//在目录下创建一个多级目录
        System.out.println(f3.mkdirs());

        File f4 = new File("G:\\gsr\\javase.txt");
        System.out.println(f4.createNewFile());
    }
}

1.3 File类删除功能

方法名	说明
public boolean delete()	删除由此抽象路劲名表示的文件或目录

绝对路径和相对路径的区别

绝对路径:完整的路径名，不需要任何其他信息就可以定位它所表示的文件.例如：E：\\itcast\\java.txt
相对路径:必须使用取自其他路径名的信息进行解释.例如：myFile\\java.txt

删除日录时的注意事项:

如果一个目录中有内容(目录, 文件),不能直接删除。应该先删除目录中的内容,最后才能删除目录

package com.File;

import java.io.File;
import java.io.IOException;

public class FileDeleteDemo {
    public static void main(String[] args) throws IOException {
        File f1 = new File("java.txt");
//        System.out.println(f1.createNewFile());
        System.out.println(f1.delete());  //删除当前文件

        System.out.println("********************");
        File f2 = new File("javase");
//        System.out.println(f2.mkdir());
        System.out.println(f2.delete());

        System.out.println("********************");
        File f3 = new File("JAVA");
//        System.out.println(f3.mkdir());
        File f4 = new File(f3, "java.txt");
//        System.out.println(f4.createNewFile());
        System.out.println(f3.delete()); //目录有文件，不能直接删除

    }
}

1.4 File类判断和获取功能

方法名	说明
public boolean isDirectory（）	测试此抽象路径名表示的File是否为目录
public boolean isFile（）	测试此抽象路径名表示的File是否为文件
public boolean exists（）	测试此抽象路径名表示的File是否存在
public String getAbsolutePath（）	返回此抽象路径名的绝对路径名字符串
public String getPath（）	将此抽象路径名转换为路径名字符串
public String getName（）	返回由此抽象路径名表示的文件或目录的名称
public String[] list（）	返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[ listFiles（）	返回此抽象路径名表示的目录中的文件和目录的File对象数组

package com.File;

import java.io.File;
import java.io.IOException;
/*
File类的判断和获取功能
 */
public class FileDemo01 {
    public static void main(String[] args) throws IOException {
        //创建一个File文件
        File f = new File("java.txt");
//        public boolean isDirectory（）测试此抽象路径名表示的File是否为目录
//        public boolean isFile（）测试此抽象路径名表示的File是否为文件
//        public boolean exists（）测试此抽象路径名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());
//        public String getAbsolutePath（）返回此抽象路径名的绝对路径名字符串
//        public String getPath（）将此抽象路径名转换为路径名字符串
//        public String getName（）返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
//        public String[] list（）返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
//        public File[ listFiles（）返回此抽象路径名表示的目录中的文件和目录的File对象数组
        System.out.println("-------------");
        File f1 = new File("G:\\gsr");
        String[] strings = f1.list();
        for (String str : strings){
            System.out.println(str);
        }
        System.out.println("-------------");
        File[] files = f1.listFiles();
        for (File file : files){
            if (file.isFile()){
                System.out.println(file.getName());
            }
        }
    }
}

二、递归

1.5 递归

递归概念：以编程的角度来看，递归指的是方法定义中调用本身的现象

递归解决问题的思路:

把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解

递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

递归解决问题要找到两个内容：

递归出口：否则会出现内存溢出
递归规则：与原问题相似的规模较小

public static int f(int n) {
    if (n == 1 || n == 2) {
        return 1;
    } else {
        return f(n - 1) + f(n - 2);
    }
}

案例：递归求阶乘

需求:用递归求5的阶乘，并把结果在控制台输出

思路:

①定义一个方法，用于递归求阶乘，参数为-个int类型的变量

②在方法内部判断该变量的值是否是1

是:返回1

不是:返回n*（n-1）！

③调用方法

④输出结果

package com.递归;

public class Demo {
    public static void main(String[] args) {
        //调用方法
        int result = jc(5);
        //输出结果
        System.out.println("5的阶乘是："+result);

    }
    public static int jc(int n) {
        if (n == 1 ) {
            return 1;
        } else {
            return n*jc(n-1);
        }
    }
}

案例:遍历目录

需求:给定一个路径(:\itcast),请通过递归完成遍历该目录下的所有内容，并把所有文件的绝对路径输出在控制台

思路:

①根据给定的路径创建一个File对象

②定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象

③获取给定的File目录下所有的文件或者目录的File数组

④遍历该File数组，得到每一个File对象

⑤判断该File对象是否是目录

是:递归调用

不是:获取绝对路径输出在控制台

package com.递归;

import java.io.File;

public class Demo01 {
    public static void main(String[] args) {
        File srcfile = new File("G:\\gsr");

        getAllFilePath(srcfile);
    }

    public static void getAllFilePath(File srcFile){
        File[] filesArray = srcFile.listFiles();
        if (filesArray != null) {
            for (File file : filesArray){
                if (file.isDirectory()){
                    getAllFilePath(file);
                }else{
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

三、字节流

2.1 IO流概述和分类

I0流概述:

●IO: 输入/输出(Input/Output)

●流: 是一种抽象概念,是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输

●IO流就是用来处理设备间数据传输问题的

常见的应用:文件复制；文件上传；文件下载

IO流分类:

●按照数据的流向

输入流:读数据

输出流:写数据

●按照数据类型来分

字节流
字节输入流；字节输出流

字符流
字符输入流；字符输出流

一般来说，我们说IO流的分类是按照数据类型来分的

那么这两种流都在什么情况下使用呢?

如果数据通过Window自带的记事本软件打开, 我们还可以读懂里面的内容，就使用字符流,

否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

2.2字节流写数据

字节流抽象基类

InputStream：这个抽象类是表示字节输入流的所有类的超类
OutputStream: 这个抽象类是示字节输出流的所有类的超类
子类名特点:子类名称都是以其父类名作为子类名的后缀

FileOutputStream：文件输出流用于将数据写入File

FileOutputStream(Stringname)：创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤：

●创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象，让字节输出流对象指向文件)

●调用字节输出流对象的写数据方法

●释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

package com.字节流;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDeemo {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(Stringname)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("fos.txt");
        /*
        做了三件事：
            A：调用系统功能创建了文件
            B：创建了字节输出流对象
            C：让字节输出流对象指向创建好的文件
         */
        fos.write(97);

        //最后都要释放资源
        //void close(); 关闭此文件输出流并释放与此流相关联的任何系统资源
        fos.close();
    }
}

2.3字节流写数据的3种方式

方法名	说明
void write(int b)	将指定的字节写入此文件输出流，一次写一个字节数据
void write(byte[]b)	将b.Length字节从指定的字节数组写入此文件输出流一次写一个字节数组数据
void write(byte[]b, int off, int len)	将len字节从指定的字节数组开始，从偏移量of开始写入此文件输出流，一次写一个字节数组的部分数据

package com.字节流;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("java.txt");
        //new File(name)
//        FileOutputStream fos = new FileOutputStream(new File("java.txt"));

        File file = new File("java.txt");
        FileOutputStream fos1 = new FileOutputStream(file);
//        FileOutputStream fos2 = new FileOutputStream(new File("java.txt"));

//        fos.write(97);
//        fos.write(98);
//        fos.write(99);
//        fos.write(100);
//        fos.write(101);
        byte[] by = {97,98,99,100,101};
        fos.write(by);
        //byte[] getBytes(); 返回字符串对应的字节数组
        byte[] bys = "abcde".getBytes();
        fos.write(bys);

        fos.write(bys,0,bys.length);
        fos.write(bys,1,3);

        //释放资源
        fos.close();
    }
}

2.4 字节流写数据的两个小问题

字节流写数据如何实现换行？

写完数据后，加换行符

windows: \r\n

linux: \n

mac: \r

字节流写数据如何实现追加写入？

public FileOutputStream(String name,boolean append);
创建文件输出流已指定的名称写入文件。如果第二个参数为true，则写入的文件的末尾而不是开头

package com.字节流;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
//        FileOutputStream fos = new FileOutputStream("java.txt");
        FileOutputStream fos = new FileOutputStream("java.txt",true);
        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

2.5字节流写数据加异常处理

**finally:**在异常处理时提供finally块来执行所有清除操作。比如说I0流中的释放资源

特点:被finally控制的语句- 定会执行，除非JVM退出

try{

可能出现异常的代码:

}eatch(异常类名变量名){

异常的处理代码:

}finally{

执行所有清除操作:

}

package com.字节流;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo03 {
    public static void main(String[] args) {
//        try{
//        FileOutputStream fos = new FileOutputStream("java.txt");
//        fos.write("hello".getBytes());
//        fos.close();
//        }catch(IOException e){
//            e.printStackTrace();
//        }
        //加入finally来实现释放资源
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("java.txt");
            fos.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.6字节流读数据(一次读一个字节数据)

需求:把文件fos.txt中的内容读取出来在控制台输出

FileInputStream：从文件系统中的文件获取输入字节

FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream,该文件由

文件系统中的路径名name命名

使用字节输入流读数据的步骤:

①创建字节输入流对象

②调用字节输入流对象的读数据方法

③释放资源

package com.字节流.字节流写数据.字节流读数据;

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileInputStream fis = new FileInputStream("java.txt");
        //调用字节输出流对象读数据方法
        //int read();从该输出流读取一个字节的数据

//        //第一次读取数据
//        int by = fis.read();
//        System.out.println(by);
//        System.out.println((char)by);
//
//        //第二次读取数据
//        int by1 = fis.read();
//        System.out.println(by1);
//        System.out.println((char)by1);
//
//        //在多读取两次
//        int by2 = fis.read();
//        System.out.println(by2);
//        System.out.println((char)by2);
//
//        by = fis.read();
//        System.out.println(by);
//        System.out.println((char)by);
//
//        by = fis.read();
//        System.out.println(by);
//        System.out.println((char)by);
//
//        //如果数据达到末尾，输出-1
//        by = fis.read();
//        System.out.println(by);
//        System.out.println((char)by);

//        //使用循环读取数据
//        int by = fis.read();
//        while(by != -1){
//            System.out.print((char)by);
//            by = fis.read();
//        }

        //优化上面的代码
        int by;
        /*
            fis.read():读数据
            by=fis. read():把读取到的数据赋值给by
            by != -1:判断读取到的数据是否是-1
         */
        while((by=fis.read())!=-1){
            System.out.print((char) by);
        }


        //释放资源
        fis.close();
    }
}

2.7 字节流复制文本文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BxwvrPGA-1618148716185)(C:\Users\你可知世间再难遇我\AppData\Roaming\Typora\typora-user-images\image-20210407103402403.png)]

2.8 复制图片

/*
需求:
把E:itcast\ \mn. jpg复制到模块目录下的mn. jpg
思路:
1：根据数据源创建字节输入流对象
2：根据目的地创建字节输出流对象
3：读写数据，复制图片(-次读取一个字节数组，-次写入一个字节数组)
4：释放资源
*/
public class CopyJpgDemo {
	public static void main(String[] args) throws IOException {
		//根据数据源创建字节输入流对象
		FileInputStream fis = new FileInputStream( name: "E:\\itcast\\mn.jpg");
		//根据目的地创建字节输出流对象
		FileOutputStream fos = new FileOutputStream( name: "myByteStream\\mn .jpg");
		//读写数据，复制图片(- -次读取一个字节数组，一次写入一 -个字节数组)
		byte[] bys = new byte[1024];
		int len;
		while ((len=fis.read(bys))!=-1) {
			fos.write(bys, off: 0,len);
			//释放资源
		fos.close();,
		fis.close();
		}
    }
}

2.7 字节缓冲流

字节缓冲流:

BufferOutputStream: 该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字

节，而不必为写入的每个字节导致底层系统的调用
BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法:

字节缓冲输出流：BufferedOutputStream(OutputStreamout)
字节缓冲输入流：BufferedInputStream(InputStreamin)

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

package com.字节流.字节流写数据.字节缓冲流;

import com.sun.org.apache.xpath.internal.operations.String;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
//        FileOutputStream fos = new FileOutputStream("java.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        /*
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("java.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();
        */
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java.txt"));
//        int by;
//        while((by = bis.read())!=-1){
//            System.out.print((char)by);
//        }
        byte[] bys= new byte[1024];
        int len;
        while((len=bis.read(bys))!=-1){
            System.out.print(new String(bys,0,len));
        }
    }
}

复制图片

需求:把“E:\itcast)字节流复制图片.avi” 复制到模块目录下的”字节流复制图片.avi"

思路:

①根据数据源创建字节输入流对象

②根据目的地创建字节输出流对象

③读写数据，复制视频

④释放资源

package com.字节流.字节流写数据.复制图片;

import java.io.*;

public class CopyAviDemo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
//        method1();   //1000多毫秒
//        method2();   //997毫秒
        mothod3();      //17毫秒
//        mothod4();  //共耗时：42毫秒
        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时："+ (endTime - startTime) +"毫秒");
    }
    //基本字节流一次读写一个字节
    public static void method1() throws IOException {
        //H:\\itheima\\字节流复制图片.avi
        //模块目录下得到字节流复制图片.avi
        FileInputStream fis = new FileInputStream("H:\\itheima\\字节流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("G:\\gsr\\字节流复制图片.avi");
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        fis.close();
        fos.close();

    }

    //基本字节流一次读写一个字节数组
    public static void method2() throws IOException{
        //H:\\itheima\\字节流复制图片.avi
        //模块目录下得到字节流复制图片.avi
        FileInputStream fis = new FileInputStream("H:\\itheima\\字节流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("G:\\gsr\\字节流复制图片.avi");

        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read())!=-1){
            fos.write(bys,0,len);
        }
        fos.close();
        fis.close();
    }
    //字节缓冲流一次读写一个字节
    public static void mothod3() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("H:\\itheima\\字节流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("G:\\gsr\\字节流复制图片.avi"));

        int by;
        while((by=bis.read())!=-1){
            bos.write(by);
        }
        bis.close();
        bos.close();

    }
    //字节缓冲流一次读写一个字节数组
    public static void mothod4() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("H:\\itheima\\字节流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("G:\\gsr\\字节流复制图片.avi"));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read())!=-1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();

    }
}

四、字符流

3.1 为什么会出现字符流？

由于字节流操作中文不是特别的方便，所以ava就提供字符流

字符流=字节流+编码表.

用字节流复制文本文件时，文本文件也会有中文,但是没有问题，原因是最终底层操作会自动进行字节拼接成

中文,如何识别是中文的呢?

汉字在存储的时候，无论选择哪种编码存储,第一个字节都负数

package com.字符流;

import java.io.IOException;
import java.util.Arrays;

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
//        FileInputStream fis = new FileInputStream("java.txt");
//
//        int by;
//        while((by=fis.read())!=-1){
//            System.out.println((char)by);
//        }
//        fis.close();

//        String s = "abc";  //[97, 98, 99]
        String s ="中国";     //[-28, -72, -83, -27, -101, -67]
//        byte[] bys = s.getBytes();
//        byte[] bys = s.getBytes("UTF-8");
        byte[] bys = s.getBytes("GBK");   //[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));
    }
}

3.2 编码表

基础知识:

计算机中储存的信息都是用二进制数表示的;我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果
按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。这里强调一下:按照A编码存储，必须按照A编码解析，这样才能显示正确的文本符号。否则就会导致乱码现象

字符编码:就是一套自然语言的字符与二进制数之间的对应规则(A65)

3.5 字符流写数据的五种方式

方法名	说明
void write(int c)	写一个字符
void write(char[] cbuf)	写入一个字符数组
void write(char] cbuf, int off, int len)	写入字符数组的一部分
void write(String str)	写一个字符串
void write(String str, int off, int len)	写一个字符串的一部分

package com.字符流.写数据;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java.txt"));

//        osw.write(97);
//        //void flush(); 刷新流
//        osw.flush();
//        osw.write(98);
//        osw.flush();
//        osw.write(99);
        osw.flush();
//        osw.close();  //先刷新缓冲，后释放资源，释放资源后不能再写入数据
        char[] chs = {'a','b','c','d','e'};
//        osw.write(chs);

//        osw.write(chs,0,chs.length);
//        osw.write(chs,1,3);
//        osw.write("abcde");
//        osw.write("abcde",0,"abcde".length());
        osw.write("abcde",1,3);
        osw.close();
    }
}

3.6 字符流读数据的2种方式

方法名	说明
int read()	一次读一个字符数据
int read(char[] cbuf)	一次读一个字符数组数据

package com.字符流.读数据;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReadDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("java.txt"));
//        int ch;
//        while ((ch=isr.read())!=-1){
//            System.out.print((char)ch);
//        }
        char[] chs = new char[1024];
        int len;
        while ((len=isr.read(chs))!=-1){
            System.out.println(new String(chs,0,len));
        }
        //释放资源
        isr.close();
    }
}

复制Java文件

需求:把模块目录下的"ConversionStreamDemo.java” 复制到模块目录下的"Copyjava"

思路:

①根据数据源创建字符输入流对象

②根据目的地创建字符输出流对象

③读写数据，复制文件

④释放资源

package com.字符流.复制Java文件;

import java.io.*;

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException{
        InputStreamReader isr = new InputStreamReader(new FileInputStream("H:\\itheima\\hello.java"));
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("G:\\gsr\\hello.java"));

        //读写数据，复制文件
//        int ch ;
//        while ((ch=isr.read())!=-1){
//            osw.write(ch);
//        }
        char[] chs = new char[1024];
        int len;
        while ((len=isr.read())!=-1){
            osw.write(chs,0,len);
        }
        isr.close();
        osw.close();

    }
}

复制Java文件改进版

需求:把模块目录下的"ConversionStreamDemo.java” 复制到模块目录下的"Copyjava"

思路:

①根据数据源创建字符输入流对象

②根据目的地创建字符输出流对象

③读写数据，复制文件

④释放资源

package com.字符流.复制Java文件;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        FileReader fr = new FileReader("H:\\itheima\\hello.java");
        FileWriter fw = new FileWriter("G:\\gsr\\hello.java");

        //读写数据，复制文件
//        int ch;
//        while ((ch=fr.read())!=-1){
//            fw.write(ch);
//        }

        char[] chs = new char[1024];
        int len;
        while ((len=fr.read())!=-1){
            System.out.println(new String(chs,0,len));
        }

        fw.close();
        fr.close();
    }
}

3.7 字符缓冲流

字符缓冲流：

BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大,可用于大多数用途
BufferedReader:从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取,可以指定缓冲区大小，或者可以使用默认大小。默认值足够大,可用于大多数用途

构造方法：

BufferedWriter(Writer out)
BufferedReader(Reader in)

package com.字符流.字符缓冲流;

import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
//        BufferedWriter bw = new BufferedWriter(new FileWriter("java.txt"));
//        bw.write("hello\r\n");
//        bw.write("world\r\n");
//        bw.close();
        BufferedReader br = new BufferedReader(new FileReader("java.txt"));
        //一次读取一个字符数据
//        int ch;
//        while ((ch=br.read())!=-1){
//            System.out.print((char)ch);
//        }
        //一次读取一个字符数组
        char[] chs = new char[1024];
        int len;
        while ((len=br.read())!=-1){
            System.out.print(new String(chs,0,len));
        }
        br.close();

    }
}

复制Java文件（字符缓冲流）

package com.字符流.复制Java文件;

import java.io.*;

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("H:\\itheima\\hello.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("G:\\gsr\\hello.java"));

        //一次读写一个数据文件
//        int ch;
//        while ((ch=br.read())!=-1){
//            bw.write(ch);
//        }

        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=br.read())!=-1){
            bw.write(chs,0,len);
        }



        br.close();
        bw.close();
    }
}

3.8 字符缓冲流的特有功能

BufferedWriter：

void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader：

public String readLine()：读一行文字，结果包含行的内容的字符串，不包含任何行终止符，如果流的结尾已经到达，则为null

package com.字符流.字符缓冲流特有的功能;

import java.io.*;

public class BufferedStreamDemo  {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲流输出
        BufferedWriter bw = new BufferedWriter(new FileWriter("java.txt"));

        //写数据
//        for (int i = 0; i < 10; i++) {
//            bw.write("hello" + i);
//            bw.write("\r\n");
//            bw.newLine();  //换行
//            bw.flush();  //刷数据
//        }
//        bw.close();

        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("java.txt"));
/*
        //第一次读数据
        String line = br.readLine();
        System.out.println(line);
        //第二次读数据
        line = br.readLine();
        System.out.println(line);
        line = br.readLine();
        System.out.println(line);
        line = br.readLine();
        System.out.println(line);
*/
        String line;
        while ((line=br.readLine())!=null ){
            System.out.println(line);
        }
        br.close();
    }
}

复制Java文件（字节缓冲流特有功能改进版）

package com.字符流.字符缓冲流特有的功能;

import java.io.*;

public class CopyStreamDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("H:\\itheima\\hello.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("G:\\gsr\\hello.java"));

        String line;
        while ((line = br.readLine())!=null){
            bw.write(line);
            bw.newLine();//行分割
            bw.flush(); //刷数据
        }
        br.close();
        bw.close();
    }
}