java基础之File、流
一、File类
我们可以使用File类的方法
创建一个文件/文件夹
删除文件/文件夹
获取文件/文件夹
判断文件/文件夹是否存在
对文件夹进行遍历
获取文件的大小
构造方法：
1.public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
2.public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例
3.public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例
public class FileTest2 {
public static void main(String[] args) {
File file1 = new File("D:\\workspace3\\jjavaBase_day03_string\\aa.txt");
System.out.println(file1);
File file2 = new File("D:\\workspace3\\jjavaBase_day03_string","aa.txt");
System.out.println(file2);
File file4 = new File("aa.txt"); //使用了相对路径
System.out.println(file4.getAbsolutePath());
}
}
例子：
public class FileTest {
public static void main(String[] args) {
/*
重点:记住这三个单词
file:文件
directory:文件夹/目录
path:路径
操作路径:路径不能写死了
C:\develop\a\a.txt windows
C:/develop/a/a.txt linux
"C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"
*/
String pathSeparator = File.pathSeparator;
System.out.println(pathSeparator); //路径分隔符 windows:分号; linux:冒号:
String separator = File.separator;
System.out.println(separator); // 文件名称分隔符 windows:反斜杠\ linux:正斜杠/
}
}
public class FileMethodDemo {
public static void main(String[] args) {
//创建文件对象
File file = new File("Test22.java");
//获取文件的绝对路径，即全路径
String absPath = file.getAbsolutePath();
//File中封装的路径是什么获取到的就是什么。
String path = file.getPath();
//获取文件名称
String filename = file.getName();
//获取文件大小
long size = file.length();
System.out.println("absPath="+absPath);
System.out.println("path="+path);
System.out.println("filename="+filename);
System.out.println("size="+size);
}
}
//absPath=D:\code\BigData\designPattern\Test22.java
//path=Test22.java
//filename=Test22.java
//size=0
public class FileMethodDemo2 {
public static void main(String[] args) throws IOException {
// 对文件或者文件加进行操作。
File file = new File("e:\\file.txt");
// 创建文件，如果文件不存在，创建 true 。 如果文件存在，则不创建 false。 如果路径错误，IOException。
boolean b1 = file.createNewFile();
System.out.println("b1=" + b1);
//-----------删除文件操作-------注意：不去回收站。慎用------
boolean b2 = file.delete();
System.out.println("b2="+b2);
//-----------需要判断文件是否存在------------
boolean b3 = file.exists();
System.out.println("b3="+b3);
//-----------对目录操作 创建，删除，判断------------
File dir = new File("e:\\abc");
//mkdir()创建单个目录。//dir.mkdirs();创建多级目录
boolean b4 = dir.mkdir();
System.out.println("b4="+b4);
//删除目录时，如果目录中有内容，无法直接删除。
boolean b5 = dir.delete();
//只有将目录中的内容都删除后，保证该目录为空。这时这个目录才可以删除。
System.out.println("b5=" + b5);
//-----------判断文件，目录------------
File f = new File("e:\\javahaha");// 要判断是否是文件还是目录，必须先判断存在。
// f.mkdir();//f.createNewFile();
System.out.println(f.isFile());
System.out.println(f.isDirectory());
}
}
//b1=true
//b2=true
//b3=false
//b4=true
//b5=true
//false
//false
二、绝对路径与相对路径
public class FileTest1 {
public static void main(String[] args) {
/*
路径:
绝对路径:是一个完整的路径
以盘符(c:,D:)开始的路径
c:\\a.txt
D:\\workspace3\\jjavaBase_day03_string
D:\\demo\\b.txt
相对路径:是一个简化的路径
相对指的是相对于当前项目的根目录(D:\\workspace3\\jjavaBase_day03_string)
如果使用当前项目的根目录,路径可以简化书写
D:\\workspace3\\jjavaBase_day03_string\\123.txt-->简化为: 123.txt(可以省略项目的根目录)
注意:
1.路径是不区分大小写
2.路径中的文件名称分隔符windows使用反斜杠,反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠
例子： c:\\a.txt(在项目中路径的书写方式)==c:\a.txt(本地电脑真实路径书写方式)
*/
}
}
三、常用方法
获取功能的方法：
public String getAbsolutePath() ：返回此File的绝对路径名字符串（无论构造方法中传入是相当路径还是绝对路径，都返回的是绝对路径）
public String getPath() ：将此File转换为路径名字符串（在构造方法中传入什么路径就返回什么路径）
public String getName() ：返回由此File表示的文件或目录的名称（获取的就是构造方法传递路径的结尾部分【文件/文件夹】）
public long length() ：返回由此File表示的文件的长度（获取的是构造方法指定的文件的大小,以字节为单位）
注意:
文件夹是没有大小概念的,不能获取文件夹的大小
如果构造方法中给出的路径不存在,那么length方法返回0
例子：
public class FileTest2 {
public static void main(String[] args) {
File file1 = new File("D:\\workspace3\\jjavaBase_day03_string\\aa.txt");
System.out.println(file1.getAbsolutePath());
System.out.println(file1.getPath());
File file2 = new File("aa.txt");
System.out.println(file2.getAbsolutePath());
System.out.println(file2.getPath());
File file3 = new File("D:\\workspace3\\jjavaBase_day03_string\\bb.txt");
System.out.println(file3.getName());
}
}
判断功能的方法：
public boolean exists() ：此File表示的文件或目录是否实际存在（用于判断构造方法中的路径是否真实存在）
public boolean isDirectory() ：此File表示的是否为目录（用于判断构造方法中给定的路径是否以【文件夹】结尾）
public boolean isFile() ：此File表示的是否为文件（用于判断构造方法中给定的路径是否以【文件】结尾）
注意:
电脑的硬盘中只有文件/文件夹,两个方法是互斥
这两个方法使用前提,路径必须是存在的,否则都返回false
例子：
public class FileTest3 {
public static void main(String[] args) {
File file1 = new File("D:\\workspace3\\jjavaBase_day03_string\\tt.txt");
System.out.println(file1.exists());
if(file1.exists()){
System.out.println(file1.isFile());
System.out.println(file1.isDirectory());
}
}
}
创建删除功能的方法：
public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件
创建文件的路径和名称在构造方法中给出(构造方法的参数)
返回值:布尔值
true:文件不存在,创建文件,返回true
false:文件存在,不会创建,返回false
注意:
1.此方法只能创建文件,不能创建文件夹
2.创建文件的路径必须存在,否则会抛出异常
public boolean delete() ：删除由此File表示的文件或目录（可以删除构造方法路径中给出的文件/文件夹）
此方法,可以删除构造方法路径中给出的文件/文件夹
返回值:布尔值
true:文件/文件夹删除成功,返回true
false:文件夹中有内容,不会删除返回false;构造方法中路径不存在false
注意:
delete方法是直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎
public boolean mkdir() ：创建由此File表示的目录（创建单级空文件夹）
返回值:布尔值
true:文件夹不存在,创建文件夹,返回true
false:文件夹存在,不会创建,返回false;构造方法中给出的路径不存在返回false
注意:
1.此方法只能创建文件夹,不能创建文件
public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录
既可以创建单级空文件夹,也可以创建多级文件夹
创建文件夹的路径和名称在构造方法中给出(构造方法的参数)
返回值:布尔值
true:文件夹不存在,创建文件夹,返回true
false:文件夹存在,不会创建,返回false;构造方法中给出的路径不存在返回false
注意:
1.此方法只能创建文件夹,不能创建文件
例子：
public class FileTest4 {
public static void main(String[] args) throws IOException {
File file1 = new File("D:\\workspace3\\jjavaBase_day03_string\\src\\1.txt"); //绝对路径
boolean b = file1.createNewFile();
System.out.println(b);
File file2 = new File("src\\2.txt"); //相对路径
boolean b1 = file2.createNewFile();
System.out.println(b1);
File file3 = new File("src\\aa"); //相对路径
System.out.println(file3.mkdir());
File file4 = new File("src\\aa\\bb");
System.out.println(file4.mkdirs());
}
}
四、I/O流
根据数据的流向分为：输入流和输出流
输入流 ：把数据从 其他设备 上读取到 内存 中的流
输出流 ：把数据从 内存 中写出到 其他设备 上的流
格局数据的类型分为：字节流和字符流【1个字符=2个字节，1个字节=8个二进制】
字节流 ：以字节为单位，读写数据的流
字符流 ：以字符为单位，读写数据的流
顶级父类们：
五、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) ：把字节数组的一部分写入到文件中
int off:数组的开始索引
int len:写几个字节
public abstract void write(int b) ：将指定的字节输出流（只能一次写入一个字节）
java.io.FileOutputStream extends OutputStream
FileOutputStream:文件字节输出流
作用:把内存中的数据写入到硬盘的文件中
构造方法:
FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
追加写/续写:使用两个参数的构造方法
FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
参数:
String name,File file:写入数据的目的地
boolean append:追加写开关
true:创建对象不会覆盖源文件,继续在文件的末尾追加写数据
false:创建一个新文件,覆盖源文件
参数:写入数据的目的
String name:目的地是一个文件的路径
File file:目的地是一个文件
构造方法的作用:
1.创建一个FileOutputStream对象
2.会根据构造方法中传递的文件/文件路径,创建一个空的文件
3.会把FileOutputStream对象指向创建好的文件
写入数据的原理(内存-->硬盘)
java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中
字节输出流的使用步骤(重点):
1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
2.调用FileOutputStream对象中的方法write,把数据写入到文件中
3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
系统中的换行：
Windows系统里，每行结尾是 回车+换行 ，即 \r\n ；
linux系统里，每行结尾只有 换行 ，即 \n ；
Mac系统里，每行结尾是 回车 ，即 \r 。从 Mac OS X开始与Linux统一
例子：
public class FileOutputStreamTest {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("src\\aa.txt"); //相对路径
fos.write(97);
fos.close();
FileOutputStream fos1 = new FileOutputStream("src\\cc.txt"); //相对路径
String str1 = "ABCD";
byte[] bytes = str1.getBytes(); //使用String类中的方法把字符串,转换为字节数组
System.out.println(Arrays.toString(bytes)); //使用Arrays将字节数组，转换字符串
fos1.write(bytes);
fos1.close();
FileOutputStream fos3 = new FileOutputStream("src\\bb.txt"); //相对路径
String str2 = "ABCD";
byte[] bytes1 = str2.getBytes(); //使用String类中的方法把字符串,转换为字节数组
fos3.write(bytes1,0,2);
fos3.close();
FileOutputStream fos4 = new FileOutputStream("src\\dd.txt"); //相对路径
byte[] bytes = {97,98,99,100,101};
for (int i = 0; i < bytes.length; i++) {
fos4.write(bytes[i]);
// 写出一个换行, 换行符号转成数组写出
fos4.write("\r\n".getBytes());
}
fos4.close();
}
}
六、InputStream类
java.io.InputStream:字节输入流
此抽象类是表示字节输入流的所有类的超类
定义了父类的成员方法：
int read()从输入流中读取数据的下一个字节【读取文件中的一个字节并返回,读取到文件的末尾返回-1】
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
参数：
1.方法的参数byte[]的作用?
起到缓冲作用,设置每次读取的字节数，并将其存放到byte[]数组中
数组的长度一把定义为1024(1kb)或者1024的整数倍
2.方法的返回值int是什么?
每次读取到的字节个数
void close() 关闭此输入流并释放与该流关联的所有系统资源
java.io.FileInputStream extends InputStream
FileInputStream:文件字节输入流
作用:把硬盘文件中的数据,读取到内存中使用
构造方法:
FileInputStream(String name)
FileInputStream(File file)
参数:读取文件的数据源
String name:文件的路径
File file:文件
构造方法的作用:
1.会创建一个FileInputStream对象
2.会把FileInputStream对象指定构造方法中要读取的文件
读取数据的原理(硬盘-->内存)
java程序-->JVM-->OS-->OS读取数据的方法-->读取文件
字节输入流的使用步骤(重点):
1.创建FileInputStream对象,构造方法中绑定要读取的数据源
2.使用FileInputStream对象中的方法read,读取文件
3.释放资源
String类的构造方法
String(byte[] bytes) :把字节数组转换为字符串
String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数
例子：
public class FileInputStreamTest {
public static void main(String[] args)throws IOException {
FileInputStream fis = new FileInputStream("src\\aa.txt");
/*
System.out.println("....第一次读....");
int len1 = fis.read();
System.out.println(len1); //98
System.out.println("....第二次读....");
int len2 = fis.read();
System.out.println(len2); //97
System.out.println("....第三次读....");
int len3 = fis.read();
System.out.println(len3); //-1
*/
int len;
while((len = fis.read())!=-1){
System.out.println(len);
}
int len;
byte[] bytes = new byte[1024];
while((len=fis.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
fis.close();
}
}
七、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() 关闭此流，但要先刷新它。
flush方法和close方法的区别
flush ：刷新缓冲区，流对象可以继续使用。
close: 先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
java.io.FileWriter extends OutputStreamWriter extends Writer
FileWriter:文件字符输出流
作用:把内存中字符数据写入到文件中
构造方法:
FileWriter(File file)根据给定的 File 对象构造一个 FileWriter 对象。
FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。
FileWriter(String fileName, boolean append)
参数:写入数据的目的地
String fileName:文件的路径
File file:是一个文件
append:追加写开关
构造方法的作用:
1.会创建一个FileWriter对象
2.会根据构造方法中传递的文件/文件的路径,创建文件
3.会把FileWriter对象指向创建好的文件
字符输出流的使用步骤(重点):
1.创建FileWriter对象,构造方法中绑定要写入数据的目的地
2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中
4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
例子：
public class FileWriterTest {
public static void main(String[] args)throws IOException {
FileWriter fw = new FileWriter("src\\aa.txt");
char[] cs = {'a','b','c','d','e'};
fw.write("你好");
fw.flush(); //刷新之后流可以继续使用
fw.write("IO流");
fw.flush(); //刷新之后流可以继续使用
fw.write(cs,0,4);
fw.close();//释放资源(会先把内存缓冲区中的数据刷新到文件中),流就不能再使用了
}
}
八、Reader类
java.io.Reader:字符输入流
是字符输入流的最顶层的父类,定义了一些共性的成员方法,是一个抽象类
该类的成员方法
int read() 读取单个字符并返回。
int read(char[] cbuf)一次读取多个字符,将字符读入数组。
void close() 关闭该流并释放与之关联的所有资源
java.io.FileReader extends InputStreamReader extends Reader
FileReader:文件字符输入流
作用:把硬盘文件中的数据以字符的方式读取到内存中
构造方法:
FileReader(String fileName)
FileReader(File file)
参数:读取文件的数据源
String fileName:文件的路径
File file:一个文件
FileReader构造方法的作用:
1.创建一个FileReader对象
2.会把FileReader对象指向要读取的文件
字符输入流的使用步骤:
1.创建FileReader对象,构造方法中绑定要读取的数据源
2.使用FileReader对象中的方法read读取文件
3.释放资源
String类的构造方法
String(char[] value) 把字符数组转换为字符串
String(char[] value, int offset, int count) 把字符数组的一部分转换为字符串 offset数组的开始索引 count转换的个数
例子：
public class FileReaderTest {
public static void main(String[] args)throws IOException {
FileReader fr = new FileReader("src\\aa.txt");
char[] chars = new char[1024];
int len;
while ((len=fr.read(chars))!=-1){
System.out.println(new String(chars,0,len));
}
}
}
九、IO异常的处理
在jdk1.7之前使用try catch finally 处理流中的异常
格式：
try{
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}finally{
一定会指定的代码
资源释放
}
例子：
public class FileWriterTest {
public static void main(String[] args) {
//提高变量fw的作用域,让finally可以使用
//变量在定义的时候,可以没有值,但是使用的时候必须有值
//fw = new FileWriter("09_IOAndProperties\\g.txt",true); 执行失败,fw没有值,fw.close会报错
FileWriter fw = null;
try {
fw = new FileWriter("src\\aa.txt", true);
char[] cs = {'a', 'b', 'c', 'd', 'e'};
fw.write(cs,0,3);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fw != null) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
JDK7的新特性
在try的后边可以增加一个(),在括号中可以定义流对象
那么这个流对象的作用域就在try中有效
try中的代码执行完毕,会自动把流对象释放,不用写finally
格式:
try(定义流对象;定义流对象....){
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
例子：
public class FileWriterTest {
public static void main(String[] args) {
try (FileWriter fw = new FileWriter("src\\aa.txt", true)) {
char[] cs = {'a', 'b', 'c', 'd', 'e'};
fw.write(cs, 0, 3);
} catch (IOException e) {
//异常的处理逻辑
e.printStackTrace();
}
}
}
十、BufferedOutputStream类
java.io.BufferedOutputStream extends FilterOutputStream extends OutputStream
BufferedOutputStream:字节缓冲输出流
父类的成员方法
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) ：将指定的字节输出流
构造方法:
BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
参数:
OutputStream out:字节输出流
我们可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区,提高FileOutputStream的写入效率
int size:指定缓冲流内部缓冲区的大小,不指定默认
使用步骤(重点)
1.创建FileOutputStream对象,构造方法中绑定要输出的目的地
2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象对象,提高FileOutputStream对象效率
3.使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
4.使用BufferedOutputStream对象中的方法flush,把内部缓冲区中的数据,刷新到文件中
5.释放资源(会先调用flush方法刷新数据,第4部可以省略)
例子：
public class Demo01BufferedOutputStream {
public static void main(String[] args) throws IOException {
//1.创建FileOutputStream对象,构造方法中绑定要输出的目的地
FileOutputStream fos = new FileOutputStream("10_IO\\a.txt");
//2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象对象,提高FileOutputStream对象效率
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3.使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
bos.write("我把数据写入到内部缓冲区中".getBytes());
//4.使用BufferedOutputStream对象中的方法flush,把内部缓冲区中的数据,刷新到文件中
bos.flush();
//5.释放资源(会先调用flush方法刷新数据,第4部可以省略)
bos.close();
}
}
十一、BufferedInputStream类
java.io.BufferedInputStream extends FilterInputStream extends InputStream
BufferedInputStream:字节缓冲输入流
父类的成员方法
int read()从输入流中读取数据的下一个字节。
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
void close() 关闭此输入流并释放与该流关联的所有系统资源。
构造方法:
BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
参数:
InputStream in:字节输入流
我们可以传递FileInputStream,缓冲流会给FileInputStream增加一个缓冲区,提高FileInputStream的读取效率
int size:指定缓冲流内部缓冲区的大小,不指定默认
使用步骤(重点):
1.创建FileInputStream对象,构造方法中绑定要读取的数据源
2.创建BufferedInputStream对象,构造方法中传递FileInputStream对象,提高FileInputStream对象的读取效率
3.使用BufferedInputStream对象中的方法read,读取文件
4.释放资源
例子：
public class BufferedInputStreamTest {
public static void main(String[] args) throws IOException {
InputStream is = new FileInputStream("src\\aa.txt");
BufferedInputStream bis = new BufferedInputStream(is);
byte[] bytes = new byte[1024];
int len = 0; //记录每次读取的有效字节个数,这里设置为1024个字节
while((len=bis.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
bis.close();
}
}
十二、BufferedWriter类
java.io.BufferedWriter extends Writer
BufferedWriter:字符缓冲输出流
继承自父类的共性成员方法:
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() 关闭此流，但要先刷新它。
构造方法:
BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
参数:
Writer out:字符输出流
我们可以传递FileWriter,缓冲流会给FileWriter增加一个缓冲区,提高FileWriter的写入效率
int sz:指定缓冲区的大小,不写默认大小
特有的成员方法:
void newLine() 写入一个行分隔符。会根据不同的操作系统,获取不同的行分隔符
换行:换行符号
windows:\r\n
linux:/n
mac:/r
使用步骤:
1.创建字符缓冲输出流对象,构造方法中传递字符输出流
2.调用字符缓冲输出流中的方法write,把数据写入到内存缓冲区中
3.调用字符缓冲输出流中的方法flush,把内存缓冲区中的数据,刷新到文件中
4.释放资源
例子 ：
public class BufferedWriterTest {
public static void main(String[] args)throws IOException {
FileWriter fw = new FileWriter("src\\aa.txt");
BufferedWriter bw = new BufferedWriter(fw);
for(int i=1;i<10;i++){
bw.write("江南");
bw.newLine(); //换行：bw.write("\r\n");
}
bw.flush(); //调用字符缓冲输出流中的方法flush,把内存缓冲区中的数据,刷新到文件中
bw.close();
}
}
十三、BufferedReader类
java.io.BufferedReader extends Reader
BufferedReader:字符缓冲输入流
父类的成员方法:
int read() 读取单个字符并返回。
int read(char[] cbuf)一次读取多个字符,将字符读入数组。
void close() 关闭该流并释放与之关联的所有资源。
构造方法:
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
参数:
Reader in:字符输入流
我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区,提高FileReader的读取效率
特有的成员方法:
String readLine() 读取一个文本行。读取一行数据
行的终止符号:通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行(\r\n)。
返回值:
包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
使用步骤:
1.创建字符缓冲输入流对象,构造方法中传递字符输入流
2.使用字符缓冲输入流对象中的方法read/readLine读取文本
3.释放资源
例子：
public class BufferedReaderTest {
public static void main(String[] args)throws IOException {
Reader r = new FileReader("src\\aa.txt");
BufferedReader br = new BufferedReader(r);
char[] chars = new char[1024];
int len = 0;
while((len=br.read(chars))!=-1){
System.out.println(new String(chars,0,len));
}
br.close();
}
}
十四、ObjectOutputStream类
序列化视图解析
序列化操作
1. 一个对象要想序列化，必须满足两个条件:
该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出
NotSerializableException
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。
例子：
public class Employee implements java.io.Serializable {
// 加入序列版本号，解决：正序列化与反序列化转换发生冲突问题
private static final long serialVersionUID = 1L;
private String name;
private String address;
private transient int age; // transient瞬态修饰成员,不会被序列化
public void addressCheck() {
System.out.println("Address check : " + name + " ‐‐ " + address);
}
}
java.io.ObjectOutputStream：将Java对象写出到文件,实现对象的持久存储
构造方法
public ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream
ObjectOutputStream的成员方法
public final void writeObject (Object obj) : 将指定的对象写出
例子：
public class SerializeDemo {
public static void main(String[] args)throws IOException {
Employee e = new Employee();
e.setName("请问天");
e.setAddress("北京");
e.setAge(20);
OutputStream os = new FileOutputStream("src\\aa.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(e); //将对象写入文件中
oos.close();
os.close();
System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化
}
}
十五、ObjectInputStream类
java.io.ObjectInputStream extends InputStream
ObjectInputStream:对象的反序列化流
作用:把文件中保存的对象,以流的方式读取出来使用
构造方法:
ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。
参数:
InputStream in:字节输入流
特有的成员方法:
Object readObject() 从 ObjectInputStream 读取对象。
使用步骤:
1.创建ObjectInputStream对象,构造方法中传递字节输入流
2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
3.释放资源
4.使用读取出来的对象(打印)
readObject方法声明抛出了ClassNotFoundException(class文件找不到异常)
当不存在对象的class文件时抛出此异常
反序列化的前提:
1.类必须实现Serializable
2.必须存在类对应的class文件
例子：
