IO流的总结

最新推荐文章于 2024-11-16 17:49:09 发布

小吴爱学习。。

最新推荐文章于 2024-11-16 17:49:09 发布

阅读量104

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_52493276/article/details/126486754

版权

概述：

1.File 文件操作
2.IO流

IO：input和output
System.in
System.out

3.文件流
4.处理流：

带有缓冲区的流
转换流
对象流

文件操作File类

file类：表示操作系统中的文件或文件夹
文件路径：
1.绝对路径
从磁盘根目录
C：/abc/def/a.txt
2.相对路径
相对于当前的项目
文件夹/文件

package IO.File;

import java.io.File;

public class Test {
    public static void main(String[] args) {

        try {
            //File file = new File("abc/def/吼吼吼.txt");
//            file.createNewFile();//创建一个文件，不包含文件夹

//            System.out.println(file.getParentFile());//拿到上一层文件夹的对象
//            System.out.println(file.getParent());//拿到上一层文件名
//
//            file.mkdir();//不能创建多级目录
//            file.mkdirs();//创建文件夹一定选这个，可以帮我们把上级目录创建出来
//
//            file.renameTo(new File("abc/def/吼吼吼.txt"));//重命名
//            file.delete();//删除文件



            //查看相关
//            System.out.println(file.exists());//查看文件是否存在
//
//            System.out.println(file.isAbsolute());//判断是否是绝对路径
//
//            System.out.println(file.isDirectory());//判断文件是否是文件夹
//
//            System.out.println(file.isFile());//判断文件是否是文件
//
//            System.out.println(file.length());//查看文件大小
//
//            System.out.println(file.getName());//查看文件的名字

			//完整的创建文件
            File file = new File("abc/def/吃饭.txt");
            //1.先判断上层文件夹是否存在
            File parentFile = file.getParentFile();
            if (!parentFile.exists()){
                parentFile.mkdirs();//创建上层文件夹
            }
            //2.创建文件
            file.createNewFile();


        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

IO流——节点流

在这里插入图片描述

流的分类:
1.按照读写的方向来讲，分为输入流与输出流。站在程序的角度去分析。
2.按照读写内容的单位来讲，分为字节流和字符流
3.按照流的功能l不同，分为节点流和处理流
节点流：直接连接在文件上的
处理流：套在其他流上的

lnputStream
OutputStream
Reader
Writer
抽象类

文件流：
FileInputStream 文件字节输入流= =读
FileOutputStream 文件字节输出流= =写
FileReader文件字符输入流
FileWriter文件字符输出流

如何选择流：
字符流：读取文件中的文字信息
字节流：读取非文本文件的时候

package IO.Node;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class TestFileInputStream {
    public static void main(String[] args) throws Exception {

        //创建流
        FileInputStream fis = new FileInputStream(new File("a.txt"));
//        int b = fis.read();
//        System.out.println((char) b);
//
//        int b1 = fis.read();
//        System.out.println((char) b1);
//        byte [] bs = new byte[1024];
//        int len = fis.read(bs);//返回读取了多少个字节
//
//        System.out.println(new String(bs,0,len));

        //读取文件最重要的一套写法
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len=fis.read(bytes))!=-1){
            String s = new String(bytes,0,len);
            System.out.println(s);
        }
        fis.close();
    }
}

package IO.Node;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class TestFileOutputStream {
    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream(new File("a.txt"),true);
        fos.write("谁都很帅".getBytes());

        //好习惯
        fos.flush();//清空
        fos.close();//关闭

    }
}

package IO.Node;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

public class TestFileReader {
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader(new File("a.txt"));
//       int i =  fr.read();//以字符为单位
//        System.out.println((char)i);
//
//
//        char[] cs = new char[1024];
//        int len = fr.read(cs);
//        System.out.println(new String(cs,0,len));

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


    }
}

package IO.Node;

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

public class TestFileWriter {
    public static void main(String[] args) throws Exception {
        FileWriter fw = new FileWriter(new File("a.txt"));
        fw.write("我能写字符串了，好腻害");

        fw.flush();
        fw.close();
    }
}

IO流小练习

使用IO流，把一张图片从C盘复制到D盘（附加思考：如果是剪切呢？）
字节流。

package IO.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class test {

    public static void main(String[] args) throws Exception {
        File f = new File("abcd/download.jpg");
        FileInputStream fis = new FileInputStream(f);

        FileOutputStream fos = new FileOutputStream(new File("D:\\WWWsd.jpg"));
        byte[] bs = new byte[1024];

        int len = 0;
        while ((len = fis.read(bs))!=-1){//读取数据
            fos.write(bs,0,len);//写出数据
        }
        fis.close();
        fos.flush();
        fos.close();
        
        f.delete();//剪切，相当于删除
    }
}

缓冲流

IO流
1.输入流，输出流
2.字节流，字符流
3.节点流，处理流

处理流：
1.缓冲流
2.转换流
3.对象流

缓冲流：带有缓冲区的数据流
处理流必须接到节点流上

BufferedlnputStream
BufferedOutputStream
BufferedReader-----------》重点，读取文本文件最好的一种方式
BufferedWriter

package IO.Bufferd;

import java.io.*;

public class Test {
    public static void main(String[] args) throws Exception {
        //BufferedInputStream bis = new BufferedInputStream(new BufferedInputStream(new FileInputStream(new File("a.txt"))));
        BufferedReader br = new BufferedReader(new FileReader(new File("a.txt")));
//        System.out.println(br.readLine());//是读取文本文件最好用的方法
//        System.out.println(br.readLine());
        String str = "";
        while ((str = br.readLine())!= null){
            System.out.println(str);
        }
        br.close();
    }
}

转换流

字节流—》字符流
InputStreamReader
OutputStreamWriter

Scanner sc = new Scanner（Systemm.in）

package IO.Convert;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test {
    public static void main(String[] args) throws Exception {
        //把字节流转换为字符流
        BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
        String s = br.readLine();
        System.out.println("从System.in接收到的是："+s);
    }
}

package IO.Convert;

        import java.io.IOException;
        import java.io.OutputStream;
        import java.io.OutputStreamWriter;
        import java.io.Writer;

public class Test2 {
    public static void main(String[] args) throws Exception {
        Writer writer = new OutputStreamWriter(System.out);
        writer.write("你好，我叫周润发");
        writer.flush();
        writer.close();//有时候，这个流不可以关
        System.out.println("ss" );

    }
}

对象流

ObjectInputStream
ObjectOutputStream
（Exception in thread “main” java.io.NotSerializableException: IO.obj.Person//没有序列化
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
at IO.obj.Test.main(Test.java:12)）==》发现这个异常添加实现就行

序列化：把一个对象转化成字节的过程
反序列化：把字节转化成对象
在java中只需要给类添加一个实现，Serialiable，你就是可以被序列化的一个类了

文件修改操作

把文件“唐诗三百首.txt"文件中的所有的李白替换成李太白

package IO.Update;

import java.io.*;

public class Test {
    public static void main(String[] args) throws Exception {
        File res = new File("唐诗三百首.txt");
        File another = new File("副本唐诗三百首.txt");
        BufferedReader br = new BufferedReader(new FileReader(res));

        BufferedWriter bw = new BufferedWriter(new FileWriter(another));

        String line = "";
        while ((line = br.readLine())!= null){
            line = line.replace("李白","李太白");//替换文件内容
            bw.write(line);//写入新文件
            bw.newLine();//另起一行
        }
        br.close();
        bw.flush();
        bw.close();

        //删除原文件
        res.delete();//删除文件
        another.renameTo(res);//重命名文件
    }
}

作业：

package IO.Update;

import com.sun.org.apache.bcel.internal.generic.F2D;

import java.io.*;
import java.text.DecimalFormat;

public class HomeWork {
    public static void main(String[] args) throws Exception {
        DecimalFormat df = new DecimalFormat(".00");
        //1.能从文件中读取水果信息
        
        //1.1需要创建输入流，BufferedReader
        //1.2第一行要特殊处理，第一行是表头
        File f1 = new File("fruit.txt");
        BufferedReader br = new BufferedReader(new FileReader(f1));

        File f2 = new File("副本_fruit.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(f2));

        String title = br.readLine();//第一行内容
        //写出第一行内容
        bw.write(title+"_总价");
        bw.newLine();

        //2.计算水果的总价格
        //2.1读取所有水果的信息
        String content = "";
        while((content = br.readLine())!=null){//香蕉，3.33，20
            String[] fs = content.split("_");

            double price = Double.parseDouble(fs[1]);
            double num = Double.parseDouble(fs[2]);
            double totle = price*num;//66.6
            String totleStr = df.format(totle);//“66.60”
            System.out.println(totleStr);
            content+="_"+totleStr;//拼接 香蕉_3.33_20_66.60
            bw.write(content);//向新文件写入内容
            bw.newLine();
        }
        br.close();
        bw.flush();
        bw.close();

        //3.删除源文件，重新命名新文件
        f1.delete();
        f2.renameTo(f1);


    }
}