Java基础学习笔记（十六）—— IO流
IO流
- 1 IO流
- 1.1 IO流概述
- 1.2 IO流的分类
- 1.3 IO流的使用场景
- 2 File类
- 2.1 File类概述
- 2.2 File类构造方法
- 2.3 File类常用方法
- 2.4 File类案例
- 3 字节流
- 3.1 字节流写数据
- 3.2 字节流写数据的三种方式
- 3.3 字节流写数据加异常处理
- 3.4 字节流读数据
- 3.5 字节流复制文件
- 4 字节缓冲流
- 4.1 字节缓冲流概述
- 4.2 字节缓冲流构造方法
- 4.3 小结
- 5 字符流
- 5.1 字符流概述
- 5.2 字符串的编码解码
- 5.3 字符流写数据
- 1.4 字符流读数据
- 5.5 字符流案例
- 6 字符缓冲流
- 6.1 构造方法
- 6.2 特有方法
- 6.3 缓冲流案例
1 IO流
之前存储的数据是不能够永久化存储的，只要代码运行结束，所有数据都会丢失。而想要数据永久话存储就必须要用到IO，可以跟本地硬盘交互。
1.1 IO流概述
- IO：输入/输出(Input/Output)
- I表示input，是数据从硬盘进内存的过程，称为读
- O表示output，是数据从内存到硬盘的过程，称为写
- 流：是一种抽象概念，是对数据传输的总称，也就是说数据在设备间的传输称为流，流的本质是数据传输
IO的数据传输，可以看做是一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作。
1.2 IO流的分类
- 按照数据的流向
- 输入流：读数据
- 输出流：写数据
- 按照数据类型来分
- 字节流
- 字节输入流
- 字节输出流
- 字符流
- 字符输入流
- 字符输出流
- 字节流
1.3 IO流的使用场景
- 如果操作的是纯文本文件，优先使用字符流
- 如果操作的是图片、视频、音频等二进制文件，优先使用字节流
- 如果不确定文件类型，优先使用字节流，字节流是万能的流
纯文本文件：用Windows自带的记事本打开能读懂的文件就是纯文本文件，txt文件就直接是纯文本文件
2 File类
2.1 File类概述
File类
- 它是文件和目录路径名的抽象表示
- 文件和目录是可以通过File封装成对象的
- 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的，将来是要通过具体的操作把这个路径的内容转换为具体存在的
- 在读写数据时告诉虚拟机要操作的（文件/文件夹）在哪
- 对（文件/文件夹）进行操作，包括创建、删除等
2.2 File类构造方法
public static void main(String[] args) {
//method1();
//method2();
//method3();
}
private static void method3() {
//File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的File实例
File file1 = new File("C:\\it");
String path = "a.txt";
File file = new File(file1,path);
System.out.println(file);//C:\it\a.txt
}
private static void method2() {
//File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的File实例
String path1 = "C:\\it";
String path2 = "a.txt";
File file = new File(path1,path2);//把两个路径拼接.
System.out.println(file);//C:\it\a.txt
}
private static void method1() {
//File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
String path = "C:\\it\\a.txt";
File file = new File(path);
//问题:为什么要把字符串表示形式的路径变成File对象?
//就是为了使用File类里面的方法.
}
注意：
- 绝对路径
- 是一个完整的路径,从盘符开始
- 相对路径
- 是一个简化的路径,相对当前项目下的路径
public static void main(String[] args) {
// 是一个完整的路径,从盘符开始
File file1 = new File("D:\\it\\a.txt");
// 是一个简化的路径,从当前项目根目录开始
File file2 = new File("a.txt");
File file3 = new File("模块名\\a.txt");
}
2.3 File类常用方法
- 创建功能
public static void main(String[] args) throws IOException {
//public boolean createNewFile() 创建一个新的空的文件
//注意点:
//1.如果文件存在,那么创建失败,返回false
//2.如果文件不存在,那么创建成功,返回true
//3.createNewFile方法不管调用者有没有后缀名,只能创建文件.
//public boolean mkdir() 创建一个单级文件夹
//注意点:
//1.只能创建单级文件夹,不能创建多级文件夹
//2.不管调用者有没有后缀名,只能创建单级文件夹
//public boolean mkdirs() 创建一个多级文件夹
//注意点:
//1,可以创建单级文件夹,也可以创建多级文件夹
//2.不管调用者有没有后缀名,只能创建文件夹
//疑问:
//既然mkdirs能创建单级,也能创建多级.那么mkdir还有什么用啊? 是的
//method1();
//method2();
File file = new File("C:\\it\\aaa.txt");
boolean result = file.mkdirs();
System.out.println(result);
}
private static void method2() {
File file = new File("C:\\it\\aaa.txt");
boolean result = file.mkdir();
System.out.println(result);
}
private static void method1() throws IOException {
File file1 = new File("C:\\it\\aaa");
boolean result1 = file1.createNewFile();
System.out.println(result1);
}
- 删除功能
//注意点:
//1.不走回收站的.
//2.如果删除的是文件,那么直接删除.如果删除的是文件夹,那么能删除空文件夹
//3.如果要删除一个有内容的文件夹,只能先进入到这个文件夹,把里面的内容全部删除完毕,才能再次删除这个文件夹
//简单来说:
//只能删除文件和空文件夹.
public static void main(String[] args) {
//method1();
File file = new File("C:\\it");
boolean result = file.delete();
System.out.println(result);
}
private static void method1() {
File file = new File("C:\\it\\a.txt");
boolean result = file.delete();
System.out.println(result);
}
- 判断功能
public static void main(String[] args) {
//method1();
//method2();
private static void method2() {
File file = new File("a.txt");
boolean result = file.exists();
System.out.println(result);
}
private static void method1() {
File file = new File("C:\\it\\a.txt");
boolean result1 = file.isFile();
boolean result2 = file.isDirectory();
System.out.println(result1);
System.out.println(result2);
}
- 获取功能
public static void main(String[] args) {
File file = new File("D:\\aaa");
System.out.println(f.getAbsolutePath());
System.out.println(f.getPath());
System.out.println(f.getName());
File[] files = file.listFiles();//返回值是一个File类型的数组
System.out.println(files.length);
for (File path : files) {
System.out.println(path);
}
}
注意：
- 当调用者不存在时，listFiles方法返回null
- 当调用者是一个文件时，listFiles方法返回null
- 当调用者是一个空文件夹时，listFiles方法返回一个长度为0的数组
- 当调用者是一个有内容的文件夹时，进入文件夹，listFiles方法会获取这个文件夹里面所有的文件和文件夹的File对象，并把这些File对象都放在一个数组中返回。包括隐藏文件和隐藏文件夹都可以获取。
- 当调用者是一个有权限才能进入的文件夹时，listFiles方法返回null
2.4 File类案例
- 在当前模块下的aaa文件夹中创建一个a.txt文件
public static void main(String[] args) throws IOException {
/* File file = new File("filemodule\\aaa\\a.txt");
file.createNewFile();*/
//注意点:文件所在的文件夹必须要存在.
File file = new File("filemodule\\aaa");
if(!file.exists()){
//如果文件夹不存在,就创建出来
file.mkdirs();
}
File newFile = new File(file,"a.txt");
newFile.createNewFile();
}
- 删除一个多级文件夹
public static void main(String[] args) {
//delete方法
//只能删除文件和空文件夹.
//如果现在要删除一个有内容的文件夹?
//先删掉这个文件夹里面所有的内容.
//最后再删除这个文件夹
File src = new File("C:\\Users\\apple\\Desktop\\src");
deleteDir(src);
}
private static void deleteDir(File src) {
//先删掉这个文件夹里面所有的内容.
//递归 方法在方法体中自己调用自己.
//注意: 可以解决所有文件夹和递归相结合的题目
//1.进入 --- 得到src文件夹里面所有内容的File对象.
File[] files = src.listFiles();
//2.遍历 --- 因为我想得到src文件夹里面每一个文件和文件夹的File对象.
for (File file : files) {
if(file.isFile()){
//3.判断 --- 如果遍历到的File对象是一个文件,那么直接删除
file.delete();
}else{
//4.判断
//递归
deleteDir(file);//参数一定要是src文件夹里面的文件夹File对象
}
}
//最后再删除这个文件夹
src.delete();
}
- 统计一个文件夹中，每种文件出现的次数
public static void main(String[] args) {
//统计 --- 定义一个变量用来统计. ---- 弊端:同时只能统计一种文件
//利用map集合进行数据统计,键 --- 文件后缀名 值 ---- 次数
File file = new File("filemodule");
HashMap<String, Integer> hm = new HashMap<>();
getCount(hm, file);
System.out.println(hm);
}
private static void getCount(HashMap<String, Integer> hm, File file) {
File[] files = file.listFiles();
for (File f : files) {
if(f.isFile()){
String fileName = f.getName();
String[] fileNameArr = fileName.split("\\.");
if(fileNameArr.length == 2){
String fileEndName = fileNameArr[1];
if(hm.containsKey(fileEndName)){
//已经存在
//将已经出现的次数获取出来
Integer count = hm.get(fileEndName);
//这种文件又出现了一次.
count++;
//把已经出现的次数给覆盖掉.
hm.put(fileEndName,count);
}else{
//不存在
//表示当前文件是第一次出现
hm.put(fileEndName,1);
}
}
}else{
getCount(hm,f);
}
}
}
3 字节流
3.1 字节流写数据
- 字节流抽象基类
- InputStream：这个抽象类是表示字节输入流的所有类的超类
- OutputStream：这个抽象类是表示字节输出流的所有类的超类
- 子类名特点：子类名称都是以其父类名作为子类名的后缀
- 字节输出流
- FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
- 使用字节输出流写数据的步骤
- 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
- 调用字节输出流对象的写数据方法
- 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
public static void main(String[] args) throws IOException {
//1.创建字节输出流的对象 --- 告诉虚拟机我要往哪个文件中写数据了
FileOutputStream fos = new FileOutputStream("D:\\a.txt");
//FileOutputStream fos = new FileOutputStream(new File("D:\\a.txt"));
//2,写数据，传递一个整数时，那么实际上写到文件中的，是这个整数在码表中对应的那个字符.
fos.write(97); //会在文件中写入a
//3,释放资源，告诉操作系统，我现在已经不要再用这个文件了
fos.close();
}
注意：
- 如果文件不存在，会帮我们自动创建出来.
- 如果文件存在，会把文件清空.
3.2 字节流写数据的三种方式
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
/*fos.write(97);
fos.write(98);
fos.write(99);*/
/* byte [] bys = {97,98,99};
fos.write(bys);*/
byte [] bys = {97,98,99,100,101,102,103};
fos.write(bys,1,2); //98,99即写入bc
fos.close();
}
那么，现在有两个小问题
- 字节流写数据如何实现换行？
- windows:\r\n
- linux:\n
- mac:\r
- getBytes()是字符串的一个方法，可以将字符串转换为字节
- 字节流写数据如何实现追加写入？
- public FileOutputStream(String name,boolean append)
- 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头
public static void main(String[] args) throws IOException {
//第二个参数就是续写开关,如果没有传递,默认就是false,
//表示不打开续写功能,那么创建对象的这行代码会清空文件.
//如果第二个参数为true,表示打开续写功能
//那么创建对象的这行代码不会清空文件.
FileOutputStream fos = new FileOutputStream("bytestream\\a.txt",true);
fos.write(97);
//加一个换行
fos.write("\r\n".getBytes());
fos.write(98);
//加一个换行
fos.write("\r\n".getBytes());
fos.write(99);
//加一个换行
fos.write("\r\n".getBytes());
fos.write(100);
//加一个换行
fos.write("\r\n".getBytes());
fos.write(101);
//加一个换行
fos.write("\r\n".getBytes());
fos.close();
}
3.3 字节流写数据加异常处理
有如下代码：
try {
FileOutputStream fos = new FileOutputStream("a.txt");
fos.write(97);
fos.close();
}catch (IOException e){
e.printStackTrace();
}
我们如何操作才能让close方法一定执行呢？
异常处理的标准格式：
try{
可能出现异常的代码;
}catch(异常类名 变量名){
异常的处理代码;
}finally{
执行所有清除操作; // 在异常处理时提供finally块来执行所有的清除操作，比如IO流的释放资源，被finally控制的语句一定会执行，除非JVM退出
}
加异常处理后的代码如下：
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//System.out.println(2/0);
fos = new FileOutputStream("D:\\a.txt");
fos.write(97);
}catch(IOException e){
e.printStackTrace();
}finally {
//finally语句里面的代码,一定会被执行.
if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.4 字节流读数据
字节输入流
- FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名
字节输入流读取数据的步骤
- 创建字节输入流对象
- 调用字节输入流对象的读数据方法
- 释放资源
- 一次读一个字节数据
public static void main(String[] args) throws IOException {
//如果文件存在,那么就不会报错.
//如果文件不存在,那么就直接报错.
FileInputStream fis = new FileInputStream("bytestream\\a.txt");
int read = fis.read();
//一次读取一个字节,返回值就是本次读到的那个字节数据.
//也就是字符在码表中对应的那个数字.
//如果我们想要看到的是字符数据,那么一定要强转成char
System.out.println(read); // 97
System.out.println((char)read); //a
//释放资源
fis.close();
}
- 一次读多个字节数据
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("bytestream\\a.txt");
//文件中多个字节我怎么办?
/*while(true){
int i1 = fis.read(); 内容读取结束读取到空格时返回-1
System.out.println(i1);
}*/
int b;
while ((b = fis.read())!=-1){
System.out.println((char) b);
}
fis.close();
}
3.5 字节流复制文件
- 小文件复制
将C:\it\a.jpg的文件复制到模块bytestream下
public static void main(String[] args) throws IOException {
//创建了字节输入流,准备读数据.
FileInputStream fis = new FileInputStream("C:\\it\\a.jpg");
//创建了字节输出流,准备写数据.
FileOutputStream fos = new FileOutputStream("bytestream\\a.jpg");
int b;
while((b = fis.read())!=-1){
fos.write(b);
}
fis.close();
fos.close();
}
- 大文件复制
对于大文件的复制问题，字节流通过创建字节数组，可以一次读写多个数据
一次读一个字节数组的方法：
- public int read(byte[] b)：从输入流读取最多b.length个字节的数据
- 返回的是读入缓冲区的总字节数，也就是实际的读取字节个数
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("C:\\itheima\\a.avi");
FileOutputStream fos = new FileOutputStream("bytestream\\a.avi");
byte [] bytes = new byte[1024];// 该字节数组的大小是1024字节
int len;//本次读到的有效字节个数 --- 这次读了几个字节
while((len = fis.read(bytes))!=-1){ // 循环读取
fos.write(bytes,0,len);//0索引开始，读取len个字节
}
fis.close();
fos.close();
}
4 字节缓冲流
4.1 字节缓冲流概述
- BufferedOutputStream：该类实现缓冲输出流，通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
- BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组，当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节
4.2 字节缓冲流构造方法
- 一次读写一个字节
public static void main(String[] args) throws IOException {
//就要利用缓冲流去拷贝文件
//创建一个字节缓冲输入流
//在底层创建了一个默认长度为8192的字节数组。
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));
//创建一个字节缓冲输出流
//在底层也创建了一个默认长度为8192的字节数组。
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));
int b;
while((b = bis.read()) != -1){
bos.write(b);
}
//方法的底层会把字节流给关闭。
bis.close();
bos.close();
}
- 一次读写一个字节数组
public static void main(String[] args) throws IOException {
//缓冲流结合数组，进行文件拷贝
//创建一个字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));
//创建一个字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));
byte [] bytes = new byte[1024];
int len;
while((len = bis.read(bytes)) != -1){
bos.write(bytes,0,len);
}
bis.close();
bos.close();
}
为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
- 字节缓冲流仅仅提供缓冲区，而真正读写数据还是得依靠基本的字节流对象进行操作
4.3 小结
字节流：
- 可以操作（拷贝）所有类型的文件
字节缓冲流：
- 可以提高效率；
- 不能直接操作文件，需要传递字节流
拷贝文件的四种方式：
- 字节流一次读写一个字节
- 字节流一次读写一个字节数组
- 字节缓冲流一次读写一个字节
- 字节缓冲流一次读写一个字节数组
5 字符流
5.1 字符流概述
既然字节流可以操作所有文件，为什么要学习字符流？
- 如果利用字节流，把文本文件中的中文，读取到内存中，有可能出现乱码
- 如果利用字节流，把中文写到文本文件中，也有可能出现乱码
为什么字节流读取文本文件，可能会出现乱码？
- 因为字节流一次读一个字节，而不管GBK还是UTF-8一个中文都是多个字节，用字节流每次只能读其中的一部分，所以会出现乱码的问题
由于字节流操作中文不是特别的方便，所以Java就提供字符流（字符流 = 字节流 + 编码表）
- 计算某种规则，将字符变成二进制，再存储到计算机中，称为编码
- 按照同样的规则，将存储在计算机中的二进制数解析显示出来，称为解码
- 编码和解码的方式必须一致，否则会导致乱码
Windows默认使用码表为：GBK，一个中文两个字节
IDEA和以后工作默认使用Unicode的UTF-8编码格式，一个中文三个字节
不管是在哪张码表中，中文的第一个字节一定是负数
注意：
- 想要进行拷贝，一律使用字节流或者字节缓冲流
- 想要把文本文件中的数据读到内存中，使用字符输入流
- 想要把内存中的数据写到文本文件中，使用字符输出流
5.2 字符串的编码解码
public static void main(String[] args) throws UnsupportedEncodingException {
method1();
method2();
}
private static void method2() throws UnsupportedEncodingException {
byte[] bytes = {-28, -67, -96, -27, -91, -67, -28, -72, -106, -25, -107, -116};
//利用默认的UTF-8进行解码
String s1 = new String(bytes);
System.out.println(s1);//你好世界
//利用指定的编码进行解码
String s2 = new String(bytes,"UTF-8");
System.out.println(s2);//你好世界
}
private static void method1() throws UnsupportedEncodingException {
String s = "你好世界";
//利用idea默认的UTF-8将中文编码为一系列的字节
byte[] bytes1 = s.getBytes();
System.out.println(Arrays.toString(bytes1)); // [-28, -67, -96, -27, -91, -67, -28, -72, -106, -25, -107, -116]
byte[] bytes2 = s.getBytes("UTF-8");
System.out.println(Arrays.toString(bytes1)); // [-28, -67, -96, -27, -91, -67, -28, -72, -106, -25, -107, -116]
}
5.3 字符流写数据
Writer: 用于写入字符流的抽象父类
FileWriter: 用于写入字符流的常用子类
构造方法：
成员方法：
public static void main(String[] args) throws IOException {
//创建字符输出流的对象
//FileWriter fw = new FileWriter(new File("charstream\\a.txt"));
FileWriter fw = new FileWriter("charstream\\a.txt");
//写一个字符
fw.write(97);
fw.write(98);
fw.write(99);
//写出一个字符数组
char [] chars1 = {97,98,99,100,101};
fw.write(chars1);
//写出字符数组的一部分
char [] chars2 = {97,98,99,100,101};
fw.write(chars2,0,3);
//写一个字符串
String line1 = "黑马程序员abc";
fw.write(line1);
//写一个字符串的一部分
String line2 = "黑马程序员abc";
fw.write(line2, 0, 2);
//释放资源
fw.close();
}
注意：
- 在创建字符输出流对象时，如果文件存在就清空，如果文件不存在就创建，但是要保证父级路径存在
- 写数据时，写出int类型的整数，实际写出的是整数在码表上对应的字母，写出字符串数据，是把字符串本身原样输出
刷新和关闭的方法：
1.4 字符流读数据
Reader: 用于读取字符流的抽象父类
FileReader: 用于读取字符流的常用子类
- 构造方法
- 成员方法
public static void main(String[] args) throws IOException {
//创建字符输入流的对象
// FileReader fr = new FileReader(new File("charstream\\a.txt"));
FileReader fr = new FileReader("charstream\\a.txt");
//读取数据
//一次读取一个字符
/* int ch;
while((ch = fr.read()) != -1){
System.out.println((char) ch);
}*/
//一次读取多个字符。
//创建一个数组
char [] chars = new char[1024];
int len;
//read方法还是读取，但是是一次读取多个字符
//他把读到的字符都存入到chars数组。
//返回值：表示本次读到了多少个字符。
while((len = fr.read(chars))!=-1){
System.out.println(new String(chars,0,len));
}
//释放资源
fr.close();
}
5.5 字符流案例
- 案例需求：
- 将键盘录入的用户名和密码保存到本地实现永久化存储
- 实现步骤：
- 获取用户输入的用户名和密码
- 将用户输入的用户名和密码写入到本地文件中
- 关流，释放资源
- 示例代码：
public static void main(String[] args) throws IOException {
//将键盘录入的用户名和密码保存到本地实现永久化存储
//要求：用户名独占一行，密码独占一行
//分析：
//1，实现键盘录入，把用户名和密码录入进来
Scanner sc = new Scanner(System.in);
System.out.println("请录入用户名");
String username = sc.next();
System.out.println("请录入密码");
String password = sc.next();
//2.分别把用户名和密码写到本地文件。
FileWriter fw = new FileWriter("charstream\\a.txt");
//将用户名和密码写到文件中
fw.write(username);
//表示写出一个回车换行符 windows \r\n MacOS \r Linux \n
fw.write("\r\n");
fw.write(password);
//刷新流
fw.flush();
//释放资源
fw.close();
}
6 字符缓冲流
6.1 构造方法
-
BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
-
BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途
public static void main(String[] args) throws IOException {
read();
write();
}
private static void write() throws IOException {
//字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\a.txt"));
//写出数据
//实际写出的是97对应的字符a
bw.write(97);
bw.write("\r\n");
//实际写出的是97 - 101 对应的字符 abcde
char [] chars = {97,98,99,100,101};
bw.write(chars);
bw.write("\r\n");
//实际写的是abc
bw.write(chars,0,3);
bw.write("\r\n");
//会把字符串的内容原样写出
bw.write("我是一个程序员");
bw.write("\r\n");
//会把字符串的一部分写出 abcde
String line = "abcdefg";
bw.write(line,0,5);
bw.flush();
bw.close();
}
private static void read() throws IOException {
//字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("charstream\\a.txt"));
//读取数据
char [] chars = new char[1024];
int len;
while((len = br.read(chars)) != -1){
System.out.println(new String(chars,0,len));
}
br.close();
}
6.2 特有方法
BufferedWriter：
public static void main(String[] args) throws IOException {
//字符缓冲流的特有功能
//字符缓冲输出流BufferedWrite ： newLine 跨平台的换行符
//创建对象
BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\a.txt"));
//写出数据
bw.write("程序员666");
//跨平台的回车换行
bw.newLine();
bw.write("abcdef");
//跨平台的回车换行
bw.newLine();
bw.write("-------------");
//刷新流
bw.flush();
//释放资源
bw.close();
}
BufferedReader：
public static void main(String[] args) throws IOException {
//字符缓冲流的特有功能
//字符缓冲输入流BufferedReader： readLine 读一整行
//创建对象
BufferedReader br = new BufferedReader(new FileReader("charstream\\a.txt"));
/* //读取数据
String line1 = br.readLine();
String line2 = br.readLine();
String line3 = br.readLine();
//在之前，如果读不到数据，返回-1
//但是readLine如果读不到数据返回null
String line4 = br.readLine();
System.out.println(line1);
System.out.println(line2);
System.out.println(line3);
System.out.println(line4);*/
//使用循环来进行改进
String line;
//可以读取一整行数据。一直读，读到回车换行为止。
//但是他不会读取回车换行符。
while((line = br.readLine()) != null){
System.out.println(line);
}
// 释放资源
br.close();
}
6.3 缓冲流案例
字符缓冲流操作文件中数据排序案例
- 案例需求
- 使用字符缓冲流读取文件中的数据，排序后再次写到本地文件
- 实现步骤
- 将文件中的数据读取到程序中
- 对读取到的数据进行处理
- 将处理后的数据添加到集合中
- 对集合中的数据进行排序
- 将排序后的集合中的数据写入到文件中
- 代码实现
public static void main(String[] args) throws IOException {
//需求：读取文件中的数据，排序后再次写到本地文件
//分析：
//1.要把文件中的数据读取进来。
BufferedReader br = new BufferedReader(new FileReader("charstream\\sort.txt"));
//输出流一定不能写在这里，因为会清空文件中的内容
//BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\sort.txt"));
String line = br.readLine();
System.out.println("读取到的数据为" + line);
br.close();
//2.按照空格进行切换
String[] split = line.split(" ");//9 1 2 5 3 10 4 6 7 8
//3.把字符串类型的数组变成int类型
int [] arr = new int[split.length];
//遍历split数组，可以进行类型转换。
for (int i = 0; i < split.length; i++) {
String smallStr = split[i];
//类型转换
int number = Integer.parseInt(smallStr);
//把转换后的结果存入到arr中
arr[i] = number;
}
//4.排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//5.把排序之后结果写回到本地 1 2 3 4...
BufferedWriter bw = new BufferedWriter(new FileWriter("charstream\\sort.txt"));
//写出
for (int i = 0; i < arr.length; i++) {
bw.write(arr[i] + " ");
bw.flush();
}
//释放资源
bw.close();
}