IO流

最新推荐文章于 2024-07-24 17:27:32 发布

hjh3132778226

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量111

点赞数

文章标签： java

本文链接：https://blog.csdn.net/hjh3132778226/article/details/115551639

版权

IO流

1.什么是流？

概念:内存与存储设备之间传输数据的通道

简单的说这就是计算机传输数据的方式输入流主要体现在我们从键盘输入传送给计算机，输出流主要体现在计算机在屏幕上打印

2.IO流的分类

1.按流向分类：输入流、输出流

输入流:将存储设备中的内容读入到内存中
输出流:将内存中的内容写入到存储设备中

2.按操作对象(单位)分类：字节流、字符流

字节流：以字节为单位，可以读写所有的数据
字符流：以字符为单位，只能读写文本数据

3.按功能分类：节点流、处理流

节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能

3.字节流

字节流的父类(抽象类):
- InputStream :字节输入流
- OutputStream : 字节输出流

4.文件字节流

FileInputStream:

public int read(byte [] b) //从流中读取多个字节，将读到内容存入

b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1

package Demo26.demo01;

import java.io.FileInputStream;

/**
 * @author fanqie
 * @date 2021/4/2 -14:01
 * 演示FileInputStream的使用
 * 文件字节输入流
 */
public class FileInputStream_01 {
    public static void main(String[] args) throws Exception {
        //1.创建FileInputStream,并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");

        //2.读取文件
        //fis.read();
        //2.1单个字节读取
//        int date = 0;
//        while ((date=fis.read())!=-1) {
//            System.out.print((char) date);
//        }

        //2.2一次性读取多个字节
        byte [] bytes = new byte[131];
        int count = 0;
        while ((count=fis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,count));
        }

        //3.关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}

FileOutputStream：

public void write(byte [] b) //一次写多个字节，将b数组中所有字节，写入输出流

package Demo26.demo01;

import java.io.FileOutputStream;

/**
 * @author fanqie
 * @date 2021/4/2 -14:28
 * 演示文件字节输出流的使用
 * FileOutputStream
 */
public class FileOutputStream_01 {
    public static void main(String[] args) throws Exception{
        //1.创建文件字节输出流对象
        FileOutputStream fil = new FileOutputStream("d:\\bbb.txt",true);//如果写了true,那么它的值将不会覆盖
        //2.写入文件
//        fil.write(97);
//        fil.write('b');
//        fil.write('c');
        String s = "helloworld";
        fil.write(s.getBytes());
        //3.关闭
        fil.close();
        System.out.println("执行完毕");


    }
}

使用文件字节流实现文件的复制

package Demo26.demo01;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author fanqie
 * @date 2021/4/2 -14:51
 * 使用文件字节流实现文件的复制
 */
public class fuzhi {
    public static void main(String[] args) throws Exception {
        //1.创建流
        //1.1.文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //1.2.文件字节输入流
        FileOutputStream fos = new FileOutputStream("d:\\ccc.txt");

        //2.一边读,一边写
        byte [] bytes = new byte[1024];
        int count = 0;
        while ((count=fis.read(bytes))!=-1){
            fos.write(bytes,0,count);
        }

        //3.关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");

    }
}

5.字节缓冲流

缓冲流:BufferedInputStream/BufferedOutputStream

提高Io效率，减少访问磁盘的次数；

数据存储在缓冲区中，flush是将缓冲区的内容写到文件中，也可以直接close

package Demo26.demo02;

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

/**
 * @author fanqie
 * @date 2021/4/2 -15:01
 * 使用字节缓冲流读取
 * BufferedInputStream
 */
public class BufferedInputStream_01 {
    public static void main(String[] args) throws Exception {
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream buf = new BufferedInputStream(fis);

        //2.读取
        int date = 0;
        while ((date=buf.read())!=-1){
            System.out.print((char) date);
        }
        
//        byte [] bytes = new byte[1024];
//        int count = 0;
//        while ((count=buf.read(bytes))!=-1){
//            System.out.println(new String(bytes,0,count));
//        }

        //3.关闭
        buf.close();
        System.out.println();
        System.out.println("\n执行完毕");
    }
}

package Demo26.demo02;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/**
 * @author fanqie
 * @date 2021/4/2 -15:12
 *使用字节缓冲流写入文件
 * BufferedOutputStream
 */
public class BufferedOutputStream_01 {
    public static void main(String[] args)throws Exception {
        //1.创建字节输出缓冲流
        FileOutputStream fio = new FileOutputStream("d:\\eee.txt");
        BufferedOutputStream bf = new BufferedOutputStream(fio);

        //2.写入文件
        for (int i=0;i<10;i++){
            bf.write("番茄永远滴神\r\n".getBytes());//写入8k缓冲区
            bf.flush();//刷新到硬盘
        }

        //3.关闭(内部调用 flush方法)
        bf.close();
        System.out.println("执行完毕");
    }
}

6.对象流

对象流:ObjectOutputStream/ObjectInputStream
- 增强了缓冲区功能
- 增强了读写8中基本数据类型和字符串功能
- 增强了读写独享的功能
  1. readObject() 从流中读取一个对象
  2. writeObject(Object obj) 向流中写入一个对象
使用流传输对象的过程称为序列化、反序列化

序列化ObjectOutputStream

package Demo26.demo03;

import java.io.Serializable;

/**
 * @author fanqie
 * @date 2021/4/2 -17:02
 */
public class Student implements Serializable {
   private String name;
   private transient int age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }
}

package Demo26.demo03;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/**
 * @author fanqie
 * @date 2021/4/2 -17:06
 * ObjectOutputStream实现对象的序列化
 * 注意事项:
 * (1)序列化类必须要实现Serializable接口
 * (2)序列化类中对象属性要求实现Serializable接口
 * (3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类
 * (4)使用transient(瞬间的)修饰属性，这个属性不能序列化
 * (5)静态实现不能序列化
 * (6)序列化多个对象，可以帮助集合实现
 */
public class ObjectOutputStream_01 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化（写入操作）
        Student stu = new Student("张三",12);
        Student stu2 = new Student("李四",12);
//        oos.writeObject(stu);
//        oos.writeObject(stu2);

        ArrayList<Student> list = new ArrayList<>();
        list.add(stu);
        list.add(stu2);
        oos.writeObject(list);

        //3.关闭
        oos.close();
        System.out.println("序列化完毕");

    }
}

反序列化ObjectInputStream

package Demo26.demo03;

import java.io.Serializable;

/**
 * @author fanqie
 * @date 2021/4/2 -17:02
 */
public class Student implements Serializable {
   private String name;
   private transient int age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }
}

package Demo26.demo03;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;

/**
 * @author fanqie
 * @date 2021/4/2 -17:11
 * ObjectInputStream实现反序列化（读取重构成对象）
 */
public class ObjectInputStream_01 {
    public static void main(String[] args) throws Exception {
        //1.创建流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ooi = new ObjectInputStream(fis);
        //2.读取文件(反序列化)
//        Student s = (Student) ooi.readObject();
//        Student s1 = (Student) ooi.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ooi.readObject();

        //3.关闭
        ooi.close();
//        System.out.println(s.toString());
//        System.out.println(s1.toString());
          System.out.println("反序列化完毕");
          System.out.println(list.toString());


    }
}

7.常见字符编码

ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
UTF-8 针对Unicode码表的可变长度字符编码
GB2312 简体中文
GBK 简体中文、扩充
BIG5 台湾，繁体中文

8.字符流

字符流对的父类(抽象类):
- Reader:字符输入流
  1. public int read(){}
  2. public int read(char[] c){}
  3. public int read(char[] b,int off,int len){}
- Writer: 字符输出流
  1. public void write(int n){}
  2. public void write(String str){}
  3. public void write(char[] c){}

9.文件字符流

FileReader:
- public int read(char [] c) //从流中读取多个字符，将读到内容存入C数组，返回实际读到的字符数:如果达到文件的尾部，则返回-1
FileWriter:
- public void writer(String str) //一次写多个字符，将b数组中所有字符，写入输出流

package Demo26.demo04;

import java.io.FileReader;

/**
 * @author fanqie
 * @date 2021/4/2 -17:49
 * 使用FileReader读取文件
 */
public class FileReader_01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\hello.txt");

        //2.读取
        //2.1.单个字符读取
//        int date = 0;
//        while ((date=fr.read())!=-1){//读取一个字符
//            System.out.print((char) date);
//        }

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

        fr.close();
    }
}

package Demo26.demo04;

import java.io.FileWriter;

/**
 * @author fanqie
 * @date 2021/4/2 -17:55
 * 使用FileWriter写入文件
 */
public class FileWriter_01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\writer.txt");

        //2.写入
        for (int i=0;i<10;i++){
            fw.write("番茄永远滴神\r\n");
            fw.flush();
        }

        //3.关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件

package Demo26.demo04;

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

/**
 * @author fanqie
 * @date 2021/4/2 -18:00
 *使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
 */
public class fuzhi {
    public static void main(String[] args) throws Exception {
        //1.创建FileReader和FileWriter
        FileReader fr = new FileReader("d:\\writer.txt");
        FileWriter fw = new FileWriter("d:\\writer2.txt");

        //2.读写
        int date = 0;
        while ((date= fr.read())!=-1){
          fw.write(date);
          fw.flush();
        }
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

10.字符缓冲流

缓冲流:BufferedReader/BufferedWriter
- 高效率读写
- 支持输入换行符
- 可一次写一行、读一行

package Demo26.demo05;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * @author fanqie
 * @date 2021/4/5 -20:04
 * 使用字符缓冲流读取文件
 * BufferedReader
 */
public class BufferedReader_01 {
    public static void main(String[] args) throws Exception{
        //1.创建缓冲流
        FileReader fr = new FileReader("d:\\writer.txt");
        BufferedReader br = new BufferedReader(fr);

        //2.读取
        //2.1.第一种方式
//        char [] buf = new char[1024];
//        int count = 0;
//        while ((count=br.read(buf))!=-1){
//            System.out.print(new String(buf,0,count));
//        }

        //2.2.第二种方式，一行一行的读取
        String line = null;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }

        //3.关闭
        br.close();
    }
}

package Demo26.demo05;

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * @author fanqie
 * @date 2021/4/5 -20:11
 *演示BufferedWriter的使用
 * BufferedWriter
 */
public class BufferedWriter_01 {
    public static void main(String[] args) throws Exception{
       //1.创建BufferedWriter对象
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        //2.写入
        for (int i=0;i<10;i++){
            bw.write("好好学习，天天向上");
            bw.newLine();//写入一个换行符
            bw.flush();
        }

        //3.关闭
        System.out.println("执行完毕");
        bw.close();
    }
}

11.打印流

PrintWriter:

封装了print() / println() 方法，支持写入后换行
支持数据原样打印

package Demo26.demo06;

import java.io.PrintWriter;

/**
 * @author fanqie
 * @date 2021/4/6 -1:59
 * 演示PrintWriter的使用
 */
public class PrintWriter_01 {
    public static void main(String[] args) throws Exception {
        //1.创建打印流
        PrintWriter pr = new PrintWriter("d:\\print.txt");

        //2.打印
        pr.println(96);
        pr.println(true);
        pr.println(3.34);
        pr.println('a');

        //3.关闭
        pr.close();
        System.out.println("打印完毕");
    }
}

12.转换流

桥转换流:InputStreamReader/OutputStreamWriter
- 可将字节流转换为字符流
- 可设置字符的编码方式

package Demo26.demo07;

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;

/**
 * @author fanqie
 * @date 2021/4/6 -2:08
 * 使用InputStreamReader读取文件，指定使用编码
 */
public class InputStreamReader_01
{
    public static void main(String[] args) throws Exception{
        //1.创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("d:\\writer.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");

        //2.读取文件
        int date = 0;
        while ((date=isr.read())!=-1){
            System.out.print((char) date);
        }

        //3.关闭
        isr.close();
        System.out.println("执行完毕");

    }
}

package Demo26.demo07;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

/**
 * @author fanqie
 * @date 2021/4/6 -2:14
 * 使用OutputStreamWriter写入，使用指定编码
 */
public class OutputStreamWriter_01 {
    public static void main(String[] args) throws Exception {
        //1.创建OutputStreamWriter
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //2.写入
        for (int i = 0;i<10;i++){
            osw.write("深圳,嘟嘟嘟\n");
            osw.flush();
        }

        //3.关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

13.打印流

PrintWriter:
- 封装了print() / println() 方法，支持写入后换行
- 支持数据原样打印

package Demo26.demo06;

import java.io.PrintWriter;

/**
 * @author fanqie
 * @date 2021/4/6 -1:59
 * 演示PrintWriter的使用
 */
public class PrintWriter_01 {
    public static void main(String[] args) throws Exception {
        //1.创建打印流
        PrintWriter pr = new PrintWriter("d:\\print.txt");

        //2.打印
        pr.println(96);
        pr.println(true);
        pr.println(3.34);
        pr.println('a');

        //3.关闭
        pr.close();
        System.out.println("打印完毕");
    }
}

14.File类

概念：代表物理盘符中的一个文件或者文件夹

基本方法:

createNewFile() //创建一个新文件
mkdir() //创建一个新目录
delete() //删除文件或空目录
exists() //判断File对象所对象所代表的对象是否存在
getAbsolutePath() //获取文件的绝对路径
getName() //取得名字
getParent() //获取文件/目录所在的目录
isDirectory() //是否是目录
isFile() //是否是文件
length() //获取长度
listFiles() //列出目录中的所有内容
renameTo() //修改文件名为

package Demo26.demo08;

import java.io.File;
import java.io.FileReader;
import java.sql.Date;

/**
 * @author fanqie
 * @date 2021/4/6 -2:34
 * File类的使用
 * (1)分隔符
 * (2)文件操作
 * (3)文件夹操作
 */
public class File_01 {
    public static void main(String[] args) throws Exception {
        //separator();
       // fileOpe();
        directoryOpe();

    }

    //（1）分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);// ;
        System.out.println("文件分隔符"+File.separator);//  /
    }

    //(2)文件操作
    public static void fileOpe() throws Exception{
        //1.创建文件createNewFile()
        File file = new File("d:\\file.txt");
        if(!file.exists()){ //exists判断
            boolean b = file.createNewFile();
            System.out.println("创建结果为:"+b);
        }else {
            System.out.println("创建失败,文件已存在");
        }

        //2.删除文件
        //2.1.直接删除
        //System.out.println("删除结果:"+file.delete());

        //2.2.使用jvm退出时删除
        //file.deleteOnExit();
        //Thread.sleep(5000);//计时

        //3.获取文件信息
        System.out.println("获取文件的绝对路径:"+file.getAbsolutePath());
        System.out.println("获取路径:"+file.getPath());
        System.out.println("获取文件名称:"+file.getName());
        System.out.println("获取父目录:"+file.getParent());
        System.out.println("获取文件的长度:"+file.length());
        System.out.println("获取文件的创建时间:"+new Date(file.lastModified()).toLocaleString());

        //4.判断
        System.out.println("判断是否可写:"+file.canWrite());
        System.out.println("是否是文件:"+file.isFile());
        System.out.println("是否隐藏:"+file.isHidden());
    }

    //(3)文件夹操作
    public static void directoryOpe() throws Exception{
        //1.创建文件夹
        File file = new File("d:\\aaa\\bbb\\ccc");
        if (!file.exists()){
            //System.out.println("创建结果:"+file.mkdir());//只能创建单级目录
            System.out.println("创建结果:"+file.mkdirs());//创建多目录
        }else {
            System.out.println("创建失败,文件已存在");
        }

        //2.删除文件夹(只能删除最后一个子目录)
        //2.1.直接删除(只能删除空目录)
        //System.out.println("删除结果为:"+file.delete());

        //2.2.使用jvm删除
        //file.deleteOnExit();
        //Thread.sleep(5000);

        //3.获取文件夹的信息
        System.out.println("获取绝对路径:"+file.getAbsolutePath());
        System.out.println("获取路径"+file.getPath());
        System.out.println("获取文件夹名称:"+file.getName());//只能获得最后一个子目录文件夹名称
        System.out.println("获取父目录:"+file.getParent());
        System.out.println("获取创建时间"+new Date(file.lastModified()).toLocaleString()  );

        //4.判断
        System.out.println("是否是文件夹:"+file.isDirectory());
        System.out.println("是否是隐藏"+file.isHidden());

        //5.遍历文件夹
        File file1 = new File("E:\\壁纸");
        String [] s = file1.list();
        System.out.println("-------------------------------------");
        for (String s1 : s) {
            System.out.println(s1);
        }
    }
}

15.FileFilter接口

public interface FileFilter
- boolean accept(File pathname)
当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles()的返回值中

File file1 = new File("E:\\壁纸");

 System.out.println("---------------------FileFilter接口的使用-------------------------");
        File[] file2 = file1.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".exe")){//只获取文件后缀为.exe的文件
                    return true;
                }
                return false;
            }
        });

        for (File file3 : file2) {
            System.out.println(file3.getName());
        }
    }

16.递归遍历文件夹和递归删除文件夹

package Demo26.demo09;

import java.io.File;

/**
 * @author fanqie
 * @date 2021/4/6 -3:46
 * 案例1:递归遍历文件夹
 * 案例2:递归删除文件夹
 */
public class listDemo {
    public static void main(String[] args) {
       //listDir(new File("d:\\myfiles"));
        deleteDir(new File("d:\\myfiles"));
    }

    //案例1:递归遍历文件夹
    public static void listDir(File dir){
       File [] files = dir.listFiles();
        System.out.println(dir.getAbsoluteFile());
        if(files!=null&&files.length>0){
            for (File file : files) {
                if(file.isDirectory()){
                    listDir(file);//递归
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
    //案例2:递归删除文件夹
    public static void deleteDir(File dir){
        File [] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if(file.isDirectory()){
                    deleteDir(file);//递归
                }else{
                    //删除文件
                    System.out.println(file.getAbsolutePath()+"删除:"+file.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath()+"删除:"+dir.delete());

    }

}

17.Properites

Properites：属性集合
特点
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关

package Demo26.demo10;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

/**
 * @author fanqie
 * @date 2021/4/6 -4:00
 * Properites集合的使用
 */
public class Properites_01  {
    public static void main(String[] args) throws Exception{
        //1.创建集合
        Properties properties = new Properties();
        //2.添加数据
        properties.setProperty("username","张三");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3.遍历
        //3.1------------KeySet--------------
        //3.2------------entrySet------------
        //3.3------------stringPropertyNames()---------------------
       Set<String> pronames =  properties.stringPropertyNames();
        for (String proname : pronames) {
            System.out.println(proname+"=========="+properties.getProperty(proname));
        }

        //4.和流有关的方法
        //---------list方法-------------------
//        PrintWriter pw = new PrintWriter("d:\\print.txt");
//        properties.list(pw);
//        pw.close();

        //-------------store方法 保存-----------------------
//        FileOutputStream fos = new FileOutputStream("d:\\print.properties");
//        properties.store(fos,"注释");
//        fos.close();

        //-----------------load方法 加载---------------------------------
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\print.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());

    }
}

hjh3132778226

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流

IO流文章目录IO流1.什么是流？2.IO流的分类1.按流向分类：**输入流、输出流**2.按操作对象(单位)分类：字节流、字符流3.按功能分类：**节点流、处理流**3.字节流4.文件字节流使用文件字节流实现文件的复制5.字节缓冲流6.对象流序列化ObjectOutputStream反序列化ObjectInputStream7.常见字符编码8.字符流9.文件字符流使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件10.字符缓冲流11.打印流12.转换流13.打印流14.
复制链接

扫一扫