javaEE-文件内容的读写

目录

一.数据流

1.字节流

InputStream的方法：

cloes()

read()

OutPutStream

writer()方法

2.字符流

Reader:

writer:

代码练习1:

代码练习2:

代码练习3:

一.数据流

java标准库对数据进行了封装,提供了一组类负责进行这些工作.

数据流分为两类:字节流和字符流.

1.字节流

以字节为单位，进行数据的读入（硬盘->cpu) 和写出(cpu->硬盘）。一次最少读取一个字节。

代表类：

InputStream:输入

OutputStream:输出

InputStream是一个抽象类，实现该类可由其 子类实现：

InputStream的方法：

cloes()

调用colse() 目的是为了释放文件描述符：

PCS中包含很多属性，其中就有文件描述符表，就是一个顺序表（数组）。一个进程每打开一个文件，就会在顺序表中分配一个元素，顺序表的长度是有上限的，若每次只打开文件，而不关闭文件，那么这个顺序表将会有被分配完的时候，此时，就会引发文件资源泄露。调用cloes()就会释放被分配的文件描述符！

这种写法，在要操作地代块码中，很有可能提前 return或异常终止了，而无法执行到cloes(),造成文件描述符无法被释放。

因此，应将cloes()放到finall代码块中：

这样一定能执行cloes(）。

但这样看代码不太美观，try(){ }还有另一种写法：

try( ):括号中代码：1.定义变量，2.在代码块结束的时候 自动调用close()。

将定义的变量放到( )括号中，前提是该变量要 实现Closeable接口。

read()

提供了三个版本：

  public static void main1(String[] args) {
        try(InputStream inputStream=new FileInputStream("./test.exe")){
            while(true){
                int n=inputStream.read();
                if(n==-1){
                    break;
                }
                //以标准字节输出流的形式打印输出
                System.out.printf("%c",n);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main2(String[] args) {
        //打开文件
        try(InputStream inputStream=new FileInputStream("./test.exe")){
            while(true){//循环读取文件
                byte[] buffer=new byte[1024];//1024：自定义的一次最多读取文件的字节数
                int n=inputStream.read(buffer);//读文件到buffer字节数组中
                if(n==-1){
                    break;
                }
                //打印输出
                for(int i=0;i<n;i++){
                    System.out.printf("%c",buffer[i]);
                }
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) {
        //打开文件
        try(InputStream inputStream=new FileInputStream("./test.exe")){
            while(true){//循环读取文件
                byte[] buffer=new byte[4];//1024：自定义的一次最多读取文件的字节数
                int n=inputStream.read(buffer,0,4);//读文件到buffer字节数组中
                                        // 从0位置开始读取，每次读1024个字节
                if(n==-1){
                    break;
                }
                //将读到的n个字节转换成字符串
                String s=new String(buffer,0,n);
                System.out.println(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
//以Scanner方式读取：
 public static void main(String[] args) {
        try(InputStream inputStream=new FileInputStream("./test.exe")){
            Scanner scan=new Scanner(inputStream);//从文件读取内容
           while(scan.hasNext()){
               String s=scan.next();
               System.out.println(s);
           }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

OutPutStream

OutPutStream也是一个抽象类，通过子类创建对象：

每次调用OutPutSream就会将调用的文件清空，

要想在每次调用时，文件不被清空，可以在构造方法中再传入一个参数“true",就不会清空文件了：

writer()方法

writer有三个版本：

参考代码：

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main1(String[] args) {
        try(OutputStream outputStream=new FileOutputStream("./test.exe",true) ){
            byte[] buffer=new byte[]{97,98,99,100,101,102};
            outputStream.write(buffer);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) {
        try(OutputStream outputStream=new FileOutputStream("./test.exe") ){
            byte[] buffer=new byte[]{97,98,99,100,101,102};
            outputStream.write(buffer,0,2);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

2.字符流

以字符为单位读写。比如，以utf8表示汉字，每3个字节表示一个汉字，则每次至少以3个字节为单位（1个字符）读取，不能一次读取半个汉字。

代表类：

Reader：输入

Writer:输出

字符流输入输出和上面的字节流用法类似。

Reader:

 public static void main1(String[] args) {
//法一：
        try(Reader reader=new FileReader("./test.exe")){
            while(true){
                int n=reader.read();//每次读单个字符
                if(n==-1){
                    break;
                }
                System.out.printf("%c",n);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
//法二：
    public static void main(String[] args) {
        try(Reader reader=new FileReader("./test.exe")){
            while(true){
                char[] buffer=new char[1024];
                int n=reader.read(buffer);//每次读取一个字符数组
                if(n==-1){
                    break;
                }
                String s=new String(buffer,0,n);
                System.out.println(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

writer:

public static void main(String[] args) {
        try(Writer writer=new FileWriter("./test.exe")){
           String s="好好学习，天天向上";
           writer.write(s);//将字符串写入文件
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

代码练习1:

扫描指定⽬录，并找到名称中包含指定字符的所有普通⽂件（不包含⽬录），并且后续询问⽤⼾是否 要删除该⽂件

public class Io1 {
    public static void main(String[] args) {
        System.out.println("请输入要要查找的根目录：");
        Scanner scan=new Scanner(System.in);
        String root=scan.next();
        File file = new File(root);
        if(!file.isDirectory()){
            System.out.println("输入的根目录有错误！！");
            return;
        }
        System.out.println("请输入要查找的文件：");
        String s=scan.next();
//        File file1 = new File(s);
//
//        if(!file1.isFile()){
//            System.out.println("输入的文件有错误！");
//            return;
//        }
        //根目录和文件都没有问题
        //从根目录 递归查找 指定文件是否存在
        Search(file,s);
    }
    private static void Search(File root, String s) {
        File[] files = root.listFiles();
        if(files==null){
            return;
        }
        for(File f:files){
            System.out.println("当前遍历到: "+f.getAbsolutePath());
            if(f.getName().equals(s)){
                System.out.println("找到文件，路径为："+f.getAbsolutePath());
            }else if(f.isDirectory()){
                //是目录文件，就继续 递归 向下找
                Search(f,s);
            }else{
                ;
            }
        }
    }

}

代码练习2:

进⾏普通⽂件的复制： 先读取源文件,再写入到复制文件中,边读边写

/**
 * 进⾏普通⽂件的复制
 * 先读取源文件,再写入到复制文件中,边读边写
 */
public class Io2 {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入源文件路径:");
        String srcfile=scan.next();
        File file = new File(srcfile);
        if(!file.isFile()){
            System.out.println("源文件路径有误!!");
            return;
        }
        System.out.println("请输入目标文件路径:");
        String descfile=scan.next();
        File file1 = new File(descfile);
        //不要求目标文件存在,但路径 要是 目录
        if(!file1.getParentFile().isDirectory()){
            System.out.println("目标文件路径有误!!");
            return;
        }
        try(InputStream inputStream = new FileInputStream(file);
            FileOutputStream outputStream = new FileOutputStream(file1)){
            while(true){
                byte[] buffer=new byte[1024];
                int n = inputStream.read(buffer);//从源文件读取 到buffer数组中
                if(n==-1){
                    break;
                }
                outputStream.write(buffer,0,n);//将buffer数组中的内容写入到 目标文件中
            }
            System.out.println("文件复制完毕!!!!");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

代码练习3:

/**
 * 扫描指定⽬录，并找到名称或者内容中包含指定字符的所有普通⽂件（不包含⽬录）
 */
public class Io09 {
    public static void main(String[] args) {
        System.out.println("请输入要查找的目录:");
        Scanner scan=new Scanner(System.in);
        String src=scan.next();
        File file = new File(src);
        if(!file.isDirectory()){
            System.out.println("输入目录有误!!");
            return;
        }
        System.out.println("请输入要查找文件:");
        String s1=scan.next();
        scanFile(file,s1);
    }
//进行目录扫描,查找是否为 文件
    private static void scanFile(File srcfile,String s){
        File[] files = srcfile.listFiles();
        if(files==null){
            return;
        }
        for(File f:files){
            if(f.isFile()){
                //是文件,进行搜索,是否有要找到内容
                    SearchWord(f,s);
            }else if(f.isDirectory()){
                //是目录 继续递归寻找文件
                scanFile(f,s);
            }else{
            ;
        }
    }
    //进行文件查找
    private static void SearchWord(File f, String s) {
        try(InputStream inputStream=new FileInputStream(f)){
            StringBuilder stringBuilder=new StringBuilder();
            while(true){
                byte[] buffer=new byte[1024];
                int n = inputStream.read(buffer);
                if(n==-1){
                    break;
                }
                String str=new String(buffer,0,n);
                stringBuilder.append(str);
            }
            if(stringBuilder.indexOf(s)!=-1){
                System.out.println("找到了,文件路径为: "+f.getAbsolutePath());
            }else{
                System.out.println(f.getAbsolutePath());
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}