韩顺平Java学习笔记(IO流基础一)

最新推荐文章于 2024-10-05 12:07:50 发布

富江！

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量899

点赞数 25

文章标签： java 学习笔记

本文链接：https://blog.csdn.net/qq_45014958/article/details/134720409

版权

文章详细介绍了Java中的文件操作，包括文件创建、使用FileOutputStream进行文件写入、文件信息获取、不同输出方式、文件拷贝以及FileReader和FileWriter的使用，还讨论了节点流和处理流的概念及其区别和应用实例。

摘要由CSDN通过智能技术生成

文件创建

import org.junit.Test;
import java.io.File;
import java.io.IOException;
public class FileCreate {
    public static void main(String[] args) {
    }
    @Test
    public void creat01(){
        String  filePath = "d:\\news1.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
//        方式2根据父目录文件加子路径创建
    @Test
    public void create02(){
        File parentfile = new File("d:\\");
        String fileName = "news2.txt";
//        这里的file对象，在java程序中只是一个对象
//        只有执行了createNewFile 方法，才会真正的在磁盘中创建该文件
        File file = new File(parentfile, fileName);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    @Test
    public void create03(){
        String parentPath = "d:\\";
        String  filePath = "news3.txt";
        File file = new File(parentPath, filePath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

目录创建

import org.junit.Test;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStream01 {
    public static void main(String[] args) {
    }
    @Test
    public void writerFile(){
//    创建FileOutputStream对象
//        new FileOutputStream（filePath）创建方式，当写入内容时，会覆盖原来的内容
//        new FileOutputStream（filePath，true）以追加的方式写入文件，不覆盖原来的文件内容
        String filePath = "d:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
//            得到文件对象
           fileOutputStream = new FileOutputStream(filePath);
//           按字节写入写入一个字节
            fileOutputStream.write('a');//char->int char自动转为int
//写入字符数组
            String str = "hello, world!";
//str.getBytes()该方法将字符串转换为字节数组
            fileOutputStream.write(str.getBytes());
//获取字符串中从某个位置到某个位置的字节
            fileOutputStream.write(str.getBytes(),0,str.length());
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

文件基础操作

import org.junit.Test;
import java.io.File;
public class FileInformation {
    public static void main(String[] args) {
    }
    @Test
    public void info(){
        File file = new File("d:\\news1.txt");
//        调用相应的方法，得到文件信息
        System.out.println("文件名字="+file.getName());
        System.out.println("文件的绝对路径="+file.getAbsolutePath());
        System.out.println("文件的父级目录="+file.getParent());
        System.out.println("文件的大小="+file.length());
        System.out.println("文件是否目录="+file.isDirectory());
        System.out.println("文件是否文件="+file.isFile());
        System.out.println("文件是否存在="+file.exists());
    }
}

文件的三种输出方式

import org.junit.Test;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStream01 {
    public static void main(String[] args) {
    }
    @Test
    public void writerFile(){
//    创建FileOutputStream对象
//        new FileOutputStream（filePath）创建方式，当写入内容时，会覆盖原来的内容
//        new FileOutputStream（filePath，true）以追加的方式写入文件，不覆盖原来的文件内容
        String filePath = "d:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
//            得到文件对象
           fileOutputStream = new FileOutputStream(filePath);
//           按字节写入写入一个字节
            fileOutputStream.write('a');//char->int char自动转为int
//写入字符数组
            String str = "hello, world!";
//str.getBytes()该方法将字符串转换为字节数组
            fileOutputStream.write(str.getBytes());
//获取字符串中从某个位置到某个位置的字节
            fileOutputStream.write(str.getBytes(),0,str.length());
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

文件拷贝（图片、文字）

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCpoy {
    public static void main(String[] args) {
//        将d盘图片文件拷贝到c盘
//        1、创建文件的输入流，将文件入读入到程序
//        2、创建文件输出流，将读取到的文件数据，写入到指定位置
//        将数据写入文件时，应该是先读取一部数据，写入到指定文件，在读取一部分数据写入到指定文件
        String srcfilePath = "D:\\BaiduNetdiskDownload\\dataset\\AID\\AID28_test\\Airport\\airport_2.jpg";
        String aimfilePath = "D:\\BaiduNetdiskDownload\\dataset";
        FileOutputStream fileOutputStream = null;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(srcfilePath);
            fileOutputStream = new FileOutputStream(aimfilePath);
//            定义一个字节数组，提高读取效率
            byte[] buf = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buf))!=-1){
//                读取后，写入文件，边读边写
                fileOutputStream.write(buf,0, readLen);
            }
            System.out.println("完成拷贝");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
//            关闭输入流和输出流，释放资源
            try {
                if (fileInputStream != null){
                    fileInputStream.close();
                }
                if (fileOutputStream != null){
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

FileReader 和 FileWriter介绍

fileReader 和FileWriter 是字符流，按照字符来操作

fileReader相关方法

new FileReader(File/String)；
read:每次读取单个字符，返回该字符，如果到文件末尾返回-1；
read：（char[]）:批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1；
new String（char[]）: 将char[]转换成String；
new String（char[],off, len) ：将char[]的指定部分转化为String
示例如下：

import org.junit.Test;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReader_ {
    public static void main(String[] args) {
        String filePath = "d:\\a.txt";
        FileReader fileReader = null;
        int data = 0;
        try {
            fileReader = new FileReader(filePath);
//            循环读取 使用read， 单个字符读取
            while ((data = fileReader.read()) !=-1 ){
                System.out.println((char)data);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (fileReader != null){
                    fileReader.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    //   方案二 使用字符数组读取文件
    @Test
    public void readFile01(){
        String filePath = "d:\\a.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] buf = new char[8];
        try {
            fileReader = new FileReader(filePath);
//            循环读取 使用read(buf)， 返回实际读取到的字符数
//            返回-1时，说明文件结束
            while ((readLen = fileReader.read(buf)) !=-1 ){
                System.out.println(new String(buf, 0 , readLen));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (fileReader != null){
                    fileReader.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
      }
   }
}

fileWriter相关方法

new FileWriter(File/String)：覆盖模式，相当于流的额指针在首段；
new FileWriter(File/String，true)：追加模式，相当于流的指针在为尾端；
writer(int):写入单个字符
writer(char[]):写入指定数组
writer(char[]，off， len):写入数组的指定部分
writer(String):写入字符串
writer(String，off， len):写入字符串的指定部分
String类相关的API:
toCharArray:将String转换成char[]
注意：FileWriter后，必须要关闭或者刷新即：close或flush，否则写入不到指定文件。
示例如下：

import java.io.FileWriter;
import java.io.IOException;
public class FileWriter_ {
    public static void main(String[] args) {
        String filePath = "d:\\note.txt";
//        创建FileWriter
        FileWriter fileWriter =null;
        char [] chars = {'1','2','3','4'};
        try {
            fileWriter = new FileWriter(filePath);
//            1. new FileWriter(File/String)：覆盖模式，相当于流的额指针在首段；
//            2. new FileWriter(File/String，true)：追加模式，相当于流的指针在为尾端；
//            3. writer(int):写入单个字符
            fileWriter.write('L');
//            4. writer(char[]):写入指定数组
            fileWriter.write(chars);
//            5. writer(char[]，off， len):写入数组的指定部分
            fileWriter.write(chars,0,2);
//            6. writer(String):写入字符串
            fileWriter.write("never give up!");
//            7. writer(String，off， len):写入字符串的指定部分
            fileWriter.write("never give up!",0,9);
            fileWriter.write("风雨之后定见彩虹");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
//            关闭流或者刷新流
            try {
                fileWriter.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

节点流和处理流

在这里插入图片描述

节点流：可以从一个特定的数据源读写数据，如FileReader、FileWriter
在这里插入图片描述

处理流：也叫包装流是"连接"在已存在的流（节点流和处理流）之上，为程序提供更强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter等
在这里插入图片描述

节点流和处理流的区别和联系：

节点流是底层流/低级流，直接跟数据源相接；
处理流包装流节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入和输出；
处理流对节点流进行包装，并使用了修饰器设计模式，不会直接与数据源相连接。

处理流的功能主要体现在以下两个方面：

性能的提高：主要以增加缓冲的方式来提高输出输入的效率；
操作的便捷：处理流可能提供了一系列便捷的方式来一次输入输出大批量的数据，使用更加灵活方便；
示例如下：

public abstract class Reader_ {//抽象类可以不用去实现
    public  void readFile(){};
    public  void readString(){};
}

public class BufferedReader_ extends Reader_{//将其处理为包装流
    private  Reader_ reader_;//属性是 Reader_类型
//接收Reader_子类对象
    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }
    public void readFile(){
//        封装一层
        reader_.readFile();
    }
//    多次读取文件
    public void readFiles(int num){
        for (int i = 0; i < num; i++) {
            reader_.readFile();
        }
    }
//   扩展readString，批量处理字符串数据
    public void readString(int num){
        for (int i = 0; i < num; i++) {
            reader_.readString();
        }
    }

}

public class FileReader_ extends Reader_{
    public void readFile(){
        System.out.println("对文件进行操作");
    }
}

import com.hspedu.Reader_;
public class StringReader_ extends Reader_ {
    public void readString(){
        System.out.println("对字符串进行操作");
    }
}

public class Test_ {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader = new BufferedReader_(new FileReader_());
        bufferedReader.readFiles(100);
        BufferedReader_ bufferedReader1 = new BufferedReader_(new StringReader_());
        bufferedReader1.readString(10000);
    }
}