Java基础:字节流、字符流
第一章 IO
概述
1.1 什么是IO
生活中,你肯定经历过这样的场景。当你编辑一个文本文件,忘记了ctrl+s
,可能文件就白白编辑了。当你电脑上插入一个U盘,可以把一个视频,拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢?键盘、内存、硬盘、外接设备等等。
我们把这种数据的传输,可以看做是一种数据的流动,按照流动的方向,以内存为基准,分为 输入input
和输出output
,即流向内存是输入流,流出内存的输出流。
Java
中I/O
操作主要是指使用java.io
包下的内容,进行输入、输出操作。输入也叫做读取数据,输出也叫做作写出数据。
1.2 IO
的分类
根据数据的流向分为:输入流和输出流。
输入流 :把数据从 其他设备 上读取到 内存 中的流。
输出流 :把数据从 内存 中写出到 其他设备 上的流。
格局数据的类型分为:字节流和字符流。
字节流 :以字节为单位,读写数据的流。
字符流 :以字符为单位,读写数据的流。
1.3 IO
的流向说明图解
1.4 顶级父类们
输入流 | 输出流 | |
---|---|---|
字节流 |
字节输入流InputStream
|
字节输出流OutputStream
|
字符流 |
字符输入流Reader
|
字符输出流Writer
|
第二章 字节流
2.1 一切皆为字节
一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。
2.2 字节输出流【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
类是文件输出流,用于将数据写出到文件。
构造方法
public FileOutputStream(File file)
:创建文件输出流以写入由指定的File
对象表示的文件。public FileOutputStream(String name)
:创建文件输出流以指定的名称写入文件。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文件,会清空这个文件的数据。
构造举例,代码如下:
public class FileOutputStreamConstructor {public static void main(String[] args) throws FileNotFoundException {// 使用File对象创建流对象File file = new File("a.txt");FileOutputStream fos = new FileOutputStream(file);// 使用文件名称创建流对象FileOutputStream fos2 = new FileOutputStream("b.txt");}
}
写出字节数据
- 写出字节:
write(int b)
方法,每次可以写出一个字节数据,代码使用演示:
package com.dcxuexi.java23;import java.io.FileOutputStream;
import java.io.IOException;/**** @Title FOSWrite* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 17:42* @Version 1.0.0*/
public class FOSWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream.txt");// 写出数据fileOutputStream.write(97); // 写出第1个字节fileOutputStream.write(98); // 写出第2个字节fileOutputStream.write(99); // 写出第3个字节// 关闭资源fileOutputStream.close();}
}
小贴士:
- 虽然参数为
int
类型四个字节,但是只会保留一个字节的信息写出。- 流操作完毕后,必须释放系统资源,调用
close
方法,千万记得。
- 写出字节数组:
write(byte[] b)
,每次可以写出数组中的数据,代码使用演示:
package com.dcxuexi.java23;import java.io.FileOutputStream;
import java.io.IOException;/**** @Title FOSWrite02* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 17:49* @Version 1.0.0*/
public class FOSWrite02 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream02.txt");// 字符串转换为字节数组byte[] b = "我爱北京天安门".getBytes();// 写出字节数组数据fileOutputStream.write(b);// 关闭资源fileOutputStream.close();}
}
- 写出指定长度字节数组:
write(byte[] b, int off, int len)
,每次写出从off
索引开始,len
个字节,代码使用演示:
package com.dcxuexi.java23;import java.io.FileOutputStream;
import java.io.IOException;/**** @Title FOSWrite03* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 17:54* @Version 1.0.0*/
public class FOSWrite03 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream03.txt");// 字符串转换为字节数组byte[] bytes = "abcdefg".getBytes();// 写出从索引2开始,2个字节。索引2是c,三个字节,也就是cde。fileOutputStream.write(bytes,2,3);// 关闭资源fileOutputStream.close();}
}
数据追加续写
经过以上的演示,每次程序运行,创建输出流对象,都会清空目标文件中的数据。如何保留目标文件中数据,还能继续添加新数据呢?
public FileOutputStream(File file, boolean append)
:创建文件输出流以写入由指定的File
对象表示的文件。public FileOutputStream(String name, boolean append)
:创建文件输出流以指定的名称写入文件。
这两个构造方法,参数中都需要传入一个boolean
类型的值,true
表示追加数据,false
表示清空原有数据。这样创建的输出流对象,就可以指定是否追加续写了,代码使用演示:
package com.dcxuexi.java23;import java.io.FileOutputStream;
import java.io.IOException;/**** @Title FOSWrite04* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 17:59* @Version 1.0.0*/
public class FOSWrite04 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream03.txt",true);// 字符串转换为字节数组byte[] bytes = "hijklmn".getBytes();// 追加写出字节数组数据fileOutputStream.write(bytes);// 关闭资源fileOutputStream.close();}
}
写出换行
Windows
系统里,换行符号是\r\n
。代码使用演示:
package com.dcxuexi.java23;import java.io.FileOutputStream;
import java.io.IOException;/**** @Title FOSWrite05* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 18:04* @Version 1.0.0*/
public class FOSWrite05 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\javaCode\\fileOutputStream05.txt");// 定义字节数组byte[] bytes = "abcdef".getBytes();// 遍历数组for (int i = 0; i < bytes.length; i++) {fileOutputStream.write(bytes[i]);fileOutputStream.write("\r\n".getBytes());}fileOutputStream.close();}
}
回车符
\r
和换行符\n
:回车符:回到一行的开头(
return
)。换行符:下一行(
newline
)。
系统中的换行:
Windows
系统里,每行结尾是回车+换行
,即\r\n
;Unix
系统里,每行结尾只有换行
,即\n
;Mac
系统里,每行结尾是回车
,即\r
。从Mac OS X
开始与Linux
统一。
2.4 字节输入流【InputStream
】
java.io.InputStream
抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close()
:关闭此输入流并释放与此流相关联的任何系统资源。public abstract int read()
:从输入流读取数据的下一个字节。public int read(byte[] b)
:从输入流中读取一些字节数,并将它们存储到字节数组b
中 。
小贴士:
close
方法,当完成流的操作时,必须调用此方法,释放系统资源。
2.5 FileInputStream
类
java.io.FileInputStream
类是文件输入流,从文件中读取字节。
构造方法
FileInputStream(File file)
: 通过打开与实际文件的连接来创建一个FileInputStream
,该文件由文件系统中的File
对象file
命名。FileInputStream(String name)
: 通过打开与实际文件的连接来创建一个FileInputStream
,该文件由文件系统中的路径名name
命名。
当你创建一个流对象时,必须传入一个文件路径 。该路径下,如果没有该文件,会抛出FileNotFoundException
。
构造举例,代码如下:
public class FileOutputStreamConstructor {public static void main(String[] args) throws FileNotFoundException {// 使用File对象创建流对象File file = new File("a.txt");FileOutputStream fos = new FileOutputStream(file);// 使用文件名称创建流对象FileOutputStream fos2 = new FileOutputStream("b.txt");}
}
读取字节数据
- 读取字节:
read
方法,每次可以读取一个字节的数据,提升为int
类型,读取到文件末尾,返回 -1 ,代码使用演示:
package com.dcxuexi.java23;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;/**** @Title FISRead* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 18:26* @Version 1.0.0*/
public class FISRead {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileInputStream fileInputStream = new FileInputStream("D:\\java\\javaCode\\fileOutputStream.txt");// 读取数据,返回一个字节int read = fileInputStream.read();System.out.println((char) read);read = fileInputStream.read();System.out.println((char) read);read = fileInputStream.read();System.out.println((char) read);read = fileInputStream.read();System.out.println((char) read);read = fileInputStream.read();System.out.println((char) read);// 读取到末尾,返回-1read = fileInputStream.read();System.out.println( read);// 关闭资源fileInputStream.close();}
}
循环改进读取方式,代码使用演示:
package com.dcxuexi.java23;import java.io.FileInputStream;
import java.io.IOException;/**** @Title FISRead02* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 18:32* @Version 1.0.0*/
public class FISRead02 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileInputStream fileInputStream = new FileInputStream("D:\\java\\javaCode\\fileOutputStream.txt");// 定义变量,保存数据int b;// 循环读取while ((b = fileInputStream.read()) != -1){System.out.println((char)b);}// 关闭资源fileInputStream.close();}
}
小贴士:
- 虽然读取了一个字节,但是会自动提升为
int
类型。- 流操作完毕后,必须释放系统资源,调用
close
方法,千万记得。
- 使用字节数组读取:
read(byte[] b)
,每次读取b
的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回 -1 ,代码使用演示:
package com.dcxuexi.java23;import java.io.FileInputStream;
import java.io.IOException;/**** @Title FISRead03* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 18:38* @Version 1.0.0*/
public class FISRead03 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileInputStream fileInputStream = new FileInputStream("D:\\java\\javaCode\\fileOutputStream.txt");// 定义变量,作为有效个数int len;// 定义字节数组,作为装字节数据的容器byte[] b = new byte[2];// 循环读取while ((len = fileInputStream.read(b)) != -1){// 每次读取后,把数组变成字符串打印System.out.println(new String(b));}// 关闭资源fileInputStream.close();}
}
错误数据d
,是由于最后一次读取时,只读取一个字节e
,数组中,上次读取的数据没有被完全替换,所以要通过len
,获取有效的字节,代码使用演示:
package com.dcxuexi.java23;import java.io.FileInputStream;
import java.io.IOException;/**** @Title FISRead04* @Description TOTD* @Auter DongChuang* @Date 2022/12/11 18:42* @Version 1.0.0*/
public class FISRead04 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileInputStream fileInputStream = new FileInputStream("D:\\java\\javaCode\\fileOutputStream.txt");// 定义变量,作为有效个数int len;// 定义字节数组,作为装字节数据的容器byte[] b = new byte[2];// 循环读取while ((len = fileInputStream.read(b)) != -1){// 每次读取后,把数组的有效字节部分,变成字符串打印System.out.println(new String(b,0,len));}// 关闭资源fileInputStream.close();}
}
小贴士:
使用数组读取,每次读取多个字节,减少了系统间的
IO
操作次数,从而提高了读写的效率,建议开发中使用。
2.6 字节流练习:图片复制
复制原理图解
案例实现
复制图片文件,代码使用演示:
package com.dcxuexi.java23;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;/**** @Title Copy* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 20:36* @Version 1.0.0*/
public class Copy {public static void main(String[] args) throws IOException {// 1.创建流对象// 1.1 指定数据源FileInputStream fis = new FileInputStream("D:\\java\\Java.jpeg");// 1.2 指定目的地FileOutputStream fos = new FileOutputStream("D:\\java\\javaCode\\Java.jpeg");// 2.读写数据// 2.1 定义数组byte[] b = new byte[1024];// 2.2 定义长度int len;// 2.3 循环读取while ((len = fis.read(b))!=-1) {// 2.4 写出数据fos.write(b, 0 , len);}// 3.关闭资源 流的关闭原则:先开后关,后开先关。fos.close();fis.close();}
}
小贴士: 流的关闭原则:先开后关,后开先关。
第三章 字符流
当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文字符可能占用多个字节存储。所以Java
提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
3.1 字符输入流【Reader
】
java.io.Reader
抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
public void close()
:关闭此流并释放与此流相关联的任何系统资源。public int read()
:从输入流读取一个字符。public int read(char[] cbuf)
:从输入流中读取一些字符,并将它们存储到字符数组cbuf
中 。
3.2 FileReader
类
java.io.FileReader
类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
小贴士:
- 字符编码:字节与字符的对应规则。
Windows
系统的中文编码默认是GBK
编码表。idea
中UTF-8
- 字节缓冲区:一个字节数组,用来临时存储字节数据。
构造方法
FileReader(File file)
: 创建一个新的FileReader
,给定要读取的File
对象。FileReader(String fileName)
: 创建一个新的FileReader
,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径。类似于FileInputStream
。
构造举例,代码如下:
package com.dcxuexi.java23;import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;/**** @Title FileReaderConstructor* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 20:46* @Version 1.0.0*/
public class FileReaderConstructor {public static void main(String[] args) throws FileNotFoundException {// 使用File对象创建流对象File file = new File("a.txt");FileReader fr = new FileReader(file);// 使用文件名称创建流对象FileReader fr2 = new FileReader("b.txt");}
}
读取字符数据
- 读取字符:
read
方法,每次可以读取一个字符的数据,提升为int
类型,读取到文件末尾,返回 -1 ,循环读取,代码使用演示:
package com.dcxuexi.java23;import java.io.FileReader;
import java.io.IOException;/**** @Title FRRead* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 20:49* @Version 1.0.0*/
public class FRRead {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileReader fileReader = new FileReader("D:\\java\\javaCode\\File\\read.txt");// 定义变量,保存数据int b;// 循环读取while ((b=fileReader.read()) != -1){System.out.println("b : " + (char)b);}// 关闭资源fileReader.close();}
}
小贴士:虽然读取了一个字符,但是会自动提升为
int
类型。
- 使用字符数组读取:
read(char[] cbuf)
,每次读取b的长度个字符到数组中,返回读取到的有效字符个数,读取到末尾时,返回 -1 ,代码使用演示:
package com.dcxuexi.java23;import java.io.FileReader;
import java.io.IOException;/**** @Title FRRead02* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 20:56* @Version 1.0.0*/
public class FRRead02 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileReader fileReader = new FileReader("D:\\java\\javaCode\\File\\read.txt");// 定义变量,保存有效字符个数int len;// 定义字符数组,作为装字符数据的容器char[] chub = new char[2];// 循环读取while ((len = fileReader.read(chub)) != -1){System.out.println(new String(chub));}// 关闭资源fileReader.close();}
}
获取有效的字符改进,代码使用演示:
package com.dcxuexi.java23;import java.io.FileReader;
import java.io.IOException;/**** @Title FRRead02* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 20:56* @Version 1.0.0*/
public class FRRead02 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileReader fileReader = new FileReader("D:\\java\\javaCode\\File\\read.txt");// 定义变量,保存有效字符个数int len;// 定义字符数组,作为装字符数据的容器char[] chub = new char[2];// 循环读取while ((len = fileReader.read(chub)) != -1){System.out.println(new String(chub,0,len));}// 关闭资源fileReader.close();}
}
3.3 字符输出流【Writer
】
java.io.Writer
抽象类是表示用于写出字符流的所有类的超类,将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
void write(int c)
:写入单个字符。void write(char[] cbuf)
:写入字符数组。abstract void write(char[] cbuf, int off, int len)
:写入字符数组的某一部分,off
数组的开始索引,len
写的字符个数。void write(String str)
:写入字符串。void write(String str, int off, int len)
:写入字符串的某一部分,off
字符串的开始索引,len
写的字符个数。void flush()
:刷新该流的缓冲。void close()
:关闭此流,但要先刷新它。
3.4 FileWriter
类
java.io.FileWriter
类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
FileWriter(File file)
:创建一个新的FileWriter
,给定要读取的File
对象。FileWriter(String fileName)
:创建一个新的FileWriter
,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径,类似于FileOutputStream
。
构造举例,代码如下:
package com.dcxuexi.java23;import java.io.File;
import java.io.FileWriter;
import java.io.IOException;/**** @Title FileWriterConstructor* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 21:05* @Version 1.0.0*/
public class FileWriterConstructor {public static void main(String[] args) throws IOException {// 使用File对象创建流对象File file = new File("a.txt");FileWriter fw = new FileWriter(file);// 使用文件名称创建流对象FileWriter fw2 = new FileWriter("b.txt");}
}
基本写出数据
写出字符:write(int b)
方法,每次可以写出一个字符数据,代码使用演示:
package com.dcxuexi.java23;import java.io.FileWriter;
import java.io.IOException;/**** @Title FWWrite* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 21:07* @Version 1.0.0*/
public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write.txt");// 写出数据fileWriter.write(97);// 写出第1个字符fileWriter.write('b');// 写出第2个字符fileWriter.write("国");// 写出第3个字符fileWriter.write(30000);// 写出第4个字符,中文编码表中30000对应一个汉字。//【注意】关闭资源时,与FileOutputStream不同。// 如果不关闭,数据只是保存到缓冲区,并未保存到文件。fileWriter.close();}
}
小贴士:
- 虽然参数为
int
类型四个字节,但是只会保留一个字符的信息写出。- 未调用
close
方法,数据只是保存到了缓冲区,并未写出到文件中。
关闭和刷新
因为内置缓冲区的原因,如果不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据的。如果我们既想写出数据,又想继续使用流,就需要flush
方法了。
flush
:刷新缓冲区,流对象可以继续使用。close
:先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。
代码使用演示:
package com.dcxuexi.java23;import java.io.FileWriter;
import java.io.IOException;/**** @Title FWWrite02* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 21:17* @Version 1.0.0*/
public class FWWrite02 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write02.txt");// 写出数据,通过flushfileWriter.write('刷'); // 写出第1个字符fileWriter.flush();fileWriter.write('新'); // 继续写出第2个字符,写出成功fileWriter.flush();// 写出数据,通过closefileWriter.write('关'); // 写出第1个字符fileWriter.close();fileWriter.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closedfileWriter.close();}
}
小贴士:即便是
flush
方法写出了数据,操作的最后还是要调用close
方法,释放系统资源。
写出其他数据
- 写出字符数组 :
write(char[] cbuf) 和 write(char[] cbuf, int off, int len)
,每次可以写出字符数组中的数据,用法类似FileOutputStream
,代码使用演示:
package com.dcxuexi.java23;import java.io.FileWriter;
import java.io.IOException;/**** @Title FWWrite03* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 21:24* @Version 1.0.0*/
public class FWWrite03 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write03.txt");// 字符串转换为字节数组char[] chars = "我爱北京天安门".toCharArray();// 写出字符数组fileWriter.write(chars); // 我爱北京天安门// 写出从索引2开始,2个字节。索引2是'北',两个字节,也就是'北京'。fileWriter.write(chars,2,2); // 北京// 关闭资源fileWriter.close();}
}
- 写出字符串:
write(String str)
和write(String str, int off, int len)
,每次可以写出字符串中的数据,更为方便,代码使用演示:
package com.dcxuexi.java23;import java.io.FileWriter;
import java.io.IOException;/**** @Title FWWrite04* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 21:29* @Version 1.0.0*/
public class FWWrite04 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write04.txt");// 字符串String str = "石家庄赵子龙VS包头吕布VS枣庄兰陵王";// 写出字符数组fileWriter.write(str);// 写出从索引6开始,6个字节。索引6是'V',6个字节,也就是'VS包头吕布'。fileWriter.write(str,6,6);// 关闭资源fileWriter.close();}
}
- 续写和换行:操作类似于
FileOutputStream
。
package com.dcxuexi.java23;import java.io.FileWriter;
import java.io.IOException;/**** @Title FWWrite05* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 21:44* @Version 1.0.0*/
public class FWWrite05 {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\write04.txt",true);// 写出字符串String str ="VS合肥包拯";// 写出字符数组fileWriter.write(str);// 写出换行fileWriter.write("\r\n");// 写出字符串fileWriter.write("VS驻马店袁绍");// 关闭资源fileWriter.close();}
}
小贴士:
字符流,只能操作文本文件 ,不能操作图片,视频等非文本文件。
当我们单纯读或者写文本文件时,使用字符流,其他情况使用字节流
第四章 IO
异常的处理
JDK7
前处理
之前的入门练习,我们一直把异常抛出,而实际开发中并不能这样处理,建议使用try...catch...finally
代码块,处理异常部分,代码使用演示:
package com.dcxuexi.java23;import java.io.FileWriter;
import java.io.IOException;/**** @Title HandleException01* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 21:55* @Version 1.0.0*/
public class HandleException01 {public static void main(String[] args) {// 声明变量FileWriter fileWriter = null;try {//创建流对象fileWriter = new FileWriter("D:\\java\\javaCode\\File\\writeHandleException.txt");// 写出数据fileWriter.write("保定张翼德"); //保定张翼德} catch (IOException e) {e.printStackTrace();}finally {// 释放资源try {if (fileWriter != null){fileWriter.close();}} catch (IOException e) {e.printStackTrace();}}}
}
JDK7
的处理(扩展内容)
还可以使用JDK7
优化后的try-with-resource
语句,该语句确保了每个资源在语句结束时关闭。所谓的资源(resource
)是指在程序完成后,必须关闭的对象。
格式:
try (创建流对象语句,如果多个,使用';'隔开) {// 读写数据
} catch (IOException e) {e.printStackTrace();
}
代码使用演示:
package com.dcxuexi.java23;import java.io.FileWriter;
import java.io.IOException;/**** @Title HandleException02* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 22:05* @Version 1.0.0*/
public class HandleException02 {public static void main(String[] args) {// 创建流对象try (FileWriter fileWriter = new FileWriter("D:\\java\\javaCode\\File\\writeHandleException2.txt") ) {// 写出数据fileWriter.write("石家庄赵子龙"); //石家庄赵子龙} catch (IOException e) {e.printStackTrace();}}
}
JDK9
的改进(扩展内容)
JDK9
中try-with-resource
的改进,对于引入对象的方式,支持的更加简洁。被引入的对象,同样可以自动关闭,无需手动close
,我们来了解一下格式。
改进前格式:
// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式:创建新的变量保存
try (Resource r1 = resource1;Resource r2 = resource2) {// 使用对象
}
改进后格式:
// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");// 引入方式:直接引入
try (resource1; resource2) {// 使用对象
}
改进后,代码使用演示:
package com.dcxuexi.java23;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;/**** @Title TryDemo* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 22:13* @Version 1.0.0*/
public class TryDemo {public static void main(String[] args) throws IOException {// 创建流对象final FileReader fr = new FileReader("D:\\java\\javaCode\\File\\read.txt");FileWriter fw = new FileWriter("D:\\java\\javaCode\\File\\tryWrite.txt");// 引入到try中try (fr; fw) {// 定义变量int b;// 读取数据while ((b = fr.read())!=-1) {// 写出数据fw.write(b);}} catch (IOException e) {e.printStackTrace();}}
}
第五章 属性集
5.1 概述
java.util.Properties
继承于Hashtable
,来表示一个持久的属性集。它使用键值结构存储数据,每个键及其对应值都是一个字符串。该类也被许多Java
类使用,比如获取系统属性时,System.getProperties
方法就是返回一个Properties
对象。
5.2 Properties
类
构造方法
public Properties()
:创建一个空的属性列表。
基本的存储方法
public Object setProperty(String key, String value)
:保存一对属性。public String getProperty(String key)
:使用此属性列表中指定的键搜索属性值。public Set<String> stringPropertyNames()
:所有键的名称的集合。
package com.dcxuexi.java23;import java.util.Properties;
import java.util.Set;/**** @Title ProDemo* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 22:23* @Version 1.0.0*/
public class ProDemo {public static void main(String[] args) {// 创建属性集对象Properties properties = new Properties();// 添加键值对元素properties.setProperty("filename", "java.txt");properties.setProperty("length", "20221212");properties.setProperty("location", "D:\\java\\javaCode\\File\\read.txt");// 打印属性集对象System.out.println(properties);// 通过键,获取属性值System.out.println(properties.getProperty("filename"));System.out.println(properties.getProperty("length"));System.out.println(properties.getProperty("location"));// 遍历属性集,获取所有键的集合Set<String> strings = properties.stringPropertyNames();// 打印键值对for (String key : strings ) {System.out.println(key+" -- "+properties.getProperty(key));}}
}
与流相关的方法
public void load(InputStream inStream)
:从字节输入流中读取键值对。
参数中使用了字节输入流,通过流对象,可以关联到某文件上,这样就能够加载文本中的数据了。文本数据格式:
filename=java.txt
length=20221212
location=D:\\java\\javaCode\\File\\read.txt
加载代码演示:
package com.dcxuexi.java23;import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;/**** @Title ProDemo02* @Description TOTD* @Auter DongChuang* @Date 2022/12/12 22:33* @Version 1.0.0*/
public class ProDemo02 {public static void main(String[] args) throws IOException {// 创建属性集对象Properties pro = new Properties();// 加载文本中信息到属性集pro.load(new FileInputStream("D:\\java\\javaCode\\File\\properties.txt"));// 遍历集合并打印Set<String> strings = pro.stringPropertyNames();for (String key : strings ) {System.out.println(key + " -- " + pro.getProperty(key));}}
}
注:文本数据中如果有\
,需要使用\\
替换。因为在Java
中,反斜杠\
是一个特殊的转义字符,所以需要前面再加一个反斜杠\
,以表示转义。
小贴士:文本中的数据,必须是键值对形式,可以使用空格、等号、冒号等符号分隔。
Java基础:字节流、字符流相关推荐
- 学Java基础19 字符流 编码表 转换流 字符高效流 对象流 序列化 以及所有的IO流总结
一.字符流概述 1.字符流 就是用于来读写字符操作的流 2.字符流使用的原因: 使用字节流来读取文件中中文会出现乱码 因为中文不是一个字节组成的 所以读取中文的时候 需要使用字符流 字符实际上也是使用 ...
- java io 字节流 字符流
1.流的概念 在程序中,所有的数据都是以流的形式进行传输和保存的,当程序需要数据的时候要使用输入流读取数据,而当程序需要保存数据时要使用输出流写数据 2.字节流和字符流 字节流:处理单元为1个字节,操 ...
- java 字符流 utf8,JAVA基础(字符流设置编码读写字符)
1,使用指定的码表读写字符 FileReader是使用默认码表读取文件, 如果需要使用指定码表读取, 那么可以使用InputStreamReader(字节流,编码表) FileWriter是使用默认码 ...
- java基础---IO字符流
package com.henu.io;import java.io.FileNotFoundException; import java.io.FileReader;/** •FileReader( ...
- java基础练习复习二:递归字节流字符流二
本篇是基于java基础练习复习一:递归&字节流&字符流一, 如果对您有帮助 ,请多多支持.多少都是您的心意与支持,一分也是爱,再次感谢!!!打开支付宝首页搜"55672346 ...
- java基础 io流 字节流 字符流 节点流 包装流 转换流 缓冲流 对象流 打印流 Properties类
目录 1.概念 2.常用的文件操作 2.1 创建文件 2.2 获取文件相关信息 2.3 目录的操作和文件删除 3. IO流原理及流的分类 3.1 流的分类 4.InputStream 字节输入流 4. ...
- java基础学习_IO流03_字符流、IO流小结、案例_day21总结
java基础学习_IO流03_字符流.IO流小结.案例_day21总结 ================================================================ ...
- -1-4 java io java流 常用流 分类 File类 文件 字节流 字符流 缓冲流 内存操作流 合并序列流...
File类 •文件和目录路径名的抽象表示形式 构造方法 •public File(String pathname) •public File(String parent,Stringchild) •p ...
- io包下 文件类 字节流 字符流 缓冲流 转换流 序列化流 打印流
第一章 File类 1.1 概述 java.io.File 类是文件和目录路径名的抽象表示,主要用于文件和目录的创建.查找和删除等操作. 1.2 构造方法 public File(String pat ...
- 【java基础】IO流是啥?有啥用?(上)
今天我们说说java代码中对文件的操作,比如新建删除文件,读取文件内容等. File类 File类用于操作文件和目录,可对文件或目录进行新建,删除和重命名等操作.但是如果要访问文件内容本身,就需要用到 ...
最新文章
- 数据库中省区市组装成json_全国各省、市、县、镇、村的mysql数据库和JSON格式数据...
- python写魔兽世界脚本_用python bat写软件安装脚本 + HM NIS Edit自动生成软件安装脚本...
- 把SQL Server 错误日志导出为EXCEL 并发送到指定的ftp 或者 共享盘
- 大型网站系统架构实践(四)http层负载均衡之haproxy实践篇(一)
- oracle修改filesystem,oracle数据库 boost::filesystem使用例子
- Entity Framework 学习初级篇7--基本操作:增加、更新、删除、事务(转)
- 传奇电子cq9跳高高、跳起来规则与操作技巧
- 支付宝APP支付IOS手机端java后台版
- 信号完整性之传输线理论(三)
- 透明FLASH的插入方法
- LocalDate获取时间戳
- VMware虚拟机win7系统无法上网怎么办
- 坚果Pro2刷入twrp rec
- Android Studio 配置 Http Proxy
- 计算机测电阻伏安特性实验报告,《电学元件伏安特性的测量》实验报告附页
- 随机数的生成【详解】
- 将本地电脑做外网映射
- 麻省理工公开课《算法导论》学习笔记:第一讲
- Maven 虐我千百遍,我待 Maven 如初恋 侵删
- 神奇的魔术师——简单工厂模式
热门文章
- 数学模型学习——模糊关系与模糊矩阵
- 技术引路,设计领跑!三星下半场的“破浪”双桨
- php我赢职场季枫_我赢职场PHP全栈开发工程师就业班(H5/PC/移动/课件)
- Spring面试题(2022)
- spring自动装配的歧义性
- nanosleep php,PHP time_nanosleep( )用法及代码示例
- types 和 @types 是什么?
- 安卓手机如何防盗_来看看安卓手机对于AirPods的适配体验如何
- 8.【小萌伴Android】手电筒功能及其实现
- 键盘上ctrl各种快捷键大全(备案)