0
点赞
收藏
分享

微信扫一扫

Java I/O框架

探头的新芽 2022-02-19 阅读 36
java开发语言后端

I/O框架

流的概念

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

流的分类

  • 按方向
    • 输入流：将存储设备中的内容读入到内存中
    • 输出流：将内存中的内容写入到存储设备中
  • 按单位
    • 字节流：以字节为单位，可以读写所有数据
    • 字符流：以字符为单位，只能读写文本数据
  • 按功能
    • 节点流：具有实际传输数据的读写功能
    • 过滤流：在节点流的基础上增加功能

字节流

  • 字节流的父类（抽象类）：
    • InputStream：字节输入流
    • OutputStream：字节输出流

文件字节流

  • FileInputStream
package ioframe;

import java.io.FileInputStream;

public class Demo01 {
    public static void main(String[] args) throws Exception{
        //创建FileInputStream,指定文件路径
        FileInputStream file = new FileInputStream("e:\\aaa.txt");
        //读取文件
        //单个字节读取，file.read();
        /*
        int data = 0;

        while((data=file.read())!=-1){
            System.out.print((char)data);
        }
        */
        //读取多个字节
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count= file.read(buf))!= -1){
            System.out.println(new String(buf,0,count));
        }
        //关闭
        file.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}
  • FileOutputStream
package ioframe;
import java.io.FileOutputStream;
/**
 * 文件字节输出流
 * FileOutputStream
 */
public class Demo02 {
    public static void main(String[] args) throws Exception {
        //创建文件字节输出流
        FileOutputStream fos = new FileOutputStream("e:\\aaa.txt");
        //写入文件
        //单个字符
        fos.write(97);
        fos.write('b');
        fos.write('c');
        //字符串
        String str = "hello world";
        fos.write(str.getBytes());
        //关闭
        fos.close();
        System.out.println("执行完毕");
    }
    
}

字节流复制文件

package ioframe;

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

/**
 * 使用文件字节流实现文件复制
 */
public class Demo03 {
    public static void main(String[] args) throws Exception {
        //创建流
        //文件字节输入流
        FileInputStream fis = new FileInputStream("e:\\111.jpg");
        //文件字节输出流
        FileOutputStream fos = new FileOutputStream("e:\\222.jpg");

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

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

字节缓冲流

  • 提高IO效率，减少访问磁盘的次数
  • 数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close
  • 内部维护一个8K的缓冲区

BufferedInputStream

private static int DEFAULT_BUFFER_SIZE = 8192;

package ioframe;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //创建BufferedInputStream
        FileInputStream fis = new FileInputStream("e:\\aaa.txt");
       BufferedInputStream bis =new BufferedInputStream(fis);
        //读取
        int data =0;
        while ((data=bis.read())!=-1){
            System.out.print((char)data);
        }
    }
}

BufferedOutputStream

package ioframe;
/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 */
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class Demo05 {
    public static void main(String[] args) throws Exception{
        //创建字节输出缓冲流
        FileOutputStream fos =new FileOutputStream("e:\\buffer.txt");
        BufferedOutputStream bos =new BufferedOutputStream(fos);

        //写入文件
        for (int i = 0; i <10 ; i++) {
            //没超过8K,写入缓冲区
            String str ="helloworld\r\n";
            bos.write(str.getBytes());
            //刷新到硬盘
            bos.flush();
        }
        System.out.println("写入完毕");

        //关闭（默认内部调用flush方法）
        bos.close();
    }
}

对象流

  • ObjectInputStream/ObjectOutputStream

  • 增强了缓冲区功能

  • 增强了读写8种基本数据类型和字符串功能

  • 增强了读写对象的功能

    • readObject( ) 从流中读取一个对象
    • writeObject(Object obj) 向流中写入一个对象

序列化

package ioframe;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStream实现对象的序列化（写入）
 * 要求：
 * 序列化的类必须要实现Serializable接口
 * 序列化类中的对象属性也要求实现Serializable接口
 * 序列化版本号ID:保证序列化反序列化一致性
 * 使用transient(瞬间的)修饰属性，则不可被序列化
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileOutputStream fos = new FileOutputStream("e:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //序列化（写入操作）
        //声明学生类Serializable
        Student zhangsan = new Student("张三",20);
        oos.writeObject(zhangsan);

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

反序列化

package ioframe;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
 * 使用ObjectInputStream实现反序列化（读取重构成对象）
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileInputStream fis = new FileInputStream("e:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //反序列化（读取文件）
        Student s = (Student)ois.readObject();
        //关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

编码方式

  • ISO-8859-1
  • UTF-8
  • GB2312 简体中文
  • GBK 简体中文、扩充
  • BIG5 台湾，繁体中文

字符流

字符流抽象类

  • Reader：字符输入流
  • Writer：字符输出流

文件字符流

  • FileReader
package ioframe;

import java.io.FileReader;

public class Demo08 {
    public static void main(String[] args) throws Exception{
        //创建FileReader文件字符输入流
        FileReader fr = new FileReader("e:\\hello.txt");
        //读取
        //读取单个字符
        int data = 0;
        while ((data=fr.read())!=-1){
            System.out.print((char)data);
        }
        /*
        char[] buf = new char[2];
        int count = 0;
        while ((count = fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
            
         */
        }
    }
}
  • FileWriter
package ioframe;

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

public class Demo08 {
    public static void main(String[] args) throws Exception{
        //创建FileWriter
        FileWriter fw =new FileWriter("e:\\writer.txt");
        //写入
        for (int i = 0; i <10 ; i++) {
            fw.write("java是最好的语言\r\n");
            fw.flush();
        }
        //关闭
        fw.close();
        System.out.println("执行完毕");

    }
}

字符流复制文件

package ioframe;

import java.io.FileReader;
import java.io.FileWriter;
/**
 * 使用FileReader和FileWriter复制文本，不能复制图片或者二进制文件
 */
public class Demo08 {
    public static void main(String[] args) throws Exception {
        //创建FileReader和FileWriter
        FileReader fr = new FileReader("e:\\writer.txt");
        FileWriter fw = new FileWriter("e:\\writer01.txt");

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

字符缓冲流

  • 高效读写
  • 支持换行符
  • 可一次写一行或者读一行

BufferReader

package ioframe01;

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

/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 *
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //创建缓冲流
        FileReader fr = new FileReader("e:\\writer.txt");
        BufferedReader br =new BufferedReader(fr);

        //读取文件
        /*
        char[] buf =new char[1024];
        int count=0;
        while ((count=br.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
         */
        //按行读取
        br.readLine();

        
        //关闭
        br.close();
        System.out.println("读取完毕");
    }
}

BufferWriter

package ioframe01;

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

/**
 * BufferedWriter的使用
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //创建BufferedWriter对象
        FileWriter fw = new FileWriter("e:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //写入
        for (int i = 0; i <10 ; i++) {
            bw.write("好好学习，天天向上\r\n");
            bw.flush();
        }
        //写入完毕
        System.out.println("写入完毕");
        //关闭
        bw.close();
    }
}

打印流

PrintWriter

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

import java.io.PrintWriter;

/**
 * PrintWriter的使用
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //创建打印流
        PrintWriter pw =new PrintWriter("e:\\print.txt");
        //打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

转换流

  • 桥转换流：InputStreamReader/OutputStreamWriter
  • 可将字节流转换为字符流（内存字符与硬盘字节之间）
  • 可设置字符的编码方式

InputStreamReader

package ioframe01;

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

/**
 * 使用InputStreamReader读取文件，指定使用的字符编码
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //创建
        FileInputStream fis =new FileInputStream("e:\\writer.txt");
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");
        //读取文件
        int data=0;
        while ((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //关闭
        System.out.println("写入完毕");
        isr.close();

    }
}

OutputStreamWriter

package ioframe01;

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

/**
 * 使用OutputStreamWriter的使用，使用指定的编码
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //创建
        FileOutputStream fos=new FileOutputStream("e:\\info.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");

        //写入
        for (int i = 0; i <10 ; i++) {
            osw.write("你好\r\n");
            osw.flush();
        }
        //关闭
        osw.close();
        System.out.println("执行成功");
    }
}

File类

  • 概念：代表物理符盘中的一个文件或者文件夹
  • 提供许多文件操作方法

文件操作

package ioframe01;

import java.io.File;
import java.io.IOException;
import java.util.Date;

/**
 * File类的使用
 * 1.分隔符
 * 2.文件操作
 * 3.文件夹操作
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        separator();
        fileOpe();
        directoryOpe();
    }
    //分隔符
    public static void separator(){
        System.out.println("路径分隔符:"+ File.pathSeparator);
        System.out.println("名称分隔符:"+File.separator);
    }
    //文件操作
    public static void fileOpe() throws IOException {
        //创建文件
        File file = new File("file.txt");
        System.out.println(file.toString());
        boolean b = file.createNewFile();
        System.out.println("创建结果:"+b);
        
        //删除文件
        //直接删除
        //file.delete();
        System.out.println("是否存在"+file.exists());
        //使用JVM退出时删除
        //file.deleteOnExit();

        //获取文件信息
        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());

        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
        System.out.println("是否是目录"+file.isDirectory());
    }
    //文件夹操作
    public static void directoryOpe(){
        //创建文件夹
        File dir = new File("e:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
            //dir.mkdir();//创建单级目录
            System.out.println(dir.mkdirs());//创建多级目录
        }

        //删除文件夹
        //直接删除
        System.out.println("删除结果"+dir.delete());//只删除单级子空目录
        //使用JVM删除
        dir.deleteOnExit();
        
        //获取文件夹信息
        System.out.println("获取绝对路径"+dir.getAbsolutePath());
        System.out.println("获取路径"+dir.getPath());
        System.out.println("获取文件夹名称"+dir.getName());
        System.out.println("获取父目录"+dir.getParent());
        System.out.println("获取创建时间"+new Date(dir.lastModified()).toLocaleString());
        
        //判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否是隐藏"+dir.isHidden());

        //遍历文件夹
        File dir2 = new File("e:\\图片");
        String[] files = dir2.list();
        for (String str:files
             ) {
            System.out.println(str);
        }
    }
}

FileFilter接口

  • 当调用File类中的listFiles( )方法时，支持传入FileFilter接口实现类，对获取文件进行过滤，只有满足条件的文件才可以出现在listFiles( )的返回值中
File[] file2=dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //只获取以“.jpg“结尾的文件
                if (pathname.getName().endsWith(".jpg")){
                    return true;//满足要求
                }
                return false;//不满足要求
            }
        });
        for (File file:file2
             ) {
            System.out.println(file.getName());
        }

实例

  1. 递归遍历文件夹
package ioframe01;

import java.io.File;

/**
 * 案例1
 * 递归遍历文件夹
 */
public class ListDemo {
    public static void main(String[] args) {
        listDir(new File("e:\\myfiles"));
    }
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (files!=null&&files.length>0){
            for (File file:files
                 ) {
                if (file.isDirectory()){
                    listDir(file);
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}
  1. 递归删除文件夹
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());
    }

补充：Properties

  • Properties属性集合
  1. 存储属性名和属性值
  2. 属性名和属性值都是字符串类型
  3. 没有泛型
  4. 和流有关
import java.io.FileInputStream;
import java.io.FileOutputStream;

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

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //创建集合
        Properties properties = new Properties();
        //添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());

        //遍历
        //keyset、entryset遍历
        //StringPropertyNames()
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro:pronames
             ) {
            System.out.println(pro+"======="+properties.getProperty(pro));
        }

        //和流有关的方法
        //list方法 打印
        PrintWriter pw = new PrintWriter("e:\\print.txt");
        properties.list(pw);
        pw.close();
        //store方法 保存
        FileOutputStream fos = new FileOutputStream("e:\\store.properties");
        properties.store(fos,"注释");
        fos.close();

        //load方法 加载
        Properties properties1 = new Properties();
        FileInputStream fis =new FileInputStream("e:\\store.properties");
        properties1.load(fis);
        fis.close();
    }
}
举报

相关推荐

JAVA.I/O

java

I/O流（Java）

java开发语言

Java——I/O流

java开发语言后端System数组虚拟化云计算

Java I/O流

javaJava字符流后端开发

java i o习题

Javajava输入流后端开发

Unix I/O 模型及Java I/O 模型详解

python开发语言

Java-I/O框架08：BufferedReader、BufferedWriter、PrintWriter使用

java开发语言I/O框架idea

一文讲解Socket中阻塞I/O，非阻塞I/O，I/O复用，同步I/O，异步I/O，事件驱动I/O，信号驱动I/O

unix网络服务器

java的I/O介绍

java输出流字符流Java编程语言yyds干货盘点

java中——I/O流

java
0 条评论