十一 Java的IO流

原创 已于 2022-04-14 18:37:06 修改 · 1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2022-04-14 18:35:09 首次发布

文章目录

学习视频：https://www.bilibili.com/video/BV15B4y1u7Rn

文件

概念

  • 文件：保存数据的地方
  • 文件流：文件在程序中是以流的形式来操作的

image-20220309162727717

  • 流：数据在数据源(文件)和程序(内存)之间经历的路径
    • 输入流：数据从数据源(文件)到程序(内存)的路径
    • 输出流：数据从程序(内存)到数据源(文件)的路径

常用操作

image-20220309163847035

构造方法

方法说明
File(File parent, String child)从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File(String parent, String child)从父路径名字符串和子路径名字符串创建新的 File实例。
File(URI uri)通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

获取文件信息

File file = new File("D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\news1.txt");
System.out.println("文件名字" + file.getName());
System.out.println("绝对路径" + file.getAbsolutePath());
System.out.println("文件父级目录" + file.getParent());
System.out.println("文件大小(字节数)"+file.length());//utf-8 一个英文字符一个字节 一个汉字字符对应三个
System.out.println("文件是否存在"+file.exists());
System.out.println("文件是否是一个文件"+file.isFile());
System.out.println("文件是否是一个文件夹"+file.isDirectory());

查看文件的编码方式:

image-20220309165457060

不同编码方式中英文所占的字节数

编码方式英文中文
GB231212
GBK12
GB1803012
ISO-8859-111
UTF-813
UTF-1644

目录操作

  • mkdir 创建一级目录
  • mkdirs 创建多级目录
  • delete 删除文件或空目录
//判断文件是否存在，存在就删除，否则提示不存在
String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\news1.txt";
File file = new File(filePath);
if (file.exists()) {
    if(file.delete()) {
        System.out.println("文件删除成功");
    }else {
        System.out.println("文件删除失败");
    }
}else{
    System.out.println("该文件不存在");
}

//判断目录是否存在，存在就删除，否则提示不存在
String filePath2 = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\demoDir";
File file2 = new File(filePath2);
if (file2.exists()) {
    if(file2.delete()) {
        System.out.println("目录删除成功");
    }else {
        System.out.println("目录删除失败");
    }
}else{
    System.out.println("该目录不存在");
}

//判断多级目录是否存在，否则创建多级目录
String filePath3 = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\a\\b\\c";
File file3 = new File(filePath3);
if (file3.exists()) {
    System.out.println("该多级目录存在");
}else{
    if(file3.mkdirs())
    {
        System.out.println("创建成功");
    } else {
        System.out.println("创建失败");
    }
}

IO流原理及流的分类

IO流原理

  1. I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等。
  2. Java程序中，对于数据的输入/输出操作以”流(stream)”的方式进行
  3. java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据
  4. 输入input:读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。
  5. 输出output:将程序(内存)数据输出到磁盘、光盘等存储设备中

image-20220310164346264

流的分类

  • 按操作数据单位不同分为：字节流(8 bit) 适合操作二进制文件（声音，word），字符流(按字符) 文本文件，其中不同文件编码类型字符所占字节个数不同
  • 按数据流的流向不同分为：输入流，输出流
  • 按流的角色的不同分为：节点流，处理流/包装流
（抽象基类）字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter
  1. Java的I0流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。
  2. 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

常用的类

JavaIO流体系图

IO流体系图

字节流

举例: FileInputStream字节输入流

  • InputStream抽象类是所有类字节输入流的超类
  • 常用子类
    • FileInputStream 文件输入流
    • BufferedInputStream 缓冲字节输入流
    • ObjectInputStream 对象字节输入流
image-20220310170448727

FileInputStream

常用方法

image-20220315193315491

代码示例：read() 方法

//read()方法 一次从输入流中读取一个字节的数据 单字节读取
public void readFile01(){
    //读文件
    File file = new File("D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\hello.txt");
    FileInputStream fileInputStream =null;
    try {
        //创建FileInputStream对象
        fileInputStream = new FileInputStream(file);
        //read:从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。
        //数据的下一个字节，如果达到文件的末尾， 返回-1 。读一个字节，如果中文，有可能不止一个字节，会乱码
        int read=-1;
        while((read = fileInputStream.read())!=-1)
        {
            System.out.print((char) read);//转成char显示
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        //关闭文件流，释放资源
        try {
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码示例 read(byte[] b)

public void readFile02(){
    //读文件
    String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\hello.txt";
    //字节数组
    byte[] buf = new byte[8];//一次读8个字节
    int readLen = 0;//一次读取的字节长度
    FileInputStream fileInputStream =null;
    try {
        //创建FileInputStream对象
        fileInputStream = new FileInputStream(filePath);
        //read(byte[] b):从该输入流读取最多b.length字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。
        //返回值: 读入缓冲区的总字节数，如果没有更多的数据，因为文件的结尾已经到达， -1 。
        //乱码可能：缓冲区边界的一个中文字符拆成了多个字节
        while((readLen=fileInputStream.read(buf))!=-1)
        {

            System.out.print(new String(buf,0,readLen));//显示
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        //关闭文件流，释放资源
        try {
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileOutputStream

image-20220315194321041

常用方法

image-20220315193238083

代码示例

/**
 * 演示使用FileOutputStream将数据写到文件中，
 * 如果该文件不存在，则创建该文件
 */
@Test
public void writeFile(){

    File file = new File("D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\news4.txt");
    FileOutputStream fileOutputStream = null;
    try {
        //创建FileOutputStream 对象
        //new FileOutputStream(file); 覆盖写
        //new FileOutputStream(file,true); 构造器后面的一个参数append设置为true,不覆盖原来的数据，追加写
        fileOutputStream = new FileOutputStream(file);

        //写入一个字节
        fileOutputStream.write('a');//char自动转换int
        //写入字符串
        String str = "QWER";
        //str.getBytes() 可以把字符串转换为字节数组
        fileOutputStream.write(str.getBytes());
        /*
        write(byte[] b, int off, int len)
        将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
         */
        fileOutputStream.write(str.getBytes(),1,str.length()-1);

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

作业

完成英语文件的拷贝

/*
完成音乐的拷贝
音乐位置: D:\programme\javaProject\java_base\code\JavaSE\基础语法\src\com\textFile\LoveStory.m4a
拷贝位置: D:\programme\javaProject\java_base\code\JavaSE\基础语法\src\com\textFile\music.m4a
 */
public class Demo06_FileInputStream_FileOutputStream_exercise {

    public static void main(String[] args) {
        String inputPath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\LoveStory.m4a";
        FileInputStream fileInputStream = null;
        String outputPath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\music.m4a";
        FileOutputStream fileOutputStream = null;
        int len = 0;
        byte[] buffer = new byte[256];
        try {
            fileInputStream = new FileInputStream(inputPath);
            fileOutputStream = new FileOutputStream(outputPath);//如果是c盘可能需要管理员权限
            while ((len = fileInputStream.read(buffer)) != -1){
                fileOutputStream.write(buffer);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(fileInputStream!=null)
                    fileInputStream.close();
                if(fileOutputStream!=null)
                    fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符流

FileReader和 FileWriter是字符流，即按照字符来操作io。

FileReader

下方为FileReader的继承关系类图，继承InputStreamReader

image-20220321135243399

相关方法

方法说明
new FileReader(File/String)构造方法
read()每次读取单个字符（一个汉字算一个字符），返回该字符，如果到文件末尾返回-1
read(char[])批量读取多个字符到数组，返回读取到的字符数,如果到文件末尾返回-1

字符数组转换为字符串处理的相关API：

new String(char) ： 将char[]转换成String
new String(char[],off,len)：将char[的指定部分转换成String

代码示例1：使用read()读取文件

String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\story.txt";
FileReader fileReader = null;
int data = 0;
//1.创建FileReader对象
try {
    fileReader = new FileReader(filePath);
    //循环的读取 使用reader方法读取
    while ((data= fileReader.read())!=-1)
    {
        System.out.print((char)data);
    }

} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fileReader != null) {
        try {
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码示例2：使用read(char[])读取

String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\story.txt";
FileReader fileReader = null;
char[] buf = new char[256];
int bufLen = 0;
try {
    fileReader = new FileReader(filePath);
    while((bufLen=fileReader.read(buf))!=-1)
    {
        System.out.print(new String(buf,0,bufLen));
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fileReader != null) {
        try {
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileWriter

image-20220321140329443

常用方法

方法说明
new FileWriter(File/String)构造方法，覆盖模式，相当于流的指针在首端
new FileWriter(Fiie/String , true)构造方法，追加模式，相当于流的指针在尾端
write(int)写入单个字符
write(char[])写入指定数组
write(char[],off,len)写入指定数组的指定部分
write (string)写入整个字符串
write(string,off, len)写入字符串的指定部分

字符串转换为字符数组处理的相关API：

String类的toCharArray:将String转换为char[]

⭐️注意:
FileWriter使用后，必须要关闭(close)或刷新(flush)，否则写入不到指定的文件!

代码示例

String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\fileWriter.txt";
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(filePath,true);
//            | write(int)             | 写入单个字符           |
            fileWriter.write('H');
//            | write(char[])            | 写入指定数组           |
            char[] chars = {'1', 'a', '中'};
            fileWriter.write(chars);
//            | write(char[],off,len)  | 写入指定数组的指定部分 |
            fileWriter.write("科比no.1".toCharArray(),0,2);
//            | write (string)         | 写入整个字符串         |
            fileWriter.write("库里no.1");
//            | write(string,off, len) | 写入字符串的指定部分   |
            fileWriter.write("詹姆斯no.1",0,3);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //对于FileWriter，一定要关闭流，只有在close或者flush才能真正地把数据写入到文件中
            try {
                fileWriter.close();//等价于flush() + 关闭流
                //fileWriter.flush();
            /*
            两个方法源码最终调用了OutputStream的writeBytes方法
            private void writeBytes() throws IOException {
                bb.flip();
                int lim = bb.limit();
                int pos = bb.position();
                assert (pos <= lim);
                int rem = (pos <= lim ? lim - pos : 0);

                    if (rem > 0) {
                if (ch != null) {
                    if (ch.write(bb) != rem)
                        assert false : rem;
                } else {
                    out.write(bb.array(), bb.arrayOffset() + pos, rem);
                }
                }
                bb.clear();
                }
             */
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

节点流和处理流

基本介绍

  • 节点流可以从一个特定的数据源读写数据，如FileReader、 FileWriter。

    image-20220321144705593

  • 处理流(也叫包装流)是“连接”在已存在的流（节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter

    image-20220321144733929

  • 节点流和处理流一览图

    image-20220321144845884

辅助理解包装流：以BufferedReader为例

BufferedReader类中，有属性Reader，即可以封装一个节点流，该节点流可以是任意的，只要是Reader子类。（装饰者模式）

image-20220321150133541

区别和联系

  1. 节点流是底层流/低级流,直接跟数据源相接。

  2. 处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提

    供更方便的方法来完成输入输出。

  3. 处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接

    与数据源相连[模拟修饰器设计模式]

模拟代码（模拟修饰器设计模式）

public class Demo09_Decorator {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
        bufferedReader_.readFiles(10);
        bufferedReader_.readFile();

        //通过bufferReader_ 多次读取字符串
        BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
        bufferedReader_1.readStrings(10);
    }
}

abstract class Reader_ {
    public void readFile(){

    }
    public void readString(){

    }
    //也可以将readFile和readString写成一个抽象方法，利用动态绑定机制
}
//模拟节点流
class FileReader_ extends Reader_ {
    public void readFile(){
        System.out.println("对文件进行读取..");
    }
}
//模拟字符流
class StringReader_ extends Reader_ {
    public void readString(){
        System.out.println("读取字符串..");
    }
}
//模拟包装流
class BufferedReader_ extends Reader_ {
    private Reader_ reader_;

    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }

    public void readFile(){//封装一层
        reader_.readFile();
    }

    //让方法更加灵活,多次读取文件.或者加缓冲char[] ...
    public void readFiles(int num){
        for (int i = 0; i < num; i++) {
            reader_.readFile();
        }
    }
    //扩展readString,批量处理字符串数据
    public void readStrings(int num){
        for (int i = 0; i < num; i++) {
            reader_.readString();
        }
    }
}

根据示例代码也不难理解处理流的两个主要方面的功能

  • 性能的提高：主要以增加缓冲的方式来提高输入输出的效率。
  • 操作的便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据,使用更加灵活方便

处理流讲解

  • BufferedReader 和 BufferedWriter属于字符流，是按照字符来读取数据的
  • BufferedInputStream 和 BufferedInputStream是字节流，是按照字节来读取数据的
  • 关闭处理流时，只需要关闭外层流即可，关闭处理流包含关闭节点流。

BufferedReader和BufferedWriter

代码示例一: 读取文本文件

//使用BufferedReader读取文本文件，并显示在控制台
    public static void main(String[] args) throws Exception {
        String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\hello.txt";
        //创建bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        /* 说明；
        1. bufferedReader.readLine();//按行读取
        2. 当返回null时，表示文件读取完毕
         */
        String line;
        while ((line = bufferedReader.readLine())!=null){
            System.out.println(line);
        }
        //关闭流 只需要关闭包装流，底层自动关闭节点流
        bufferedReader.close();
        /* 源码
        private Reader in;

        public void close() throws IOException {
            synchronized (lock) {
                if (in == null)
                    return;
                try {
                    in.close();
                } finally {
                    in = null;
                    cb = null;
                }
            }
        }
         */

    }
}

代码示例二：写文本文件

public static void main(String[] args) throws IOException {
    String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\news2.txt";
    //创建BufferedWriter
    //说明 new FileWriter(filePath,true)  追加写
    //说明 new FileWriter(filePath)  覆盖写
    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
    bufferedWriter.write("hello,world1");
    bufferedWriter.newLine();//插入一个和系统相关的换行
    bufferedWriter.write("hello,world2");
    bufferedWriter.write("hello,world3");

    //说明：关闭外层流会自动关闭内部流
    bufferedWriter.close();
}

示例代码三： 复制文本文件

public static void main(String[] args) {
    //BufferedReader 和 BufferedWriter 是按照字符操作
    //不要去操作二进制文件，可能造成文件损坏 
    String srcFilePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\folder1\\1.txt";
    String destFilePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\folder1\\2.txt";
    BufferedReader bufferedReader = null;
    BufferedWriter bufferedWriter = null;
    try {
        bufferedReader = new BufferedReader(new FileReader(srcFilePath));
        bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
        //说明
        String line;
        while ((line=bufferedReader.readLine())!=null){
            //每读取一行，就写入
            bufferedWriter.write(line);
            //插入一个换行符
            bufferedWriter.newLine();
        }
        System.out.println("拷贝完成");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            //关闭流
            if(bufferedReader!=null)
                bufferedReader.close();
            if(bufferedWriter!=null)
                bufferedWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedInputStream和BufferedOutputStream

  • BufferedlnputStream是字节流，在创建BufferedlnputStream时，会创建一个内部缓冲区数组

    image-20220325151933081

  • BufferedOutputStream是字节流，实现缓冲的输出流,可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

    image-20220325152323209

代码示例：完成二进制文件的拷贝

public static void main(String[] args) {
    String srcFilePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\LoveStory.m4a";
    String destFilePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\buffer.m4a";
    BufferedInputStream bi = null;
    BufferedOutputStream bo = null;
    try {
        bi = new BufferedInputStream(new FileInputStream(srcFilePath));
        bo = new BufferedOutputStream(new FileOutputStream(destFilePath));
        byte[] buffer = new byte[1024];
        int len ;
        while ((len = bi.read(buffer))!=-1){
            bo.write(buffer,0,len);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(bi!=null){
                bi.close();
            }
            if(bo!=null){
                bo.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

对象处理流：ObjectInputStream和ObjectOutputStream

需求：(保存数据的值和相应的数据类型)

  1. 将int num = 100这个int数据保存到文件中，注意不是100数字，而是int 100，并且，能够从文件中直接恢复int 100
  2. 将Dog dog = new Dog(“小黄”，3)这个dog对象保存到文件中，并且能够从文件恢复。
  3. 上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作

序列化和反序列化

  1. 序列化就是在保存数据时,保存数据的值和数据类型
  2. 反序列化就是在恢复数据时，恢复数据的值和数据类型。
  3. 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:

​ Serializable//这是一个标记接口,没有方法

​ Externalizable//该接口有方法需要实现，一般使用上面的方法

功能

  1. 提供了对基本类型或对象类型的序列化和反序列化的方法
  2. ObjectOutputStream提供序列化功能
  3. ObjectlnputStream提供反序列化功能

image-20220410105502023

image-20220410105606273

代码示例一

题目描述：使用ObjectOutputStream 序列化基本数据类型和一个Dog对象(name, age),并保存到data.dat 文件中

public static void main(String[] args) throws Exception {
    //序列化，保存的文件格式，不是文本格式，而是序列化独特的格式规范
    String fielPath = new String("D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\data.dat");

    ObjectOutputStream oos  = new ObjectOutputStream(new FileOutputStream(fielPath));
    //序列化数据到data.dat文件中
    oos.writeInt(100);//自动装箱：int -> Integer(实现了Serializable)
    oos.writeBoolean(true);//自动装箱：boolean -> Boolean(实现了Serializable)
    oos.writeChar('a');//char
    oos.writeDouble(1.1);//double
    oos.writeUTF("hello,world");//String

    //保存一个dog类
    //如果需要实现序列化某个类的对象，实现Serializable
    oos.writeObject(new Dog("旺财",2));

    oos.close();
    System.out.println("数据保存完毕");
}

代码示例二

使用ObjectlnputStream 读取 data.dat并反序列化恢复数据

public static void main(String[] args) throws Exception {
    String fielPath = new String("D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\data.dat");
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fielPath));
    //读取（反序列化）顺序需要与写入（序列化顺序）一致,否则
    System.out.println(ois.readInt());
    System.out.println(ois.readBoolean());
    System.out.println(ois.readChar());
    System.out.println(ois.readDouble());
    System.out.println(ois.readUTF());
    //dog的编译类型是Object,运行类型是Dog
    Object dog = ois.readObject();
    System.out.println(dog.getClass());//运行类型会自动转换，底层Obeject->Dog
    System.out.println(dog);
    //*访问Dog类的方法
    //1.向下转型
    //2.Dog类放在可以引用的地方，且与序列化的位置，定义都要一致
    Dog dog1 = (Dog) dog;
    System.out.println(dog1.getName());
    //注意，如果在序列化后，类的定义被修改了，例如增加了方法，会导致反序列化失败,可以添加SerialVersionUID解决这个问题
    //注意，在序列化时，包名信息已经固定，所以不能反序列化为不同包的Dog对象
    System.out.println("反序列化完成");
}

注意事项和细节说明

  1. 读写顺序要一致
  2. 要求实现序列化或反序列化对象,需要实现 Serializable
  3. 序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
  4. 序列化对象时，默认将里面所有属性都进行序列化，除了static或transient修饰的成员
  5. 序列化对象时，要求里面属性的类型也需要实现序列化接口
  6. 序列化具备可继承性,也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

标准输入输出流

类型（编译类型）默认设备
System.in 标准输入lnputStream键盘
System.out 标准输出PrintStream显示器
//System类中: public final static InputStream in = null;
//System.in 编译类型 InputStream
//System.in 运行类型 BufferedInputStream
//表示的是标准输入:键盘
System.out.println(System.in.getClass());

//System类中:：public final static PrintStream out = null;
//System.out 编译类型 PrintStream
//System.out 运行类型 PrintStream
//标准输出 显示器
System.out.println(System.out.getClass());

System.out.println("hello,world!");//使用out对象将数据输出到显示器上
Scanner scanner = new Scanner(System.in);//使用标准输入 键盘接收数据
System.out.println("输入内容");
String next = scanner.next();
System.out.println("next="+next);

转换流（InpuStreamReader和OutputStreamWriter）

问题引入

public static void main(String[] args) throws Exception {
    //读取txt文件
    //1. 创建字符输入流
    //2. 使用BufferedReader 对象读取a.txt
    //3. 默认情况下，读取文件按照的是utf-8编码
    //ANSI并不是某一种特定的字符编码，而是在不同的系统中，ANSI表示不同的编码。美国同事Bob的系统中ANSI编码其实是ASCII编码（ASCII编码不能表示汉字，所以汉字为乱码），而你的系统中（“汉字”正常显示）ANSI编码其实是GBK编码。
    String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\news3.txt";
    BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
    String line = bufferedReader.readLine();
    System.out.println("读取到的内容:"+line);//文本文件为ANSI编码，而使用utf-8编码读取文件,中文乱码
    bufferedReader.close();
}

说明

  • lnputStreamReader：Reader的子类,可以将InputStream(字节流)包装成（转换）Reader(字符流)
  • OutputStreamWriter：Writer的子类,实现将OutputStream(字节流)包装成Writer(字符流)
  • 当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流
  • 可以在使用时指定编码格式(比如utf-8, gbk , gb2312,ISO8859-1等)

类图

image-20220413201839058

代码示例一

使用InputStreamReader转换流解决中文乱码问题，将字节流FileInputStream 转成字符流 InputStreamReader,指定编码gbk/utf-8

public static void main(String[] args) throws Exception {
    String filePath = "D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\news3.txt";
    //1. 把FileInputStream 转成 InputStreamReader
    //2.指定编码 gbk
    //InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(filePath),"gbk");
    //3.把InputStreamReader 传入BufferedReader
    //BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

    //把2,3合并在一起
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
    //4.读取
    String line = bufferedReader.readLine();
    System.out.println("读取到的内容:"+line);//文本文件为ANSI编码，而使用utf-8编码读取文件,中文乱码
    //5.关闭外层流
    bufferedReader.close();
}

代码示例二

public static void main(String[] args) throws Exception {
    String filename="D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\OutputStreamWriter.txt";
    FileOutputStream fileOutputStream = new FileOutputStream(filename);
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream,"gbk");
    outputStreamWriter.write("kobe第一");
    outputStreamWriter.close();
}

打印流（PrintStream和PrintWriter）

  • 打印流只有输出流，没有输出流

类图

image-20220414100525975

image-20220414100610943

代码示例一

public static void main(String[] args) throws IOException {
    PrintStream out = System.out;
    //在默认情况下，PrintStream 输出数据的位置是 标准输出，即显示器
    /*
    public void print(String s) {
        if (s == null) {
            s = "null";
        }
        write(s);
    }
     */
    out.print("hello,world");
    //因为print底层使用的是write,所以我们可以直接调用write进行打印/输出
    out.write("rip,kobe!".getBytes());

    //我们可以修改打印流的输出位置/设备
    System.setOut(new PrintStream("D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\printStream.txt"));
    System.out.println("Jordon");
    out.close();
}

代码示例二

public static void main(String[] args) throws IOException {
    PrintWriter printWriter = new PrintWriter(System.out);
    printWriter.print("hello,北京");
    printWriter.close();

    PrintWriter printWriter2 = new PrintWriter(new FileWriter("D:\\programme\\javaProject\\java_base\\code\\JavaSE\\基础语法\\src\\com\\textFile\\PrintWriter.txt"));
    printWriter2.print("hello,北京");
    printWriter2.close();
}

Properties类

说明

  • 专门用于读写配置文件的集合类
    配置文件的格式:
    键=值
    键=值
  • 注意:键值对不需要有空格，值不需要用引号一起来。默认类型是String
  • 常见方法
    • load：加载配置文件的键值对到Properties对象
    • list:将数据显示到指定设备
    • getProperty(key):根据键获取值
    • setProperty(key,value):设置键值对到Properties对象
    • store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码

代码示例

public static void main(String[] args) throws Exception {
    //使用Properties类读取mysql.properties文件

    //1.创建Properties对象
    Properties properties = new Properties();
    //2. 加载指定配置文件
    properties.load(new FileReader("基础语法/src/mysql.properties"));
    //3. 把k-v显示控制台
    properties.list(System.out);
    //4. 根据key 获取对应的值
    String user = properties.getProperty("user");
    String pwd = properties.getProperty("pwd");
    System.out.println("用户名"+user);
    System.out.println("密码"+pwd);

    //使用Properties类创建配置文件，修改配置文件内容
    Properties properties1 = new Properties();
    //如果该文件有key，就是创建，如果没有就是修改
    /*
    Properties父类是HashTable，底层
    public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;//如果是旧key就替换
                return old;
            }
        }

        addEntry(hash, key, value, index);//如果是新key，就添加
        return null;
    }
     */
    properties1.setProperty("user", "汤姆");//中文保存为unicode码值
    properties1.setProperty("pwd", "1123");
    properties1.store(new FileWriter("基础语法/src/othersql.properties"),null);
}
JAVA IO流结构图概览
Guilai1990的博客
05-03 3335
整理Java IO流的关系，并作图如下，以供参考。 下图基于JDK 1.8制作，其中需要注意的是StringBufferInputStream和LineNumberInputStream已被废弃。 详情如下： 1.StringBufferInputStream @deprecated This class does not properly convert characters into...
JavaIo流分析图
12-11
分析Java常用IO流，包括InputStream、OutputStream、FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream、Reader、Writer、InputStreamReader、OutputStreamWriter、FileReader、FileWriter、BufferedReader、BufferedWriter
java io流类图
HEXINLI的专栏
07-14 6845
基于字节的I/O操作(InputStream和OutputStream) 二者类似，我只详细讲解InputStream类，OutputStream留给大家自己去学习。InputStream类是个抽象类，里面核心的方法就是read()、read(byte b[])、read(byte b[], int off, int len)，这三个方法是用于读取数据的底层的方法，他们可
JAVA IO流详解
u012815721的专栏
05-08 4666
一、流的概念和作用。 流是一种有顺序的，有起点和终点的字节集合，是对数据传输的总成或抽象。即数据在两设备之间的传输称之为流，流的本质是数据传输，根据数据传输的特性讲流抽象为各种类，方便更直观的进行数据操作。 二、IO流的分类。 根据数据处理类的不同分为：字符流和字节流。 根据数据流向不同分为：输入流和输出流。 三、字符流和字节流。 字符流的由来：因为数据编码的不同，而有了对字符进行高效
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
精选资源
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
精选资源
一文读懂Java IO流 1. IO流基础概念 1.1 什么是IO流 1.2 IO流的分类 1.2.1 按数据传输单位分类 1.2.2 按功能角色分类 1.3 Java IO流体系结构 1.4 流的基
最新发布
04-14
一文读懂Java IO流 1. IO流基础概念 1.1 什么是IO流 1.2 IO流的分类 1.2.1 按数据传输单位分类 1.2.2 按功能角色分类 1.3 Java IO流体系结构 1.4 流的基本操作 2. 字节流 2.1 InputStream - 输入字节流 2.2 ...
java IO流(包含类之间的关系图)
12-15
包含IO中的类的关系图和示例代码，初学者可以参考
Java Io流的概念，分类，类图
08-13 1736
目录 1、Java Io流的概念，分类，类图 1.1、Java Io流的概念 1.2、Io流的分类 1.2.1、按照流的流向分，可以分为输入流和输出流 1.2.2、按照操作单元划分，可以划分为字节流和字符流 1.2.3、按照流的角色划分为节点流和处理流 1.3、流的原理浅析和常用的流的分类表 1.3.1、流的原理浅析 1.3.2、java输入/输出流体系中常用的流的分类表（重点）...
Java IO流体系图（图）
猎人在吃肉
03-07 4597
文章目录一、字节流1.1、字节写入流1.2、字流读取流二、字符流2.1、字符写入2.2、字符读取 一、字节流 1.1、字节写入流 1.2、字流读取流 二、字符流 2.1、字符写入 2.2、字符读取 ...
java流类图结构_java学习之IO流(学习之旅，一)
weixin_36374105的博客
02-16 258
个人在学习IO流的时候看到如下所示java 流类图结构的时候，我的感想是，这么多··处于蒙的状态。Java流类图结构这么多，没有分类不好学，那我们就慢慢一口一口的吃，这样每天学习一点就好了，其实很多类并不是常用的。缕清思路很重要的，那么我转一篇百度的文档，写的思路很清晰。第一步，首先，明确IO流中有两个主要的体系，即字节输入流(InputStream)、输出流(OutputStream)和字符输入...
JavaIO流
程序员之道
04-30 321
IO流分为六种概念：输入流、输出流、字节流、字符流、节点流和处理流。 可以方便地实现数据的输入/输出操作。 不同的输入/输出源（键盘、文件、网络连接等）抽象表述 为“流”（stream）。 一、 流的分类 输入流：只能从中读取数据，而不能向其写入数据。由InputStream和 Reader作为基类。 输出流：只能向其写入数据，而不能从中读取数据。由OutputStream和Writer作为...
Java IO流 手画类图
LuoMu_L的博客
03-17 333
文章目录InputStreamOutputStreamReaderWriter InputStream OutputStream Reader Writer
Java IO 的类图
现实水中的理想倒影
10-07 9631
 拿出来方便大家。Java IO表面上看起来比较乱，有了类图就好看多了。 
Java IO流
02-11 98
首先上在网上找的InputStream和OutputStream的类图结构 下面的是Reader 和Writer 的类图结构 挑重点的讲解一下 1.ByteArrayInputStream和ByteArrayOutputStream 顾名思义,字节输入流和字节输出流,ByteArrayInputStream( ) 在构造输入流的时候传进去的是字节数组,通过re...
Java IO流实践案例解析大全
标题“java io流的实践案例大全”直接指出了文档的主旨，即提供了大量关于Java I/O流的实际操作案例。通过这些案例的展示，初学者和有经验的开发者都能从中获得必要的信息来增强他们在Java I/O操作方面的能力。 ###...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值