【韩老师零基础30天学会Java 17】IO流体系,文件和目录操作,FileInputStream和FileOutputStream,文件拷贝,FileReader 和 FileWriter

初识IO

体系

IO流原理及流的分类

节点流和处理流

输入流

  • InputStream 输入流

    • FilelnputStream 文件
    • BufferetInputStream 缓冲 节点和处理流
    • ObjectlnputStream 对象 输入流
  • Reader 字符 读

    • FileReader 文件
    • BufferedReader 缓冲 读。节点和处理流
    • InputStreamReader 输入流 读。转换流

输出流

  • OutputStream 字节

    • FileOutputStream 文件
    • BufferedOutputStream 缓冲。节点和处理流
    • ObjectOutputStream 对象
  • Writer 字符

    • FileWriterBuffer 文件
    • BufferedWriter 缓冲
    • OutputStreamWriter 输出流。转换流

Properties类

详细体系分类

字节流

  • lnputStream
    • FilelnputStream 文件输入流
    • PipedInputStream
    • **ObjectlnputStream ** 对象字节输入流
    • ByteArraylnputStream
    • SequencelnputStream
    • FilterlnputStream 过滤输入
      • BufferedlnputStream 缓冲字节输入流
      • DigestinputStream
      • DatalnputStream
  • OutputStream
    • FileOutputStream
    • PipedOutputStream
    • ObjectOutputStream
    • ByteArrayOutputStream
    • FilterOutputStream
      • BufferedOutputStream
      • DigestOutputStream
      • DataOutputStream
      • PrintStream

字符流

  • Reader 字符输入流
    • lnputStreamReader
      • FileReader
    • BufferedReader
    • CharArrayReader
    • FilterReader
    • PipedReader
    • StringReader
  • Writer 字符输出流
    • OutputStreamWriter
      • FileWriter
    • BufferedWriter
    • CharArrayWriter
    • FilterWriter
    • PipedWriter
    • PrintWriter
    • StringWriter

文件里的数据,相当于物品。

输入流 和 输出流,相当于 外卖小哥(需要通过外卖小哥 运输)

文件和文件流

文件,对我们并不陌生,文件是保存数据的地方,比如大家经常使用的word文档,txt文件,excel文件…都是文件。它既可以保存一张图片,也可以保持视频,声音.….

文件流
文件在程序中是以流的形式来操作的

java程序

  • (内存)输出流

文件(磁盘)

反之:文件到java程序 为:输入流

  • 比如 人喝水 就是输入
  • 人 吐口水 是 输出
    • 杯子是文件。水是数据。
    • 人就是java程序,胃就好像是内容。

流:数据在数据源(文件)和程序(内存)之间经历的路径

输入流:数据从数据源(文件)到程序(内存)的路径

输出流:数据从程序(内存)到数据源(文件)的路径

文件的相关操作

创建文件对象相关构造器和方法相关方法

new File(String pathname)//根据路径构建一个File对象

new File(File parent String child)//根据父目录文件+子路径构建
new File(String parent,String child)//根据父目录+子路径构建

createNewFile 创建新文件

Serializable 接口
Comparable

  • File
创建文件
直接new全路径
        String filePath = "e:\\news1.txt";
        File file = new File(filePath);

        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
\\news1.txt //这样写,如果项目在D盘,就创建到D盘根目录
    
news1.txt //这样写,如果idea打开的是:D:\代码\ 这个目录(目录下有多个项目)。那么就是在 \代码 目录下
    		//D:\代码\new4.txt

			//注意了,这种写法如果使用 JUnit 会在往里一层。file.getAbsolutePath() 查看。/a.txt 和 \\a.txt junit和main一样。
    		//文件创建成功 D:\代码\chapter19\news1.txt
Panel.class.getResource("/com/hspedu/tankgame4/gif/bomb_1.gif")
   //这种是在源文件下,如:src是源文件。就从 src/com/...下找。
   //这种:/bomb_1.gif,就要放在src目录下 
父+子创建
  • 使用父文件+目录
        File parentFile = new File("e:\\");
        String fileName = "news2.txt";
        //这里的file对象,在java程序中,只是一个对象
        //只有执行了createNewFile 方法,才会真正的,在磁盘创建该文件
        File file = new File(parentFile, fileName);
        //String parentPath = "e:\\";
        String parentPath = "e:/"; //这样写,也是行的
        String fileName = "news4.txt";
        File file = new File(parentPath, fileName);
获取文件的相关信息

获取文件的相关信息
getName、getAbsolutePath(绝对路径)、getParent、
length 字节大小、exists、isFile、isDirectory

        //先创建文件对象
        File file = new File("e:\\news44.txt");

        //调用相应的方法,得到对应信息  news44.txt
        System.out.println("文件名字=" + file.getName());

        //getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
        //e:\news44.txt
        System.out.println("文件绝对路径=" + file.getAbsolutePath());

        //e:\
        System.out.println("文件父级目录=" + file.getParent());

        System.out.println("文件大小(字节)=" + file.length());//9 (输入了1-9)。如果utf-8,一个汉字对应3个字节。
        System.out.println("文件是否存在=" + file.exists());//T
        System.out.println("是不是一个文件=" + file.isFile());//T
        System.out.println("是不是一个目录=" + file.isDirectory());//F

目录操作

目录的操作和文件删除

mkdir创建一级目录、

mkdirs创建多级目录、

delete删除空目录或文件

    //判断 d:\\news1.txt 是否存在,如果存在就删除

        String filePath = "e:\\news1.txt";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该文件不存在...");
        }
    //判断 D:\\demo02 是否存在,存在就删除,否则提示不存在
    //这里我们需要体会到,在java编程中,目录也被当做文件
        String filePath = "D:\\demo02";
	//其他都一样
    //判断 D:\\demo\\a\\b\\c 目录是否存在,如果存在就提示已经存在,否则就创建

        String directoryPath = "D:\\demo\\a\\b\\c";
        File file = new File(directoryPath);
        if (file.exists()) {
            System.out.println(directoryPath + "存在..");
        } else {
            if (file.mkdirs()) { //创建一级目录使用mkdir() ,创建多级目录使用mkdirs()
                System.out.println(directoryPath + "创建成功..");
            } else {
                System.out.println(directoryPath + "创建失败...");
            }
        }

IO原理和分类

Java IO流原理

  1. I/O是lnput/Output的缩写,I/O技术是
    [常实用的技术,用于处理数据传输。
    如读/写文件,网络通讯等。

  2. Java程序中,对于数据的输入/输出操作以”流(stream)”的方式进行。

  3. java.io包下提供了各种“流”类和接口,用以获取不同种类的数据,并通过方
    法输入或输出数据

Java IO流原理
4.输入input:读取外部数据
(磁盘、光盘等存储设备的数据)到程序(内存)中。

  • 也可能是网络

5.输出output:将程序(内存)
数据输出到磁盘、光盘等存储设备中

  • 也可能输出到网络

流的分类

按操作数据单位不同分为:字节流(8 bit),字符流(按字符)

  • 一个字符对应几个字节,和编码有关。utf-8 汉字对应3个
  • 字节流 操作 二进制文件 更好 (声音 视频 word)。

按数据流的流向不同分为:输入流,输出流

按流的角色的不同分为:节点流,处理流/包装流

  • 节点流 处理流:Buffered
  • 包装流 转换流:InputStreamReader 和 OutputStreamWriter

(抽象基类)
字节流:分为输入 输出
字符流:同样分为 输入 输出

输入流

InputStream

Reader

输出流

OutputStream

Writer

  1. Java的IO流共涉及40多个类,实际上非常规则
    都是从如上4个抽象基类派生的,
    2)由这四个类派生出来的子类名称都是以其父类名作为子类名后缀
public abstract class OutputStream implements Closeable, Flushable {}

常用类

InputStream

InputStream:字节输入流

InputStream:抽象类是所有类字节输入流的超类

常用的子类

  1. FilelnputStream:文件输入流
  2. BufferedInputStream:缓冲字节输入流
    1. 父类:FilterlnputStream 过滤输入
  3. ObjectlnputStream:对象字节输入流
FileInputStream(File file);
//通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File对象file指定。

FileInputStream (FileDescriptor fd0bj)
//通过使用文件描述符f dobj创建一个 FileIrputStrean,该文件描述符表示到文件系统中某个实际文件的现有连接。

FileInput Stream(String name)
//通过打开一个到实际文件的连接来创建一个FileInputStrean,该文件通过文件系统中的路径名name指定。
read()
//从此输入流中读取一个数据字节。
    //返回值:从该输入流读取一个字节的数据。如果没有输入可用,
	//数据的下一个字节,如果达到文件的末尾,-1

int read(byte[] b)
//从此输入流中将最多b.length个字节的数据读入一个 byte数组中。此方法将阻止。直到某些输入可用。

int read (byte[] b,int off, int len)
//从此输入流中将最多len个字节的数据读入一个 byte数组中。
    
skip(long n)
//从输入流中跳过并丢弃n个字节的数据。
FileInputStream
(字节输入流 文件--> 程序)

    /**
     * 演示读取文件...
     * 单个字节的读取,效率比较低
     * -> 使用 read(byte[] b)
     */
    @Test
    public void readFile01() {
        String filePath = "e:\\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象,用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取一个字节的数据。 如果没有输入可用,此方法将阻止。
            //如果返回-1 , 表示读取完毕
            while ((readData = fileInputStream.read()) != -1) {
                System.out.print((char)readData);//转成char显示
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流,释放资源.
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 使用 read(byte[] b) 读取文件,提高效率
     */
    @Test
    public void readFile02() {
        String filePath = "e:\\hello.txt";
        //字节数组
        byte[] buf = new byte[8]; //一次读取8个字节.
        int readLen = 0;
        FileInputStream fileInputStream = null;

            //创建 FileInputStream 对象,用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取最多b.length字节的数据到字节数组。 此方法将阻塞,直到某些输入可用。
            //如果返回-1 , 表示读取完毕
            //如果读取正常, 返回实际读取的字节数
            while ((readLen = fileInputStream.read(buf)) != -1) {
                //buf 的值 假如是 hello,word。第一次数组的 0位置为 104为h,101为e。读取到的是 ASCII码的值
                System.out.print(new String(buf, 0, readLen));//显示
            }
    }

FileOutputStream

FileOutputStrean (File file)

File0utput Strean (File file,boolean append)
//创建一个向指定File 对象表示的文件中写入数据的文件输出流。

FileoutputStrean (String name)
//创建一个向具有指定名称的文件中写入数据的输出文件流。
void write(byte[] b)
void write(byte[] b,int off, int len)
//将指定byte数组中从偏移量off开始的 len个字节写入此文件输出流。

void writer(int b)
//将指定字节写入此文件输出流。
    /**
     * 演示使用FileOutputStream 将数据写到文件中,
     * 如果该文件不存在,则创建该文件
     */
        //创建 FileOutputStream对象
        String filePath = "e:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            //得到 FileOutputStream对象 对象
            //老师说明
            //1. new FileOutputStream(filePath) 创建方式,当写入内容是,会覆盖原来的内容
            //2. new FileOutputStream(filePath, true) 创建方式,当写入内容是,是追加到文件后面
            fileOutputStream = new FileOutputStream(filePath, true);
            
            //写入一个字节
            //fileOutputStream.write('H');
            
            //写入字符串
            String str = "hsp,world!";
            //str.getBytes() 可以把 字符串-> 字节数组
            //fileOutputStream.write(str.getBytes());
            
            /*
            write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流
             */
            fileOutputStream.write(str.getBytes(), 0, 3);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

文件拷贝

在完成程序时,应该是读取部分数据,就写入到指定文件,这里使用循环

        //完成 文件拷贝,将 e:\\Koala.jpg 拷贝 c:\\
        //思路分析
        //1. 创建文件的输入流 , 将文件读入到程序
        //2. 创建文件的输出流, 将读取到的文件数据,写入到指定的文件.
        String srcFilePath = "e:\\Koala.jpg";
        String destFilePath = "e:\\Koala3.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {

            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);
            //定义一个字节数组,提高读取效果
            byte[] buf = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buf)) != -1) {
                //读取到后,就写入到文件 通过 fileOutputStream
                //即,是一边读,一边写
                fileOutputStream.write(buf, 0, readLen);//一定要使用这个方法

            }
            System.out.println("拷贝ok~");


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭输入流和输出流,释放资源
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
文件拷贝自动关流
        try (FileInputStream fi = new FileInputStream("e:\\1.jpg");
             FileOutputStream fo = new FileOutputStream("e:\\2.jpg")) {
            
            byte[] b = new byte[1024];
            int len;
            while ((len = fi.read(b)) != -1) {
                fo.write(b, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

FileReader 和 FileWriter

FileReader和 FileWriter是字符流,即按照字符来操作io

FileReader相关方法:

1) new FileReader(File/String)
2) read:每次读取单个字符,返回该字符,如果到文件末尾返回-1
3) read(char[l):批量读取多个字符到数组,返回读取到的字符数,如果到文件末尾返回 -1
             
相关APl:
1) new String(char[]):char[]转换成String
2) new String(char[1,off,len]):char[的指定部分转换成String
  • Reader 字符输入流
    • lnputStreamReader
      • FileReader
  • Writer 字符输出流
    • OutputStreamWriter
      • FileWriter
public class InputStreamReader extends Reader{}
FileWriter常用方法
1) new FileWriter(File/String):覆盖模式,相当于流的指针在首端
2) new FileWriter(File/String,true):追加模式,相当于流的指针在尾端3) write(int):写入单个字符
4) write(char[]):写入指定数组
5) write(char[],off,len):写入指定数组的指定部分6) write (string):写入整个字符串
7) write(string,off,len):写入字符串的指定部分
              
相关APl: String:toCharArray:String转换成char[]
注意:
FileWriter使用后,必须要关闭(close)或刷新(flush),否则写入不到指定的文件!
FileReader

        System.out.println("~~~readFile02 ~~~");
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;

        int readLen = 0;
        char[] buf = new char[8];
        //1. 创建FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read(buf), 返回的是实际读取到的字符数
            //如果返回-1, 说明到文件结束
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int data = 0;
        //1. 创建FileReader对象

            fileReader = new FileReader(filePath);
            //循环读取 使用read, 单个字符读取
            while ((data = fileReader.read()) != -1) {
                System.out.print((char) data);
            }
FileWriter
    public static void main(String[] args) {

        String filePath = "e:\\note.txt";
        //创建FileWriter对象
        FileWriter fileWriter = null;
        char[] chars = {'a', 'b', 'c'};
        try {
            fileWriter = new FileWriter(filePath);//默认是覆盖写入
//            3) write(int):写入单个字符
            fileWriter.write('H');
            
//            4) write(char[]):写入指定数组
            fileWriter.write(chars);
//            5) write(char[],off,len):写入指定数组的指定部分
            fileWriter.write("韩顺平教育".toCharArray(), 0, 3);
            
//            6) write(string):写入整个字符串
            fileWriter.write(" 你好北京~");
            fileWriter.write("风雨之后,定见彩虹");
//            7) write(string,off,len):写入字符串的指定部分
            fileWriter.write("上海天津", 0, 2);
            //在数据量大的情况下,可以使用循环操作.


        } catch (IOException e) {
            e.printStackTrace();
        } finally {

        //对应FileWriter , 一定要关闭流,或者flush才能真正的把数据写入到文件
        //老韩看源码就知道原因.
        /*
        看看代码
        private void writeBytes() throws IOException {

        if (var3 > 0) {
            if (this.ch != null) {
                assert this.ch.write(this.bb) == var3 : var3;
            } else {
                //注意了:***************这里底层用的 依然是 FileOutputStream
                this.out.write(this.bb.array(), this.bb.arrayOffset() + var2, var3);
            }
        }
        	this.bb.clear();
    	}
        */
            
            try {
                //fileWriter.flush();,最终调用的  依然是 writeBytes
                //关闭文件流,等价 flush() + 关闭
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        System.out.println("程序结束...");
    }
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用字节流和字符流分别复制文本文件的示例代码: 使用字节流: ```java import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class ByteStreamCopy { public static void main(String[] args) throws IOException { FileInputStream fis = null; FileOutputStream fos = null; try { fis = new FileInputStream("source.txt"); fos = new FileOutputStream("target.txt"); byte[] buffer = new byte[1024]; int len; while ((len = fis.read(buffer)) != -1) { fos.write(buffer, 0, len); } } finally { if (fis != null) { fis.close(); } if (fos != null) { fos.close(); } } } } ``` 使用字符流: ```java import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class CharStreamCopy { public static void main(String[] args) throws IOException { FileReader reader = null; FileWriter writer = null; try { reader = new FileReader("source.txt"); writer = new FileWriter("target.txt"); char[] buffer = new char[1024]; int len; while ((len = reader.read(buffer)) != -1) { writer.write(buffer, 0, len); } } finally { if (reader != null) { reader.close(); } if (writer != null) { writer.close(); } } } } ``` 其中,`source.txt` 是要复制的源文件,`target.txt` 是复制后的目标文件。使用字节流复制文件时,需要使用 `FileInputStream` 和 `FileOutputStream` 类,而使用字符流复制文件时,需要使用 `FileReader` 和 `FileWriter` 类。在复制过程中,需要使用一个缓冲区来存储取的数据,并使用 `read()` 和 `write()` 方法进行取和写入操作。最后,需要在 finally 块中关闭流。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值