侧边栏壁纸
博主头像
三生石博主等级

梦想还是有的,就算做咸鱼,也要做最咸的。|

  • 累计撰写 39 篇文章
  • 累计创建 65 个标签
  • 累计收到 10 条评论

JavaIO各种流的运用

三生石
2021-04-21 / 0 评论 / 1 点赞 / 171 阅读 / 8,151 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-04-07,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

IO操作

iostream2xx

输入输出:站在程序角度,输入(Input)-读, 输出(Ouput)-写

使用FIle类操作文件或者目录

File类的常见方法

方法名说明
boolean exists()判断文件或者目录是否存在
boolean isFile()判断是否是文件
boolean isDirectory()判断是否是目录
String getPath()返回此对象表示的文件的相对路径
String getAbsolutePath()返回此对象表示的文件的绝对路径名
String getName()返回此对象表示的文件或者目录的名称
boolean delete()删除此对象指定的文件或目录
boolean createNewFile()创建名称的空文件,不创建文件夹
long leng()返回文件的长度,的那位为字节,如果文件不存在返回OL

使用字节流读写文本文件

字节输入流(读文件):

InputStream-FileInputStream-read()

FileInputSream对象的read()方法有两种方法:read()=======read(byte[])

public class test {
    public static void main(String[] args) {
        //todo 首先要引入资源
        //创建file对象写入相应路径
        File file = new File("d:/mary/demo.txt");
        //创建FileInputStream对象,先把它设置为null,以便在结束时候关闭。
        FileInputStream fileInputStream = null;
        try {
            // TODO 创建FileInputStream对象,把file对象路径赋值给FileInputStream对象,也可以赋值给一个路径。
            fileInputStream = new FileInputStream(file);

            // todo 借助FileInputStream对象的read()方法来读取文件,read()这个方法要抛出异常

            // 方法1,使用read()
//            int data;    //读取到的每个字节的整数表示形式
//            while((data = fileInputStream.read()) != -1){
//                //把data这个int类型转换成char类型才能看到字符
//                System.out.print((char)(data));
//            }

            //方法2,使用read(byte[])
            byte[] bytes = new byte[1024];
            int d;
            while((d = fileInputStream.read(bytes)) != -1){
                for (int i = 0; i<d; i++){
                    System.out.print((char)bytes[i]);
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                //todo 结束后必须close关闭流,节省资源,close()也会有异常
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
字节输出流(写文件)

OuputSteam-FileOutStream-write()

FileOutputStream这个类有两个构造,个是只添加路径或者file对象,另一个是还可以追加一个true,意思就是在原有的内容上添加新内容。

FileOutputStream写入方法 write(byte[])=====write(byte[] ,int off int len);

public class TestFileOutputStream {
    public static void main(String[] args) {
        // todo 1首先引入资源,
        // 创建file实例
        File file = new File("d:/mary/demo.txt");
        // todo 2创建FileOutputStream这个对象实例,写在外部方便关闭流
        FileOutputStream fileOutputStream = null;
        try {
            //  把file这个对象传进fileOutputStream实例
            //fileOutputStream = new FileOutputStream(file);
            // todo FileOutputStream这个类有两个构造,一个是只添加路径或者file对象,另一个是还可以追加一个true,意思就是在原有的内容上添加新内容
            fileOutputStream = new FileOutputStream(file,true);
            //创建一个String变量,
            String str = "好好学习,天天向上呀";
            //把这个String类型变量变成字节,
            byte[] strs = str.getBytes();
            // todo 3使用FileOutputStream的write这个方法把byte字节类型的变量写入文件
            fileOutputStream.write(strs,0,strs.length);
            System.out.println("ok啦");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                // todo 4最后使用完这个流,使用close()方法关闭流
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

使用字符流读写文本文件

Reder类是是字符输入流的基类-抽象类

字符输入流

Rader-InputStreamReader-FileReader-BufferedReader

FileReader

FileReader是Reader类的孙子

FileReader(File file) ==== FileReader(String name)

public class TestFileReader {
    public static void main(String[] args) {
        //    todo 1引入资源
        FileReader fileReader = null;
        try {
            //    todo 2创建FileReader对象
            fileReader = new FileReader("D:/mary/demo.txt");
            StringBuffer stringBuffer = new StringBuffer();
            char[] bytes = new char[1024];
            int i ;
            // todo 调用FileReader对象的read方法来读取文件
            while((i = fileReader.read(bytes)) != -1){
                stringBuffer.append(bytes);
            }
            System.out.println(stringBuffer);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                // todo 最后使用FileReader的close()方法关闭流
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
InputStreamReader

InputStream是reader的子类

它在创建实例时,要传进一个FileInputStream类,还可以指定编码格式

InputStreamReader(InputStream in)======InputStreamReader(InputStream in , String charsetName)

此类和FileReader一样,就是在创建时候穿的参数不同

获取本地平台的字符编码

System.out.println(System.getProperty("file.encoding"));
BufferedReder

BufferedReader是Reader的子类,创建实例时,传进Reader类,它是带有缓冲区的字符输入流,按行读取文件,提高了文件读取效率。

构造方法:BufferedReader(Reader in)

方法:readLine()

public class TestBufferedReader {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader = null;
        try {
            fileInputStream = new FileInputStream("d:/mary/demo.txt");
            inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
            bufferedReader = new BufferedReader(inputStreamReader);
            String s = null;
            while((s = bufferedReader.readLine()) != null){
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                bufferedReader.close();
                inputStreamReader.close();
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

关闭流时,后开先关

字符输出流

Writer类是字符输出流的基类-抽象类

Writer-OutpusStreamWriter-FileWriter-BufferedWriter

FileWriter

构造方法:FileWriter(File file)====FileWriter(String name) ,加Boolean的true是在原有文件追加文件

常用方法: write(String str)====write(String str, int off, int len)====void close()====void flush()

public class TestFileWrite {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        try {
            fileWriter= new FileWriter("d:/mary/demo.txt");
            String str = "Holle,world!!!";
            fileWriter.write(str);
            fileWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
OutpusStreamWriter

构造: OutputStreamWriter(OutputStream out)==== OutputStreamWriter(OutputStream out ,String charsetName)

创建这个实例时候可以指定字符编码格式,代码和FlieWrirer一样。

BufferedWriter

BufferedWriter是Writer类的子类,它带有缓冲区。

构造: BufferedWriter(Writer out) 方法:write()====newLine()===fllush()

public class TestBufferedWriter {
    public static void main(String[] args) {
        FileOutputStream fileOutputStream = null;
        OutputStreamWriter outputStreamWriter = null;
        BufferedWriter bufferedWriter = null;
        try {
            fileOutputStream = new FileOutputStream("d:/mary/demo.txt");
            outputStreamWriter = new OutputStreamWriter(fileOutputStream,"utf-8");
            bufferedWriter = new BufferedWriter(outputStreamWriter);
            bufferedWriter.write("哈哈哈哈");
            bufferedWriter.newLine();
            bufferedWriter.write("我是第二行");
            bufferedWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                bufferedWriter.close();
                outputStreamWriter.close();
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

使用字节流读写二进制文件

DataOutputStream、DataInputStream

DataOutputStream传参是FileOutputStream,DataInputStream传参是FileInputStream

其方法跟这两个是一样的。

public class TestDataInputAndOutput {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        DataInputStream dataInputStream = null;

        FileOutputStream fileOutputStream = null;
        DataOutputStream dataOutputStream = null;

        try {
            fileInputStream = new FileInputStream("d:/mary/myimg.jpg");
            dataInputStream = new DataInputStream(fileInputStream);
            fileOutputStream = new FileOutputStream("d:/mary/myqi.jpg");
            dataOutputStream = new DataOutputStream(fileOutputStream);
            int tepe;
            while ((tepe = dataInputStream.read()) != -1){
                dataOutputStream.write(tepe);
            }
            System.out.println("复制完毕");

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                dataInputStream.close();
                fileInputStream.close();
                dataOutputStream.close();
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

使用序列化和反序列化保持和恢复对象信息

ObjectOutputStream-序列化

ObjectInputStream-反序列化

在序列化对象时候,必须要把类实现Serializable接口。否则会抛出NotSerializableException异常

在反序列化对象时候,要把反序列化出来的对象强转成你自己定义的类。

在序列化和反序列化时候如果不希望某个成员变量被序列化时,可以加入transient这个关键字可以不被反序列化

public class StudentTest {
    public static void main(String[] args) {
        Student stu = new Student(1,"Mary","地球村");
        //StudentTest.serialize("d:/Student.txt",stu);
        StudentTest.deserialization("d:/Student.txt");
    }
    public static void serialize(String Path , Student stu){
        File file = new File(Path);
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream(file);
            oos = new ObjectOutputStream(fos);
            oos.writeObject(stu);
            oos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                oos.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void deserialization(String Path){
        File file = new File(Path);
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream(file);
            ois = new ObjectInputStream(fis);
            Student stu = (Student) ois.readObject();
            System.out.println(stu);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally{
            try {
                ois.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
1

评论区