Java IO流

最新推荐文章于 2022-08-31 20:55:44 发布

luci Aristide 哎

最新推荐文章于 2022-08-31 20:55:44 发布

阅读量88

点赞数

分类专栏： Java-IO流文章标签： java

本文链接：https://blog.csdn.net/break_umbrella/article/details/112371635

版权

Java-IO流专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细介绍了Java IO流的各类操作，包括文件字节输入/输出流、缓冲流、对象序列化与反序列化、File类的使用以及文件复制等。通过实例展示了如何读取、写入文件，以及如何利用缓冲提高效率。同时涵盖了字符流的使用，如FileReader、FileWriter以及打印流等。此外，还涉及到File类的方法，如创建、删除文件及目录，以及递归遍历文件夹。最后提到了Properties集合的读写操作。

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

要点

1.io流分为字节流和字符流
字节流可以传输所有数据
字符流只能传输文本数据
2.流是内存与存储设备之间传输数据的通道
（例子自来水）
3.输入流：将存储设备中的内容读取到内存中(以内存为参照物）
4.输出流：将内存中的数据写入到存储设备中(以内存为参照物）
5.节点流：具有实际传输数据的功能
6.过滤流：在节点流的基础上增强功能
7.字节输入流的的父类：InputStream
8.字节输入流的的父类：OutputStream
9.缓冲流
10.序列化与反序列化
11. File类方法

1. 文件字节输入流（FileInputStream)

import java.io.FileInputStream;

public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileInputStream
       FileInputStream fis=new FileInputStream("d:\\aaa.txt");
       //2.读取文件
        /*int data=0;
        while ((data=fis.read())!=-1){
            System.out.println((char)data);
            // 关闭
        }
        */
        //一次读取多个字节
        byte[]bytes=new byte[5];
        /*int count=fis.read(bytes);
        System.out.println(count);
        System.out.println(new String(bytes));

        int count2= fis.read(bytes);
        System.out.println(count2);
        System.out.println(new String(bytes));

         */
      int count=0;
      while ((count=fis.read(bytes))!=-1){
          System.out.println(new String(bytes,0,count));
      }

        fis.close();
        System.out.println("执行完毕");

    }
}

2. 文件字节输出流（FileOutputStream)

import java.io.FileOutputStream;

/**
 * FileOutputStream
 * @author luci
 */
public class Demo02 {
    public static void main(String[] args) throws Exception {
        //1.创建文件字节输出流对象FileOutputStream
        FileOutputStream fos=new FileOutputStream("d:\\bbb.txt");
        //2.写入文件
        fos.write(97);
        fos.write('b');
        fos.write('c');
        String s="hello";
        fos.write(s.getBytes());
        //关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

3. 字节传输文件复制（边读取编写）

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

public class Demo03 {
    public static void main(String[] args) throws Exception{
        //创建流
        //文件字节输入流
        FileInputStream fis=new FileInputStream("d:\\1.gif");
        //文件字节输出流
        FileOutputStream fos=new FileOutputStream("d:\\2.gif");
        //2.实现复制
        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("执行完毕");

    }
}

4.使用缓冲流读取BufferedInputStream

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

/**
 * 使用缓冲流读取
 * BufferedInputStream
 * @author luci
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
   //1.创建BufferedIuputStream
        FileInputStream fis=new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //2.读取
        int data=0;
        while ((data=bis.read())!=-1){
            System.out.println((char)data);
        }
        //3.关闭
        bis.close();

    }
}

5.使用缓冲流写入BufferedOutputStream

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

/**
 * 使用缓冲流写入
 * BufferedOutputStream
 * @author luci
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //创建文件字节输出流
        // 创建BufferedOutputStream
        FileOutputStream fos=new FileOutputStream("d:\\buf.txt");
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("hello".getBytes());// 小于8k写入缓冲区
            bos.flush();;
        }
        //关闭
        bos.close();
    }
}

6.使用ObjectOutputStream实现对象的序列化

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

/**
 * 使用ObjectOutputStream实现对象的序列化
 * 注意事项：
 * 序列化的类必须实现Serilizable接口
 * 序列化的类中的对象属性（内部类）必须实现Serilizable接口
 * 序列化版本号ID，保证序列化的类和反序列化的类是同一个类(是通过serialVersionUID标识来判断)
 * 使用transient（瞬间地）修辞属性，这个属性不能序列化
 * 静态属性不能被序列化
 * 序列化多个对象可以借助集合
 * @author luci
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos=new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //2.实现序列化（写入操作）
        Student name=new Student("张三",20);
        Student name1=new Student("李氏",20);
        ArrayList<Student>list=new ArrayList<>();
        list.add(name);
        list.add(name1);
        //oos.writeObject(name);
        //oos.writeObject(name1);
        oos.writeObject(list);


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

7.使用ObjectInputStream实现对象的反序列化

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


/**
 * 使用ObjectInputStream实现反序列化（读取重构成对象）
 * @author luci
 */
public class Demo07 {
    public static void main(String[] args) throws  Exception{
        //1.创建对象流
        FileInputStream fis=new FileInputStream("D:\\stu.bin");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //反序列化（读取文件）
       // Student s=(Student)ois.readObject();
        //Student s2=(Student)ois.readObject();//( private transient int age;通过transient修饰了age，这个age不能序列化了）
        ArrayList<Student>list =(ArrayList)ois.readObject();
        //关闭
        ois.close();
        System.out.println("反序列化");
       // System.out.println(s);
      //  System.out.println(s2);
        System.out.println(list.toString());

    }
}

8.需要调用的类（student）

package com.f.www.Stream;

import java.io.Serializable;

/**
 * Student类
 * @author luci
 */
public class Student implements Serializable {
   private static final long serialVersionUID=100L;
    private String name;
    private transient int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

9.文件字符输入流FileReader

/**
 * 使用FileReader
 * @author luci
 */

import java.io.FileReader;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //1.创建FileReader 文件字符输入流
        FileReader fr=new FileReader("D:\\hello.txt");
        //2.读取
        System.out.println("单个读取--------");
        int data=0;
        while((data=fr.read())!=-1) {//读取一个字符
            System.out.println((char)data);
        }
        char[]buf=new char[1024];
        int count=0;
        while ((count= fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fr.close();

    }
}

10.文件字符输出流FileWriter

import java.io.FileWriter;

/**
 * FileWriter
 * @author luci
 */
public class Demo02 {
    public static void main(String[] args)throws Exception {
        //1.创建FileWriter对象
        FileWriter fw=new FileWriter("d:\\good.txt");
        //写入
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界最好的语言\n");
            fw.flush();
        }
        //3.关闭
        fw.close();
        System.out.println("执行完毕");

    }
}

10.字符传输文件复制

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

/**
 *  使用FileReader和FileWrite复制文本文件，不能复制图片和其他二进制文件
 *  字节流可以复制任意文件
 * @author luci
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1. 创建流
        FileReader fr=new FileReader("d:\\write1.txt");
        FileWriter fw=new FileWriter("d:\\write2.txt");
        //读写
        int data=0;
        while ((data=fr.read())!=-1){
            fw.write(data);
        }
        //关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");



    }
}

10.使用字符缓冲流读取文件BufferedReader

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

/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 * @author luci
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //创建缓冲流
        FileReader fr=new FileReader("d:\\good.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));
        }
        */
        //2.一行一行的读

        String line=null;
        while ((line=br.readLine())!=null){
            System.out.println(line);

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

11.使用字符缓冲流写入文件BufferedWriter

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

/**
 * BufferedWriter
 * @author luci
 */
public class Demo05 {
    public static void main(String[] args)throws Exception {
        //创建BUfferedWriter对象
        FileWriter fw=new FileWriter("d:\\write11.txt");
        BufferedWriter bfw=new BufferedWriter(fw);
        //写入
        int  count=0;
        for (int i = 0; i < 10; i++) {
            bfw.write("加油赚钱\r\n");
            bfw.newLine();
        }
        bfw.close();
        System.out.println("写入完毕");

    }
}

12.打印流PrintWriter

import java.io.PrintWriter;

/**
 * PrintWriter
 * @author luci
 */
public class Demo06 {
    public static void main(String[] args)throws Exception {
        //1.创建打印流
        PrintWriter pw=new PrintWriter("d:\\PW0.txt");
        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(2.14);
        pw.println('a');
        pw.println("111");
        //关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

13. 使用InputStreamReader读取文件

InputStreamReader：从字节到字符的桥梁

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

/**
 * 使用InputStreamReader读取文件，可以指定编码
 * @author luci
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建
        FileInputStream fis=new FileInputStream("d:\\write1.txt");
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");
        //2.读取文件
        int data=0;
        while ((data= isr.read())!=-1){
            System.out.println((char)data);
        }
        isr.close();
        System.out.println("读取完毕");

    }
}

13. 使用OutputStreamWriter写入文件

OutputStreamWriter是从字符流到字节流的桥接：使用指定的字符集将写入其中的字符编码为字节。它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集

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

/**
 * 使用OutputStreamWriter写入文件，使用指定的编码
 * @author luci
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建OutputStreamWriter
        FileOutputStream fos=new FileOutputStream("D:\\OSW1.TXT");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
        //2.写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱中国\r\n");
        }
        //3.关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

14. File 类

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

/**
 * File 类
 * @author luci
 */
public class Demo03 {
    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 {
        //2.1创建文件 ceeateNewFile
        File file = new File("d:\\file01.txt");
        System.out.println(file.toString());
        if (!file.exists()) {
            boolean b = file.createNewFile();
            System.out.println("创建结果:" + b);
        }
        //2.2删除文件
        System.out.println(file.delete()+"删除结果");
        //2.3使用jvm退出时删除
        file.deleteOnExit();
        Thread.sleep(5000);
        //2.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());
        //2.4判断
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());
    }
    //3.文件夹操作
    public static void directoryOpe ()throws Exception{
        //3.1创建文件夹
        File dir=new File("d:\\a\\b\\c");
        System.out.println(dir.toString());
        if (!dir.exists()){

            System.out.println("创建结果："+dir.mkdirs());//创建多级目录);
        }
        //3.2删除文件夹
        System.out.println("删除结果"+dir.delete());//只能删除最里层空目录
        dir.deleteOnExit();//使用jvm退出删除
        Thread.sleep(5000);//休眠5秒钟
        //3.3获取文件夹信息
        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());
        //3.4判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否隐藏"+dir.isHidden());
        //3.5遍历
        System.out.println("-----------");
        File dir2=new File("C:\\Users\\luci\\Pictures\\Saved Pictures");
        String[]b=dir2.list();
        for (String s:b
             ) {
            System.out.println(s);
        }
        System.out.println("FileFilter接口的使用-------------");
        File[] f=dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                if(file.getName().endsWith(".jpg")) {
                    return true;
                }
                return false;
            }
        });
        for (File file:f
             ) {
            System.out.println(file.getName());

        }

    }
}

15. 递归遍历文件夹,递归删除文件夹

import java.io.File;

/**
 * 递归遍历文件夹
 * 递归删除文件夹
 * @author luci
 */
public class ListDemo04 {
    public static void main(String[] args) {
        //递归显示文件夹
        listdir(new File("d:\\迅雷下载"));
    }
    public static void listdir(File dir){
        File[]files=dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if(files!=null&&files.length>0){
            for (File f:files
                 ) {if (f.isFile()){
                     listdir(f);
            }else {
                System.out.println(f.getAbsolutePath());
            }

            }
        }
    }
    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());//删除目录
    }
}

16.properties集合使用

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

/**
 * properties集合使用
 * @author luci
 */
public class propertiesDemo01 {
    public static void main(String[] args) throws Exception{
        //1.创建集合
        Properties properties=new Properties();
        //2.添加数据
        properties.setProperty("name","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties);
        //3.StringProrpertyNames()
        Set<String>propertyNames=properties.stringPropertyNames();
        for (String pro:propertyNames
            ) {
            //System.out.println(pro+"--"+properties.getProperty(pro));
        }
 //       //4.通过流打印储存
     //      PrintWriter pw=new PrintWriter("D:\\PR01.TXT");
  //      properties.list(pw);
  //      pw.close();
 //       System.out.println("执行完毕");
        //5.stotr方法储存
        FileOutputStream fos=new FileOutputStream("d:\\print.properties");
        properties.store(fos,"注释");
        fos.close();
        //6.load加载
        Properties properties2=new Properties();
        FileInputStream fis=new FileInputStream("d:\\print.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2);
    }
}