雷哒哒
雷哒哒

JavaSE-IO

目录

[TOC]

第一章：IO介绍

1.1 什么是IO

​ 生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了 ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

​ 我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为 输入input 和 输出output ，即流向内存是输入流，流出内存的输出流。

​ Java中I/O操作主要是指使用 java.io 包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

1.2 IO的分类

根据数据的流向分为：输入流和输出流。

  • 输入流 ：把数据从 其他设备 上读取到 内存 中的流。
  • 输出流 ：把数据从 内存 中写出到 其他设备 上的流。

根据数据的类型分为：字节流和字符流。

  • 字节流 ：以字节为单位，读写数据的流。
  • 字符流 ：以字符为单位，读写数据的流。

1.3 IO顶级的父类

第二章：字节流

2.1 一切皆为字节流

​ 一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都是一个一个的字节，那么传输时一 样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.2 字节输出流-OutputStream

​ java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

  • 方法
    • public void close()：关闭此输出流并释放与此流相关联的任何系统资源。
    • public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出。
    • public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
    • public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
    • public abstract void write(int b) ：将指定的字节输出流。
  • 注意事项：
    • close方法，当完成流的操作时，必须调用此方法，释放系统资源。

2.3 FileOutputStream类

​ OutputStream 有很多子类，我们从最简单的一个子类开始。

​ java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。

  • 构造方法

    1. public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
    2. public FileOutputStream(String name) ： 创建文件输出流以指定的名称写入文件。
    3. 注意：
      • 当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

  • 写出字节数据

        FileOutputStream fos = new FileOutputStream("a.txt");
    //  【write(int b)】
    // 写入的十进制会转换成二进制存储到a.txt
    // 读取文件时，文件会按照指定的编码格式转换为对应的内容
    fos.write(97);  // 写入→97→110 0001→内存→读取→110 0001→ASCII→a
    fos.write(98);
    // 【 write(byte[] b)】
    byte[]bs = {97,98,99,101,102};
    fos.write(bs);
    // 【字符串转换字节数组getBytes()】
    fos.write("你好".getBytes());
    // 【write(byte[] b, int off, int len)指定长度的字节数组】
    fos.write("xyz".getBytes(),0,2);
    fos.close();

  • 数据追加续写

    • 问题：

      • 经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能 继续添加新数据呢？

    • 解决方案

      • public FileOutputStream(File file, boolean append) ： 创建文件输出流以写入由指定的 File对象表示的文件。
      • public FileOutputStream(String name, boolean append) ： 创建文件输出流以指定的名称写入文件。
      • 参数： true 表示追加数据， false 表示清空原有数据。

    • 代码

          FileOutputStream fos = new FileOutputStream("a.txt",true);
    fos.write("我是新追加的数据".getBytes());
    fos.close();

  • 写出换行

    • 系统中的换行

      • Windows系统里，每行结尾是 回车+换行 ，即 \r\n ；
      • Unix系统里，每行结尾只有 换行 ，即 \n ；
      • Mac系统里，每行结尾是 回车 ，即 \r。从 Mac OS X开始与Linux统一。

    • 代码

          FileOutputStream fos = new FileOutputStream("b.txt",true);
    for (int i = 0; i < 10; i++) {
      fos.write(("\r\n第" + i +"行数据：" + i*100).getBytes() );
    }
    fos.close();

2.4 字节输入流

​ java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入 流的基本共性功能方法。

  • public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

  • public abstract int read() ： 从输入流读取数据的下一个字节。

  • public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

    • 使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使

      用。

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

2.5 FileInputStream类

java.io.FileInputStream 类是文件输入流，从文件中读取字节。

  • 构造方法

    1. FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系 统中的 File对象 fifile命名。
    2. FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件 系统中的路径名 name命名。

  • 读取字节数据代码

        // 创建字节输入流对象
    FileInputStream fis = new FileInputStream("day07_IO//a.txt");
    //【一次读取一个字节】
    // 循环读取文件中的字节
    int len = 0;
    while ((len=fis.read())!=-1){
      System.out.print((char)len);
    }
    // 结果：ABC
    // 【一次读取多个字节】
    // 将字节转换为字符串new Strig(bytes[]bts,int offset,int length);
    byte[]bts = new byte[10];
    int len2 = 0;
    while ((len2=fis.read(bts))!=-1){
      System.out.println(new String(bts,0,len2));
    }
  fis.close();

2.6 复制图片文件

  • 原理

  • 代码

      public static void main(String[] args) throws IOException {
    long s = System.currentTimeMillis();
    // 创建输入流对象-用来读取本地文件
    FileInputStream fis = new FileInputStream("D:\\test.jpg");
    // 创建输出流对象-用来写入本地文件
    FileOutputStream fos = new FileOutputStream("day07_IO\\test_copy.jpg");
    // 创建字节数组，一次从本地读取多个字节
    byte[]bts = new byte[1024];
    int len = 0; // 表示读取的有效字节个数
    // 循环读取本地数据
    while ((len=fis.read(bts))!=-1){
      // 把实际读取的字节写入本地文件
      fos.write(bts,0,len);
    }
    // 关闭输出流资源
    fos.close();
    // 关闭输入流资源
    fis.close();
    long e = System.currentTimeMillis();
    System.out.println("复制成功！");
    System.out.println("共耗时" + (e-s)+"毫秒");
  }

第三章：字符流

3.1 为什么要学习字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为

一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文

件。

3.2 字符输入流-Reader

  1. public void close() ：关闭此流并释放与此流相关联的任何系统资源。
  2. public int read() ： 从输入流读取一个字符。
  3. public int read(char[] cbuf) ： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

3.3 FileReader类

java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区

  • 注意事项

    1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。 idea中UTF-8

    2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

  • 构造函数

    1. FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象。
    2. FileReader(String fileName) ： 创建一个新的 FileReader ，给定要读取的文件的名称。

  • 代码

      public static void main(String[] args) throws IOException {
    FileReader reader = new FileReader("day07_IO//a.txt");
    // 【一次读取一个字符】
    int len = 0;
    while ((len = reader.read())!=-1) {
      System.out.print((char)len);
    }
    // 【一次读取多个字符】
    char[]chs = new char[1024];
    int len = 0;
    while ((len = reader.read(chs))!=-1) {
      System.out.print(new String(chs,0,len));
      // new String(char[]chars,int offset,int count);
    }
    reader.close();

  }

3.4 字符输出流-Writer

java.io.Writer 抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节

输出流的基本共性功能方法。

  1. void write(int c) 写入单个字符。
  2. void write(char[] cbuf)写入字符数组。
  3. abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分,offff数组的开始索引,len 写的字符个数。
  4. void write(String str)写入字符串。
  5. void write(String str, int off, int len)写入字符串的某一部分,offff字符串的开始索引,len写的字符个 数。
  6. void flush()刷新该流的缓冲。
  7. void close()关闭此流，但要先刷新它。

3.5 FileWriter类

java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

  • 构造函数：

    1. FileWriter(File file) ： 创建一个新的 FileWriter，给定要读取的File对象。
    2. FileWriter(String fileName) ： 创建一个新的 FileWriter，给定要读取的文件的名称。

  • 代码：

      public static void main(String[] args) throws IOException {
    // 创建输出字符流对象
    FileWriter fw = new FileWriter("day07_IO\\b.txt");
    fw.write("你好");
    fw.flush(); // flush将缓冲区的数据刷新到文件中，可继续写入
    fw.write("我好");
    fw.flush();
    fw.write("大家好");
    fw.close();// close 将缓冲区中的数据刷新到文件中，并且会释放输出流对象，后继无法继续输出
    fw.write("真好");   // 异常
      
    // 创建输出流对象，向指定的文件中追加写入数据
    FileWriter fw2 = new FileWriter("day07_IO\\b.txt",true);
    for (int i = 0; i < 10; i++) {
      fw2.write("你好，新的世界！" + i + "\r\n");
    }
    fw2.close();
  }

  • 注意事项：

    • 因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要 flush 方法了。
    • flush ：刷新缓冲区，流对象可以继续使用。
    • close :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

第四章：IO异常处理

4.1 JDK7之前的处理方式

  • 处理方式：try-catch-finally

    • 在finally中释放资源

  • 代码：

      public static void main(String[] args)  {
    // 创建输出流对象，向指定的文件中追加写入数据
    FileWriter fw2 = null;
    try{
      fw2 = new FileWriter("day07_IO\\b.txt",true);
      for (int i = 0; i < 10; i++) {
        fw2.write("你好，新的世界！" + i + "\r\n");
      }
    }catch (IOException e) {
      e.printStackTrace();
    }finally {
      if(fw2!=null){
        try {
          fw2.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }

  }

4.2 JDK7中的新特性

  • 处理方式：JDK7优化后的 try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源 （resource）是指在程序完成后，必须关闭的对象。

    try (创建流对象语句，如果多个,使用';'隔开) { 
    // 读写数据 
} catch (IOException e) { 
    e.printStackTrace(); 
}

  • 代码：

    public static void main(String[] args)  {
    // 创建输出流对象，向指定的文件中追加写入数据
    try(FileWriter fw2 = new FileWriter("day07_IO\\b.txt",true)){
      for (int i = 0; i < 100; i++) {
        fw2.write("你好，新的世界！" + i + "\r\n");
      }
    }catch (IOException e) {
      e.printStackTrace();
    }
  }

4.3 JDK9中的新特性

​ JDK9中 try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭， 无需手动close

  • 格式

    // 被final修饰的对象 
final Resource resource1 = new Resource("resource1"); 
// 普通对象 
Resource resource2 = new Resource("resource2"); 
// 引入方式：直接引入 
try (resource1; resource2) { 
    // 使用对象 
} catch (IOException e) { 
    e.printStackTrace(); 
}

  • 代码

    public static void main(String[] args) throws IOException  {
    // 创建输出流对象，向指定的文件中追加写入数据
    FileWriter fw2 = new FileWriter("day07_IO\\b.txt",true);
    try(fw2){
      for (int i = 0; i < 100; i++) {
        fw2.write("你好，新的世界！" + i + "\r\n");
      }
    }catch (IOException e) {
      e.printStackTrace();
    }
  }

第五章：属性集

5.1 属性集合介绍

java.util.Properties 继承于 Hashtable ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其

对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时， System.getProperties 方法就是返回

一个 Properties 对象。

5.2 Properties 类

  • 构造方法：public Properties() :创建一个空的属性列表。

  • 基本的存储方法

    1. public Object setProperty(String key, String value)： 保存一对属性。
    2. public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。
    3. public Set stringPropertyNames() ：所有键的名称的集合。

  • 与流相关的方法

    1. public void load(InputStream inStream) ： 从字节输入流中读取键值对。
      • 注意：文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。

  • 代码

    public static void main(String[] args) throws IOException {
    // 获取系统相关的信息
    System.out.println(System.getProperties());
    // 创建一个属性集合
    Properties pro = new Properties();
    pro.setProperty("张三","180");
    pro.setProperty("李四","189");
    pro.setProperty("王五","178");
    pro.setProperty("赵六","188");
    // 读取属性集合中的数据
    Set set = pro.keySet();
    for (Object o : set) {
      System.out.println(pro.get(o));
    }
    // 把集合中临时的数据输出到硬盘中
    // pro.store(new FileWriter("day07_IO\\data.txt"),"save data");

    // 读取本地文件中的数据（键值对的方式）到属性集合中
    Properties pro2 = new Properties();
    pro2.load(new FileReader("day07_IO\\data.txt"));
    System.out.println(pro2);
  }

第六章：缓冲流

6.1 缓冲流介绍

缓冲流,也叫高效流，是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：

  • 字节缓冲流： BufferedInputStream ， BufferedOutputStream
  • 字符缓冲流： BufferedReader ， BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

6.2 字节缓冲流

  • 构造方法

    1. public BufferedInputStream(InputStream in)：创建一个 新的缓冲输入流。
    2. public BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流。

  • 代码测试

    1. 基本方式一次读写一个字节

      public static void main(String[] args) throws IOException {
    long s = System.currentTimeMillis();
    // 创建字节输入流，读取本地文件数据
    FileInputStream fis = new FileInputStream("D:\\test.jpg");
    // 创建字节输出流，向本地文件写入数据
    FileOutputStream fos = new FileOutputStream("day08_IO\\test01.jpg");
    // 定义变量表示读取的字节
    int len = 0;
    // 循环遍历读取本地文件
    while ((len=fis.read())!=-1) {
      // 把读取的字节写入本地
      fos.write(len);
    }
    // 关闭输出流
    fos.close();
    // 关闭输入流
    fis.close();
    long e = System.currentTimeMillis();
    System.out.println("共耗时：" + (e-s) + "毫秒"); // 161毫秒

  }

    2. 基本方式一次读写多个字节

      public static void main(String[] args) throws IOException {
    long s = System.currentTimeMillis();
    // 创建字节输入流，读取本地文件数据
    FileInputStream fis = new FileInputStream("D:\\test.jpg");
    // 创建字节输出流，向本地文件写入数据
    FileOutputStream fos = new FileOutputStream("day08_IO\\test02.jpg");
    // 定义变量表示读取的有序字节个数
    int len = 0;
    // 定义字节数组，表示一次要读取的字节数
    byte[]bts = new byte[1024];
    // 循环遍历读取本地文件
    while ((len=fis.read(bts))!=-1) {
      // 把读取的字节写入本地
      fos.write(bts,0,len);
    }
    // 关闭输出流
    fos.close();
    // 关闭输入流
    fis.close();
    long e = System.currentTimeMillis();
    System.out.println("共耗时：" + (e-s) + "毫秒"); // 共耗时：7毫秒

  }

    3. 缓冲流方式默认读写方式

      public static void main(String[] args) throws IOException {
    long s = System.currentTimeMillis();
    // 创建字节缓冲流输入流
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\test.jpg"));
    // 创建字节缓冲流输出流f
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day08_IO\\test03.jpg"));
    // 循环读取本地数据
    int len = 0;
    while ((len = bis.read())!=-1){
      bos.write(len);
    }
    bos.close();
    bis.close();
    long e = System.currentTimeMillis();
    System.out.println("共耗时：" + (e-s) + "毫秒"); // 共耗时：8毫秒
  }

    4. 缓冲流方式指定字节读取

      public static void main(String[] args) throws IOException {
    long s = System.currentTimeMillis();
    // 创建字节缓冲流输入流
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\test.jpg"));
    // 创建字节缓冲流输出流f
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day08_IO\\test04.jpg"));
    // 循环读取本地数据
    int len = 0;
    byte[]bts = new byte[1024];
    while ((len = bis.read(bts))!=-1){
      bos.write(bts,0,len);
    }
    bos.close();
    bis.close();
    long e = System.currentTimeMillis();
    System.out.println("共耗时：" + (e-s) + "毫秒"); // 共耗时：6毫秒
  }

6.3 字符缓冲流

  • 构造方法

    1. public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
    2. public BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。

  • 特有方法：字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

    1. BufffferedReader： public String readLine() : 读一行文字。
    2. BufffferedWriter： public void newLine(): 写一行行分隔符,由系统属性定义符号。

  • 代码：

    public static void main(String[] args) throws IOException {
    // 创建字符缓冲输出流
    BufferedWriter bw = new BufferedWriter( new FileWriter("day08_IO\\01.txt"));
    for (int i = 0; i < 100; i++) {
      bw.write("贵在坚持！不只是说说！" + i);
      bw.newLine();
    }
    bw.close();
    // 创建字符缓冲输入流
    BufferedReader br = new BufferedReader(new FileReader("day08_IO\\01.txt"));
    String line;
    while ((line=br.readLine())!=null){
      System.out.println(line);
    }
    br.close();
  }

6.4 文本排序

  • 需求：读取本地文件中的文本，并排序后重新写入本地新的文件中

    2.JavaScript
1.Java
4.PHP
6.C#
7.C
3.C++
5.VB

  • 代码：

     public static void main(String[] args) throws IOException {
    // 创建HashMap对象存放读取的本地数据
    HashMap map = new HashMap<>();
    // 创建字符缓冲区输入流，逐行读取本地数据
    BufferedReader br = new BufferedReader(new FileReader("day08_IO\\02.txt"));
    String line;
    while ((line=br.readLine())!=null) {
      // 分割
      String[]strs = line.split("\\.");
      map.put(strs[0],strs[1]);
    }
    br.close();
    // 创建字符输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("day08_IO\\03.txt"));
    for (int i = 1; i <= map.size(); i++) {
      bw.write(i +"."+ map.get(String.valueOf(i)));
      bw.newLine();
    }
    bw.close();

  }

第七章：转换流

7.1 字符编码和字符集

​ 计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

  • **字符编码Character Encoding **: 就是一套自然语言的字符与二进制数之间的对应规则。

  • 字符集charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

    • 计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

    • **ASCII字符集 **

      • ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
      • 基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。ASCII的扩展字符集使用8位（bits表示一个字符，共256字符，方便支持欧洲常用字符。

    • ISO-8859-1字符集

      • 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
      • ISO-5559-1使用单字节编码，兼容ASCII编码。

    • GBxxx字符集

    • GB就是国标的意思，是为了显示中文而设计的一套字符集。

    • GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。

    • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了 21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。

    • GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。

    • Unicode字符集

      • Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国 码。
      • 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF- 32。最为常用的UTF-8编码。
      • UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
        1. 128个US-ASCII字符，只需一个字节编码。
        2. 拉丁文等字符，需要二个字节编码。
        3. 大部分常用字（含中文），使用三个字节编码。
        4. 其他极少使用的Unicode辅助字符，使用四字节编码。

7.2 编码引出的问题

​ 在IDEA中，使用 FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的 UTF-8 编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

public static void main(String[] args) throws IOException {
    FileReader fr = new FileReader("D:\\a.txt");
    int len = 0;
    while((len=fr.read())!=-1){
      System.out.print((char)len); 
    }
    fr.close();
  }
// 结果：��� 乱码

那么如何读取GBK编码的文件呢？

7.3 InputStreamReader类

​ 转换流 java.io.InputStreamReader ，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

  • 构造方法

    1. InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
    2. InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。

  • 代码

    public static void main(String[] args) throws IOException {
    InputStreamReader fr = new InputStreamReader(new FileInputStream("D:\\a.txt"),"gbk");
    int len = 0;
    while((len=fr.read())!=-1){
      System.out.print((char)len);
    }
    fr.close();
  }
// 结果：你好

7.4 OutputStreamWriter 类

​ 转换流 java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符 编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

  • 构造函数

    1. OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。
    2. OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。

  • 代码

      public static void main(String[] args) throws IOException {
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day08_IO\\04.txt"),"gbk");
    osw.write("你好");
    osw.close();
  }

7.5 图解转换流原理

第八章：序列化

8.1 对象序列化介绍

​ Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该 对象的数据 、 对象的 类型 和 对象中存储的属性 等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。 对象的数据 、 对象的类型 和 对象中 存储的数据 信息，都可以用来在内存中创建对象。看图理解序列化：

8.2 ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

  • 构造方法

    1. public ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream。

  • 序列化操作

    1. 一个对象要想序列化，必须满足两个条件:

      • 该类必须实现java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。

      • 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用 transient 关键字修饰。

      • 代码：

        public class Person implements Serializable { // 实现Serializable，表示可序列化
  private String name;
  private int age;
  private transient int height;  // 该属性不会被序列化
  public Person(String name, int age, int height) {
    this.name = name;
    this.age = age;
    this.height = height;
  }
  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;
  }
  public int getHeight() {
    return height;
  }
  public void setHeight(int height) {
    this.height = height;
  }
  @Override
  public String toString() {
    return "姓名：" + name + "，年龄："+ age + "，身高：" + height;
  }
}

    2. **写出对象方法 **

      • public final void writeObject (Object obj) : 将指定的对象写出

      • 代码

        public static void main(String[] args) throws IOException {
    // 创建一个人类对象
    Person p = new Person("张三",18,180);
    // 创建一个序列化输出流对象
    ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("day08_IO\\person.txt"));
    // 把指定的对象序列化后写入本地文件
    os.writeObject(p);
    os.close();
    System.out.println("save a Object success");
  }

8.3 ObjectInputStream类

​ ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

  • 构造方法

  • public ObjectInputStream(InputStream in);： 创建一个指定InputStream的ObjectInputStream。

  • 反序列化操作1

    • 如果能找到一个对象的class文件，我们可以进行反序列化操作，调用 ObjectInputStream 读取对象的方法：

      • public final Object readObject () : 读取一个对象。

    • 代码：

      public static void main(String[] args) throws IOException, ClassNotFoundException {
    ObjectInputStream os = new ObjectInputStream(new FileInputStream("day08_IO\\person.txt"));
    Person p = (Person) os.readObject();
    System.out.println(p); // 姓名：张三，年龄：18，身高：0
    os.close();
  }

// 对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个ClassNotFoundException 异常。

  • 反序列化操作2

    • 另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操 作也会失败，抛出一个 InvalidClassException 异常。发生这个异常的原因如下：

      • 该类的序列版本号与从流中读取的类描述符的版本号不匹配
      • 该类包含未知数据类型
      • 该类没有可访问的无参数构造方法

    • 解决方案

      • Serializable 接口给需要序列化的类，提供了一个序列版本号。 serialVersionUID 该版本号的目的在于验证序 列化的对象和对应类是否版本匹配。

    • 代码

      public class Person implements Serializable { // 实现Serializable，表示可序列化
  // 定义序列化版本号
  private static final long serialVersionUID = 10L;
  private String name;
  public int age;
  private transient int height;  // 该属性不会被序列化
  public Person(String name, int age, int height) {
    this.name = name;
    this.age = age;
    this.height = height;
  }
  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;
  }
  public int getHeight() {
    return height;
  }
  public void setHeight(int height) {
    this.height = height;
  }
  @Override
  public String toString() {
    return "姓名：" + name + "，年龄："+ age + "，身高：" + height;
  }
}

第九章：打印流

9.1 打印流介绍

​ 平时我们在控制台打印输出，是调用 print 方法和 println 方法完成的，这两个方法都来自于 java.io.PrintStream 类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

9.2 PrintStream类

  • 构造方法

    • public PrintStream(String fileName)： 使用指定的文件名创建一个新的打印流。

  • System.out 就是 PrintStream 类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象， 我们就可以玩一个"小把戏"，改变它的流向。

  • 代码

      public static void main(String[] args) throws IOException {
    // 打印在控制台
    System.out.println("你好");
    // 创建打印流，流向指定的本地文件
    PrintStream ps = new PrintStream(new FileOutputStream("day08_IO\\print.txt"));
    // 设置System.out的打印流向指向ps
    System.setOut(ps);
    // 后续打印在print.txt文件中
    System.out.println("你好1");
    System.out.println("你好2");
    System.out.println("你好3");
    ps.close();
  }

你可能感兴趣的:(JavaSE-IO)

  • JavaSE-IO流 6Cx33 java开发语言eclipse
    1.IO流1.1概述流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。I:Input输入O:output输出1.2分类按处理数据类型不同，分为字节流和字符流按数据流向的不同，分为输入流和输出流。(入和出是相对于内存来讲的)按功能不同，分为节点流(直接操作数据源)和处理流(
  • JavaSE-IO 雷哒哒
    目录[TOC]第一章：IO介绍1.1什么是IO生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input和输出output，即流向内存是输入流
  • JavaSE-IO流 YDSoong java编程语言
    一、概念1.流：数据在内存和其他存储设备传输的通道、管道。2.流的分类：(1)按照方向分：[以JVM内存为参照物]a.输入流：将[其他存储设备]中数据读入到[JVM内存]中。->读b.输出流：将[JVM内存]中数据写入到[其他存储设备]中。->写(2)按照单位分：a.字节流：以字节为传输单位，可以用于操作所有类型的文件。b.字符流：以字符为传输单位，可以用于操作文本类型的文件。文本文件：只要能以记
  • javaSE-IO补充 功能流对象（序列化和瞬态关键字） 南栀_倾寒 javaSE
    打印流PrintWriter与PrintStream可以直接操作输入流和文件/**打印流：PrintStream*特点：*1，给字节输出流提供了打印方法。*2，方便打印数值表示形式。*3，构造函数接收File对象，字符串路径，OutputStream.*/PrintStreamps=newPrintStream("temp\\ps2.txt");//ps.write(97);//write写出一个
  • JavaSE-IO流基础详解 流烟默 #IO-NIO-Netty
    流是一个抽象的概念当Java程序需要从数据源读取数据时，会开启一个到数据源的流。数据源可以是文件，内存或者网络等。同样，当程序需要输出数据到目的地时也一样会开启一个流，数据目的地也可以是文件、内存或者网络等。流的创建是为了更方便地处理数据的输入输出。流是同步的也就是说，当程序(确切的将是线程)请求一个流读/写一段数据时，在做任何其他操作前，它要等待读/写的数据。Java还支持使用通道和缓冲区的非阻
  • javaSe-IO流 叫我懒猫
    为什么称为流？所有数据对于计算机来说都是以细化的小单位存储的，所以让他们一起输入输出就像流水一样，一股数据才是一个整体，比如对于字节流，GKB编码情况下，一个汉字就是两个字节，那么这两个字节就是一个流。IO流分类：字节流：字节输入流和字节输出流字符流：字符的输入和输出流缓冲流：4字节的输入缓冲流对象流……首先接触下文件的基础操作：Filef=newFile("d:/files/b.txt");//
  • JavaSE-IO流 GGRoddick
    packagecom.btp.t4; importjava.io.File; importjava.io.IOException; importjava.util.Date; importorg.junit.Test; /* *java.io.File *1.凡是与输入，输出相关的类，接口等都定义在java.io包下 *2.File是一个类，可以有构造器创建其对象。此对
  • java Illegal overloaded getter method with ambiguous type for propert的解决 zwllxs javajdk
    好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出 Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
  • IT人应当知道的10个行业小内幕 beijingjava 工作互联网
    10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。 　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。 　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
  • java 实现自定义链表 CrazyMizzz java数据结构
    1.链表结构   链表是链式的结构 2.链表的组成    链表是由头节点，中间节点和尾节点组成    节点是由两个部分组成：       1.数据域       2.引用域 3.链表的实现 &nbs
  • web项目发布到服务器后图片过一会儿消失 麦田的设计者 struts2上传图片永久保存
      作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
  • CodeIgniter框架Cart类 name 不能设置中文的解决方法 IT独行者 CodeIgniterCart框架　
    今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。 在CI手册里也有说明，如下： $data = array( 'id' => 'sku_123ABC', 'qty' => 1, '
  • linux回收站 _wy_ linux回收站
    今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。     后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
  • jquery回到页面顶端 知了ing htmljquerycss
    html代码： <h1 id="anchor">页面标题</h1> <div id="container">页面内容</div> <p><a href="#anchor" class="topLink">回到顶端</a><
  • B树、B-树、B+树、B*树 矮蛋蛋 B树
    原文地址： http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html B树        即二叉搜索树：        1.所有非叶子结点至多拥有两个儿子（Left和Right）； &nb
  • 数据库连接池 alafqq 数据库连接池
    http://www.cnblogs.com/xdp-gacl/p/4002804.html @Anthor:孤傲苍狼 数据库连接池 用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误： java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
  • java泛型 百合不是茶 java泛型
    泛型 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患   泛型的特点：消除强制转换 确保类型安全 向后兼容   简单泛型的定义：      泛型：就是在类中将其模糊化，在创建对象的时候再具体定义 class fan
  • javascript闭包[两个小测试例子] bijian1013 JavaScriptJavaScript
    一.程序一 <script> var name = "The Window"; var Object_a = { 　　name : "My Object", 　　getNameFunc : function(){ var that = this; 　　　　return function(){ 　　　　
  • 探索JUnit4扩展：假设机制（Assumption） bijian1013 javaAssumptionJUnit单元测试
    一.假设机制（Assumption）概述        理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
  • 【Gson四】范型POJO的反序列化 bit1129 POJO
    在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过 String str = new Gson().toJson(data); 得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO   import com.google.gson.Gson; import java.
  • 【Spark八十五】Spark Streaming分析结果落地到MySQL bit1129 Stream
    几点总结： 1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法 2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
  • NGINX + LUA实现复杂的控制 ronin47 nginx lua
    安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。 这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
  • java-递归判断数组是否升序 bylijinnan java
    public class IsAccendListRecursive { /*递归判断数组是否升序 * if a Integer array is ascending,return true * use recursion */ public static void main(String[] args){ IsAccendListRecursiv
  • Netty源码学习-DefaultChannelPipeline2 bylijinnan javanetty
    Netty3的API http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html 里面提到ChannelPipeline的一个“pitfall”： 如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB） 来
  • Java工具之JPS chinrui java
    JPS使用     熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
  • window.print分页打印 ctrain window
    function init() { var tt = document.getElementById("tt"); var childNodes = tt.childNodes[0].childNodes; var level = 0; for (var i = 0; i < childNodes.length; i++) {
  • 安装hadoop时 执行jps命令Error occurred during initialization of VM daizj jdkhadoopjps
    在安装hadoop时，执行JPS出现下面错误   [slave16][email protected]:/tmp/hsperfdata_hdfs# jps Error occurred during initialization of VM java.lang.Error: Properties init: Could not determine current working
  • PHP开发大型项目的一点经验 dcj3sjt126com PHP重构
    一、变量 最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。 二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
  • android笔记之--向网络发送GET/POST请求参数 dcj3sjt126com android
    使用GET方法发送请求 private static boolean sendGETRequest (String path, Map<String, String> params) throws Exception{ //发送地http://192.168.100.91:8080/videoServi
  • linux复习笔记 之bash shell (3) 通配符 eksliang linux 通配符linux通配符
    转载请出自出处： http://eksliang.iteye.com/blog/2104387 在bash的操作环境中有一个非常有用的功能，那就是通配符。 下面列出一些常用的通配符，如下表所示 符号 意义 * 万用字符，代表0个到无穷个任意字符 ? 万用字符，代表一定有一个任意字符 [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
  • Android关于短信加密 gqdy365 android
    关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）：     1、因为Android有短信收发接口，可以调用接口完成短信收发；         发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
  • asp.net在网站根目录下创建文件夹 hvt .netC#hovertreeasp.netWeb Forms
    假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下： string m_keleyiFolderName = Server.MapPath("/hovertree"); if (Directory.Exists(m_keleyiFolderName)) { //文件夹已经存在 return; } else { try { D
  • 一个合格的程序员应该读过哪些书 justjavac 程序员书籍
    编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？ “如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本， 你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。” 很多程序员响应，他们在推荐时也写下自己的评语。 以前就有国内网友介绍这个程序员书单，不过都是推荐数
  • 单实例实践 跑龙套_az 单例
       1、内部类 public class Singleton { private static class SingletonHolder { public static Singleton singleton = new Singleton(); } public Singleton getRes
  • PO VO BEAN 理解 q137681467 VODTOpo
    PO：      全称是 persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。 好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。     BO：     全称是 business object:业务对象 主要作用是把业务逻辑封装为一个对象。这个对
  • 战胜惰性，暗自努力 金笛子 努力
    偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？ 我有个朋友是搞技术的，平时嘻嘻哈哈，以
  • NDK/JNI二维数组多维数组传递 wenzongliang 二维数组jniNDK
    多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组 用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。 Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata) { jint i,j; int s
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他