Java高级重点知识点-21-IO、字节流、字符流、IO异常处理、Properties中的load（）方法

IO

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

IO的分类

• 数据的流向： 输入流（把数据从 其他设备 上读取到 内存 中的流。）和输出流（把数据从 内存 中写出到 其他设备 上的流。）
• 数据的类型： 字节流（以字节为单位，读写数据的流。）和字符流（以字符为单位，读写数据的流。）

IO流父类:

	输入流	输出流
字节流	字节输入流InputStream	字节输出流OutputStream
字符流	字符输入流Reader	字符输出流Writer

字节流

在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

字节输出流【OutputStream】

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类

1. FileOutputStream类

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

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

public class OutPutStreamDemo {
    public static void main(String[] args) throws FileNotFoundException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:/outputstreamdemo.txt");
        FileOutputStream fileOutputStream1 = new FileOutputStream(new File("D:/outputstreamdemo2.txt"));
    }
}

这里通过源码我们可以发现，在我们使用其有参构造器创建对象的时候需要抛出一个FileNotFoundException 异常。并且我们可以注意到，当我们创建了一个输出流对象的时候，在我们的计算机中同样也会创建对应的文件（这里的文件是自动创建的,而之前我们使用File对象创建文件的时候，在硬盘中没有直接创建文件）。

写出字节数据

• 写出字节： write(int b) 方法

import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:/outputstreamdemo.txt");
        fileOutputStream.write(97);
        fileOutputStream.write(98);
        fileOutputStream.write(99);

        fileOutputStream.close();
    }
}

• 写出字节数组： write(byte[] b)

import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:/outputstreamdemo.txt");
        byte[] bytes = "今天天气很好".getBytes();
        fileOutputStream.write(bytes);
        fileOutputStream.close();
    }
}

这里我会发现，当我们写入新数据的时候，原来的数据被覆盖掉了。因此我们可以使用数据追加的构造方法。

import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:/outputstreamdemo.txt",true);
        byte[] bytes = "今天天气很好".getBytes();
        fileOutputStream.write(bytes);
        fileOutputStream.close();
    }
}

• 写出指定长度字节数组： write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节

import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:/outputstreamdemo.txt",true);
        byte[] bytes = "abcdef".getBytes();
        fileOutputStream.write(bytes,4,2);
        fileOutputStream.close();
    }
}

这里我们使用getBytes（）方法将字符串转换为字节数组，如何通过指定起始写位置4以及读写字节个数2，来向文件中写入数据ef。

写出换行：
Windows系统里，换行符号是 \r\n

import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:/outputstreamdemo.txt",true);
        byte[] bytes = "abcdef".getBytes();
        for (byte aByte : bytes) {
            fileOutputStream.write( aByte);
            fileOutputStream.write("\r\n".getBytes());
        }
        fileOutputStream.close();
    }
}

字节输入流【InputStream】

java.io.InputStream 抽象类是表示字节输入流的所有类的超类

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

数据准备： D:/outputstreamdemo2.txt

abcdef

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        new FileInputStream(new File("D:/outputstreamdemo2.txt"));
        FileInputStream in = new FileInputStream("D:/outputstreamdemo.txt");
        
    }
}

• 读取字节： read 方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        new FileInputStream(new File("D:/outputstreamdemo2.txt"));
        FileInputStream in = new FileInputStream("D:/outputstreamdemo.txt");
        int read = in.read();
        System.out.println((char) read);
        read = in.read();
        System.out.println((char) read);
    }
}

• 使用字节数组读取： read(byte[] b) ，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 -1

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        new FileInputStream(new File("D:/outputstreamdemo2.txt"));
        FileInputStream in = new FileInputStream("D:/outputstreamdemo.txt");
        int len = 0;
        byte[] read = new byte[2];
        while ( (len = in.read(read)) != -1){
            System.out.println(new String(read,0,len));
        }
    }
}

图片复制

准备工作：首先在D盘创建一个file1目录，在文件目录中存放一张照片，然后创建一个file2目录。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("D:\\file1\\basketball.jpg");
        FileOutputStream out = new FileOutputStream("D:\\file2\\test.jpg");
        int len =  0;
        byte[] buff = new byte[1024];
        while ((len = in.read(buff)) != -1){
            out.write(buff,0,len);
        }
        out.close();
        in.close();
    }
}

字符流

以字符为单位读写数据，专门用于处理文本文件。

字符输入流【FileReader】

java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
读取字符数据：
数据准备：在D盘创建一个file1目录，里面放一个a.txt,文字内容为你好；

• 读取字符： read（） 方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回 -1 ，循环读取

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

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\file1\\a.txt");
        FileReader reader1 = new FileReader(file);
        FileReader reader2 = new FileReader("D:\\file2\\b.txt");
        int len = 0;
        while ((len = reader1.read()) != -1){
            System.out.print((char)len);
        }
        reader1.close();
    }
}

• 使用字符数组读取： read(char[] cbuf) ，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 -1

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

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\file1\\a.txt");
        FileReader reader1 = new FileReader(file);
        int len = 0;
        char[] buff = new char[1024];
        while ((len = reader1.read(buff)) != -1){
            System.out.print(new String(buff,0,len));
        }
        reader1.close();
    }
}

字符输出流【FileWriter】

java.io.FileWriter 类是写出字符到文件的便利类

基本写出数据:

• 写出字符： write(int b) 方法，每次可以写出一个字符数据。

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

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\file1\\a.txt");
        FileWriter writer = new FileWriter(file,true);
        writer.write(97);
        writer.write('c');
        writer.write(4000);
        writer.close();
    }
}

注意：
关闭资源时,与FileOutputStream不同。如果不关闭,数据只是保存到缓冲区，并未保存到文件。
这里涉及到一个问题，就是我们的close（）方法执行后就无法使用同样的流对象来进行写数据了，所以我们可以使用flush（）方法。

代码示例：

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

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\file1\\a.txt");
        FileWriter writer = new FileWriter(file,true);
        writer.write(97);
        writer.write('c');
        writer.write(4000);
        writer.flush();
        writer.write('d');
        writer.write('1');
        writer.close();
    }
}

flush ：刷新缓冲区，流对象可以继续使用。
close :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

写出其他数据：

• 写出字符数组 ： write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据。

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

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\file1\\a.txt");
        FileWriter out = new FileWriter(file,true);
        char[] arr = "我的测试数据".toCharArray();
        out.write(arr); // 写入了 我的测试数据
        out.write(arr,2,2); // 写入了 测试
        out.close();
    }
}

• 写出字符串： write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据

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

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\file1\\a.txt");
        FileWriter out = new FileWriter(file,true);
        String str = "你好世界";
        out.write(str); // 写入了 你好世界
        out.write(str,2,2); // 写入了 世界
        out.close();
    }
}

小tips：

• 我们在创建FileWriter对象的时候，指定了boolean值的参数，这样我们的数据就可以进行续写了。
  
• 我们可以写出数据的时候进行换行。
  

IO异常的处理（扩展知识）

• JDK7前处理

通过try-catch-finally代码块来进行处理。

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

public class FileWriterDemo {
    public static void main(String[] args){
        File file = new File("D:\\file1\\a.txt");
        FileWriter out = null;
        try {
            out = new FileWriter(file,true);
            String str = "你好世界";
            out.write(str); // 写入了 你好世界
            out.write("\r\n");
            out.write(str,2,2); // 写入了 世界
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            
        }
    }
}

• JDK7的处理(的 try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。)

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

public class FileWriterDemo {
    public static void main(String[] args) {
        File file = new File("D:\\file1\\a.txt");
        try (FileWriter out = new FileWriter(file, true)) {
            String str = "你好世界";
            out.write(str); // 写入了 你好世界
            out.write("\r\n");
            out.write(str, 2, 2); // 写入了 世界
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• JDK9的改进(对于引入对象的方式，支持的更加简洁)

public class TryDemo {
	public static void main(String[] args) throws IOException {
		// 创建流对象
		final FileReader fr = new FileReader("in.txt");
		FileWriter fw = new FileWriter("out.txt");
		// 引入到try中
		try (fr; fw) {
			// 定义变量
			int b;
			// 读取数据
			while ((b = fr.read())!=‐1) {
			// 写出数据
			fw.write(b);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Properties属性集(java.util)

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

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

import java.io.FileNotFoundException;
import java.util.Properties;
import java.util.Set;

public class ProDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties properties = new Properties();
        // 添加键值对元素
        properties.setProperty("filename", "D:\\file1");
        properties.setProperty("username", "root");
        properties.setProperty("password", "123456");
        // 打印属性集对象
        System.out.println(properties);
        // 通过键,获取属性值
        System.out.println(properties.getProperty("filename"));
        System.out.println(properties.getProperty("username"));
        System.out.println(properties.getProperty("password"));
        // 遍历属性集,获取所有键的集合
        Set<String> strings = properties.stringPropertyNames();
        // 打印键值对
        for (String key : strings) {
            System.out.println(key + " ‐‐ " + properties.getProperty(key));
        }
    }
}

• public void load(InputStream inStream) ： 从字节输入流中读取键值对。

数据准备：
首先创建一个D:\file1\a.txt文件。在文件中写入如下数据：

filename=测试Properties类
username=root
password=123456

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class ProDemo2 {
    public static void main(String[] args) throws IOException {
        // 创建属性集对象
        Properties pro = new Properties();
        // 加载文本中信息到属性集
        pro.load(new FileReader("D:\\file1\\a.txt"));
        // 遍历集合并打印
        Set<String> strings = pro.stringPropertyNames();
        for (String key : strings) {
            System.out.println(key + " ‐‐ " + pro.getProperty(key));
        }
    }
}

欢迎java热爱者了解文章，作者将会持续更新中，期待各位友友的关注和收藏,另外对编程感兴趣的友友们可以加以下群共同学习。群号：127871664