Java的IO流

一小人物@

已于 2023-04-19 19:22:27 修改

阅读量272

点赞数 1

文章标签： java

于 2023-04-10 23:11:13 首次发布

本文链接：https://blog.csdn.net/qq_43818546/article/details/130069047

版权

Java—IO流

一、IO流简介
二、IO流的常见方法
三、io分类：
四、字符流和字节流
五、基本结构

一、IO流简介

定义：对文件的内容进行读和写的操作。
IO流所在的Java包：java.io.File
路径：分为两种：相对路径和绝对路径
（1）相对路径：指的是相对于当前的文件所在的路径。
（2）绝对路径：指的是带有盘符的路径。例如我们需要找一个在D盘下io文件夹里的Hello.txt文件，那么这个文件的“D:\io\Hello.txt”路径就是绝对路径。

二、IO流的常见方法

1、文件类的创建写法：

//在项目中已建好一个名为：HelloWord.txt的文件
File f1 = new File("HelloWord.txt");
//在D盘里的workspace文件夹下的java文件夹下已建好一个名为：HelloWord1.txt的文件
File f2 = new File("D:\\workspace\\java\\HelloWord1.txt");

2、io流的普通方法：
（1）、public String getAbsolutePath()：获取绝对路径。
（2）、public String getPath()：获取路径。
（3）、public string getName()：获取名称。
（4）、public string getParent()：获取上层文件日录路径。若无，返回null。
（5）、public long length()：获取文件长度〈即：字节数）。不能获取目录的长度。
（6）、public long lastModified()：获取最后一次的修改时间，毫秒值。

package TestFile;

import java.io.File;

public class TestFile1 {
    public static void main(String[] args) {
        File f1 = new File("HelloWorld.txt");
        File f2 = new File("F:\\练习\\04.10\\HelloWorld（文件夹下的1）.txt");
        System.out.println("f1的信息：");
        System.out.println(f1.getAbsolutePath());   //获取绝对路径
        System.out.println(f1.getPath());   //获取路径
        System.out.println(f1.getName());   //获取名称
        System.out.println(f1.getParent()); //获取上层文件日录路径。若无，返回null
        System.out.println(f1.length());    //获取文件长度〈即：字节数）。不能获取目录的长度。
        System.out.println(f1.lastModified());  //获取最后一次的修改时间，毫秒值
        System.out.println("====================================================================");
        System.out.println("f2的信息:");
        System.out.println(f2.getAbsolutePath());   //获取绝对路径
        System.out.println(f2.getPath());   //获取路径
        System.out.println(f2.getName());   //获取名称
        System.out.println(f2.getParent()); //获取上层文件日录路径。若无，返回null
        System.out.println(f2.length());    //获取文件长度〈即：字节数）。不能获取目录的长度。
        System.out.println(f2.lastModified());  //获取最后一次的修改时间，毫秒值

        System.out.println("====================================");
        File f3 = new File("F:\\练习\\04.10");
        String[] list = f3.list();
        File[] listFiles = f3.listFiles();
        for (String o : list){
            System.out.println(o);
        }
        System.out.println("==========================================================");
        for (File o1 : listFiles){
            System.out.println(o1);
        }
    }
}

3、如下的两个方法适用于文件目录：
（1）、public String[ ] list()：获取指定日录下的所有文任或者文件目录的名称数组。
（2）、public File[] listFiles()：获取指定目录下的所有文件或者文件目录的File数组。

4、public boolean renameTo(File dest)：把文件重命名为指定的文件路径。
比如: file1.renameTo(file2)为例。要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。

package ReName;

import java.io.File;

public class ReNameTo {
    public static void main(String[] args) {
        File f1 = new File("hello.txt");
        File f2 = new File("F:\\南京正厚软件公司\\课堂\\练习\\04.10");
        boolean b = f1.renameTo(f2); //   f1的文件需要是要有的，f2的文件是需要不存在
        System.out.println(b);
    }
}

5、io流的判断方法：
（1）、public boolean isDirectory()：判断是否是文件目录。
（2）、public boolean isFile()：判断是否是文件。
（3）、public boolean exists()：判断是否存在。
（4）、public boolean canRead()：判断是否可读。
（5）、public boolean canWrite()：判断是否可写。
（6）、public boolean isHidden()：判断是否隐藏。
（7）、File f1 = new File(“helloWorld.txt”);

package TestFile;

import java.io.File;

public class TestFile3 {
    public static void main(String[] args) {
        File f1 = new File("HelloWord.txt");
        File f2 = new File("F:\\练习\\04.10\\HelloWorld（文件夹下的3）.txt");

        System.out.println(f1.isDirectory());   //判断是否是文件目录
        System.out.println(f1.isFile());    //判断是否是文件
        System.out.println(f1.exists());    //判断是否存在
        System.out.println(f1.canRead());   //判断是否可读
        System.out.println(f1.canWrite());  //判断是否可写
        System.out.println(f1.isHidden());  //判断是否隐藏

        System.out.println("=================");
        System.out.println(f2.isDirectory());   //判断是否是文件目录
        System.out.println(f2.isFile());    //判断是否是文件
        System.out.println(f2.exists());    //判断是否存在
        System.out.println(f2.canRead());   //判断是否可读
        System.out.println(f2.canWrite());  //判断是否可写
        System.out.println(f2.isHidden());  //判断是否隐藏
    }
}

6、f1.delete(); //删除文件
7、f1.mkdir(); //创建文件

package TestFile;

import java.io.File;

public class TestFile4 {
    public static void main(String[] args) {
        File f1 = new File("HelloWorld1.txt");
        if (f1.exists()){   //判断文件是否存在
            f1.delete();    //删除操作
            System.out.println("删除成功");
        }else {
            f1.mkdir(); //创建文件
            System.out.println("创建成功");
        }
    }
}

三、io分类：

1、按照流向分：输入流输出流
2、按照单位分：字节流字符流
3、拉照角色分：节点流处理流

四、字符流和字节流

1、字符流处理： .doc .txt
2、字节流处理： .png .jpg .mp3 .mp4

五、基本结构

1、字符流

1.1、基本结构：

基类	节点流	缓冲流
Reader	FileReader	BufferFileReader
Writer	FileWriter	BufferFileWriter

1.2、写法步骤：
（1）先创建文件类
（2）创建流
（3）写操作
（4）关流：close();

1.3、例子1：读取操作：FileReader来读取一个文件，如果文件到达最后一个位置(即-1)，就停止读取操作。

package TestCharacterStream;

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

public class TestFileReader {
    public static void main(String[] args) {
        // FileReader：来读取一个文件，如果文件到达最后一个位置-1，就停止读的操作
        //1、创建文件类
        File f1 = new File("hello2.txt");
        //2、创建流
        FileReader fr = null;
        try {
            fr = new FileReader(f1);
            //3、读操作
            char [] chars = new char[30];
            int len;
            while ((len= fr.read(chars))!=-1){
                //读一个char类型的数组，从0的位置开始读，一直读到最后一个内容
                String str = new String(chars,0,len);
                System.out.println(str);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //4、关流：先开的要后关
            if (fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.4、例子2：写入操作：向文件 hello2.txt中写内容。

package TestCharacterStream;

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

public class TestFileWriter {
    public static void main(String[] args) {
        //向文件  hello2.txt中写内容
        // 在写的过程中，如果文件不存在，则会帮我们自动的创建一个文件
        //1.创建一个File类
        File file = new File("hello2.txt");
        //2.创建流
        FileWriter fw = null;
        try {
            fw = new FileWriter(file);
            //3、写操作
            fw.write("I love you.");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }
}

1.5、例子3：读写操作一起实现。

package TestCharacterStream;

import java.io.*;

public class TestFileCopy {
    public static void main(String[] args) {
        //文件的复制
        //1.创建文件类
        File f1 = new File("hello2.txt");
        File f2 = new File("hello3.txt");
        //2、创建流
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //3读取hello2.txt文件
            fr = new FileReader(f1);    //读取操作
            fw = new FileWriter(f2);    //写入操作
            char [] chars = new char[30];
            int len;
            while ((len=fr.read(chars)) != -1){ //循环读到每个内容
                //写的操作
                fw.write(chars,0,len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关流：先开的后关
            if (fw != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

2、字节流
2.1、基本结构：

基类	节点流	缓冲流
InputStream	FileInputStream	BufferFileInputStream
OutPutStream	FileOutPutStream	BufferFileOutPutStream

2.2、写法步骤：
（1）先创建文件类
（2）创建流
（3）写操作
（4）关流：close();

2.3、例子：使用字节流进行文件复制的操作

package TestByteStream;

import java.io.*;

/**
 * 使用字节流进行文件复制的操作
 */
public class TestCopy {
    public static void main(String[] args) throws Exception {
        //创建File类对象
        File f1 = new File("hello2.txt");   //读取操作
        File f2 = new File("hello4.txt");   //写入操作

        //创建流
        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos =new FileOutputStream(f2);

        //进行读、写操作
        byte [] bytes = new byte[30];
        int len;
        while ((len=fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }

        //关流
        fos.close();;
        fis.close();
    }
}

3、节点流与缓冲流的对比

package TestByteStream;

import java.io.*;
import java.util.Stack;

/**
 * 节点流（字节流）与缓冲流的对比：缓冲流的速度比字节流的要快
 */
public class TestCopy1 {
    public static void copyFile1(String src1,String src2) throws Exception {
        //创建类对象
        File f1 = new File(src1);
        File f2 = new File(src2);

        //创建流
        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos = new FileOutputStream(f2);

        //进行读/写操作
        byte [] buffer = new byte[30];
        int len;
        while((len=fis.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }

        fos.close();
        fis.close();
    }

    public static void copyFile2(String src1,String src2) throws Exception{
        //创建类对象
        File f1 = new File(src1);
        File f2 = new File(src2);

        //创建流
        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos = new FileOutputStream(f2);
        //将字节流对象作为参数 加入到 缓冲流中
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);


        //进行读/写操作
        byte [] buffer = new byte[30];
        int len;
        while((len=bis.read(buffer))!=-1){
            bos.write(buffer,0,len);
        }
        bis.close();
        bos.close();
    }

    public static void main(String[] args) {
        try {
            //获取系统当前时间
            long start = System.currentTimeMillis();
            //95012
            TestCopy1.copyFile1("F:\\南京正厚软件公司\\课堂\\教师\\04.10（io流）\\io流的视频\\01_File常用方法.mp4","F:\\南京正厚软件公司\\课堂\\教师\\04.10（io流）\\io流的视频\\01_File常用方法3331.mp4");
            //4324
            TestCopy1.copyFile2("F:\\南京正厚软件公司\\课堂\\教师\\04.10（io流）\\io流的视频\\01_File常用方法.mp4","F:\\南京正厚软件公司\\课堂\\教师\\04.10（io流）\\io流的视频\\01_File常用方法3332.mp4");

            long end = System.currentTimeMillis();
            System.out.println("所需时间是："+(end-start));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

一小人物@

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java的IO流

定义：对文件的内容进行读和写的操作。IO流所在的Java包：java.io.File路径：分为两种：相对路径和绝对路径（1）相对路径：指的是相对于当前的文件所在的路径。（2）绝对路径：指的是带有盘符的路径。例如我们需要找一个在D盘下io文件夹里的Hello.txt文件，那么这个文件的“D:\io\Hello.txt”路径就是绝对路径。
复制链接

扫一扫