day23IO流（字节流&字符流&操作基本数据类型的流&序列化流）&Properties集合

原创 已于 2022-02-19 21:32:58 修改 · 269 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2022-02-18 21:10:45 首次发布
这篇博客详细介绍了Java中的IO流，包括字节流（InputStream和OutputStream）、字符流（Reader和Writer）及其缓冲流，还有操作基本数据类型的DataInputStream和DataOutputStream。此外，还讨论了序列化流（ObjectOutputStream和ObjectInputStream）以及Properties集合的使用，如setProperty和getProperty方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

IO:指的是设备之间进行数据传入的流
按照流向分类：
    输入流
    输出流
按照数据类型分类：
    字节流
        A:字节输入流 InputStream
            FileInputStream:
            FileInputStream fis = new FileInputStream("读取数据的文件名");
            字节缓冲输入流：BufferedInputStream
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("读取数据的文件名"));
            //注意：这里的文件必须提前存在
        字节输入流读取数据两种方式：
            1、一次读取一个字节
            int b = 0;
            while((b=bis.read())!=-1){
                System.out.print((char)b);
            }
            bis.close();

            2、一次读取一个字节数组
            byte[] bytes = new byte[1024];
            int length = 0;
            while((length = bis.read(bytes))!=-1){
                System.out.print(new String(bytes,0,length));
            }
            bis.close();

package com.shujia.wyh.day23;


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

public class BufferedInputStreamDemo1 {
    public static void main(String[] args) throws Exception {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("g.txt"));

        //读取数据
        //一次读取一个字节
//        int b = 0;
//        while ((b=bis.read())!=-1){
//            System.out.print((char) b);
//        }

        System.out.println("======================");

        byte[] bytes = new byte[1024];
        int length = 0;
        while ((length = bis.read(bytes)) != -1) { //bis.read(bytes)调用这个方法，将实际获取到的字节存储到数组中，返回的是数组实际读取到的字节数
            System.out.println(new String(bytes, 0, length));
        }

        //释放资源
        bis.close();


    }

}

        B: 字节输出流 OutputStream
            FileOutputStream:
                FileOutputStream fos = new FileOutputStream("写文件的名字");
            字节缓冲输出流：BufferedOutputStream
                    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(写文件的名字));
            //注意：这里文件，可以不存在，之后会自动创建
        写数据的方式：bos.write()
                1、一次写一个字节
                2、一次写一个字节数组
                3、一次写一个字节数组的一部分

package com.shujia.wyh.day23;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class BufferedOuputStreamDemo1 {
    public static void main(String[] args) throws Exception {
        //BufferedOutputStream(OutputStream out)
        //创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("g.txt"));

        //一次性写一个字节数组
        bos.write("大数据".getBytes());

        bos.close();

    }
}

        FileOutputStream(String name, boolean append)
        创建文件输出流以指定的名称写入文件。
        true表示的是可以追加写入数据

package com.shujia.wyh.day22;

import java.io.FileOutputStream;

public class FileOutputStreamDemo3 {
    public static void main(String[] args) throws Exception {
        //FileOutputStream(String name, boolean append)
        //创建文件输出流以指定的名称写入文件。
        //true表示的是可以追加写入数据
        FileOutputStream fos = new FileOutputStream("e.txt", true);
        fos.write("今天下雪了\r\n".getBytes());
        fos.write("但是没有看到积雪".getBytes());

        //释放资源
        fos.close();
    }
}

    字符流（转换流） = 字节流 + 编码表
        A: 字符输入流    Reader
            InputStreamReader:
            InputStreamReader isr = new InputStreamReader(new FileInputStream("读取数据的文件名"));
            简化写法：FileReader
                FileReader fr = new FileReader("读取数据的文件名");
            普通字符输入流读取数据两种方式：
                1、一次读取一个字符
                    int ch = 0;
                    while((ch = fr.read())!=-1){
                        System.out.print((char) ch);
                    }
                    fr.close();
                2、一次读取一个字符数组
                    char[] chars = new char[1024];
                    int length = 0;
                    while((length = fr.read(chars))!=-1){
                        System.out.print(new String(chars,0,length));
                    }
                    fr.close();

package com.shujia.wyh.day23;

import java.io.FileInputStream;
import java.io.InputStreamReader;
public class InputStreamReaderDemo2 {
    public static void main(String[] args) throws Exception {
        //1、创建字符输入流对象
        FileReader fr = new FileReader("e.txt");

        //一次只读一个字符
        //字符读取，如果已经达到流的结尾，则为-1
//        int i = 0;
//        while ((i=fr.read())!=-1){
//            System.out.print((char) i);
//        }

        //一次读取一个字符数组
        //读取的字符数，如果已经达到流的结尾，则为-1
        char[] chars = new char[1024];
        int length = 0;
        while ((length = fr.read(chars)) != -1) {
            System.out.print(new String(chars, 0, length));
        }


        //释放资源
        isr.close();

    }
}

            字符缓冲输入流：BufferedReader
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("读取数据的文件名")));
            BufferedReader br = new BufferedReader(new FileReader("读取数据的文件名"));
                字符流读取数据的第三种方式：一次读取一行 readLine()
                String s = null;
                while((s = br.readLine())!=null){
                    System.out.print(s);
                }
                br.close();

package com.shujia.wyh.day23;

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

public class BufferedReaderDEmo1 {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        String s = null;
               while((s = br.readLine())!=null){
                   System.out.print(s);
               }


        //释放资源
        br.close();
    }
}

        B: 字符输出流 Writer
            OutputStreamWriter:
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("写文件的名字"));
            简化写法：FileWriter
                FileWriter fw = new FileWriter("写文件的名字");

            写数据的方式：fw.write()
                一次写一个字符
                一次写一个字符数组
                一次写一个字符数组的一部分
                一次写一个字符串
            字符缓冲输出流：BufferedWriter
            BufferedWriter bw = new BufferedWriter(new FileWriter("写文件的名字"));

package com.shujia.wyh.day23;

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

public class BufferedWriterDemo1 {
    public static void main(String[] args) throws Exception {
        BufferedWriter bw = new BufferedWriter(new FileWriter("a2.txt"));

        bw.write("hello");
        bw.write("world");

        bw.flush();

        //释放资源
        bw.close();

    }
}

            字符流特殊的写数据方法：
                newLine() 写一个换行符，根据系统不同，这里换行符也是不一样的。

       flush()和close()的区别：
        1、调用完flush()后，流对象并没有关闭，还能继续写数据。
        2、调用完close()后，流对象关闭了，后续无法再通过这个对象写数据。

        例：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

package com.shujia.wyh.day23;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class CopyFileDemo4 {
    public static void main(String[] args) throws Exception {
        //1、创建字符缓冲输入流对象和字符缓冲输出流对象
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("b2.txt"));

        //一次读写一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while ((length= br.read(chars))!=-1){
            bw.write(chars,0,length); //直接写出不需要强转
            bw.flush();
        }

        //释放资源
        bw.close();
        br.close();

    }
}

操作基本数据类型的流

DataInputStream

DataOutputStream

注：读的顺序与写顺序一致

package com.shujia.wyh.day24;

import java.io.*;

public class DataInputStreamDemo1 {
    public static void main(String[] args) throws IOException {
//        write();
        read();
    }

    private static void read() throws FileNotFoundException, IOException {
        DataInputStream dis = new DataInputStream(new FileInputStream("b3.txt"));
        byte b = dis.readByte();
        System.out.println(b);
        short s = dis.readShort();
        System.out.println(s);
        int i = dis.readInt();
        System.out.println(i);
        long l = dis.readLong();
        System.out.println(l);
        float f = dis.readFloat();
        System.out.println(f);
        double d = dis.readDouble();
        System.out.println(d);
        char ch = dis.readChar();
        System.out.println(ch);
        boolean bb = dis.readBoolean();
        System.out.println(bb);
        dis.close();
    }

    private static void write() throws IOException {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                "dos.txt"));
        dos.writeByte(1);
        dos.writeShort(20);
        dos.writeInt(300);
        dos.writeLong(4000);
        dos.writeFloat(12.34f);
        dos.writeDouble(12.56);
        dos.writeChar('a');
        dos.writeBoolean(true);
        dos.close();
    }


}

序列化流

        序列化：把对象按照流一样的方式存到文本文件或者数据库或者在网络中传输
            对象 -- 流数据: ObjectOutputStream
        反序列化：把文本文件中的流对象数据或者网络中的流数据还原成一个对象
            流数据 -- 对象: ObjectInputStream

            serialVersionUID 不允许出现多次插入相同的数据

            transient 序列化过程中选择哪些成员不被序列化

package com.shujia.wyh.day24;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectStringDemo {
    public static void main(String[] args) throws Exception{
        //写方法，将对象存入到文件中，其实就是将对象进行持久化
//        write();

        //读方法：把文本文件中的流对象数据或者网络中的流数据还原成一个对象
        read();
    }

    public static void read() throws Exception{
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

        Object object = ois.readObject();

        System.out.println(object);

        //释放资源
        ois.close();
    }

    public static void write() throws Exception{
        //创建对象输出流对象
        //ObjectOutputStream(OutputStream out)
        //创建一个写入指定的OutputStream的ObjectOutputStream。
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

        //创建一个对象
        Person p1 = new Person("小周", 18);

        oos.writeObject(p1);


        //释放资源
        oos.close();

    }
}

class Person implements Serializable {
    private static final long serialVersionUID = 2880662336900677170L;
    private String name;
    private transient int age;


    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.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;
    }

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

Properties集合

Properties的特殊功能

        public Object setProperty(String key,String value)

        public String getProperty(String key)

package com.shujia.wyh.day24;

import java.util.Properties;

public class PropertiesDemo {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.setProperty("user", "root");
        properties.setProperty("password", "123456");

        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        System.out.println(user + "--" + password);


    }
}

qnmdlzg
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值